draft for SkColorFilter to DlColorFilter

JsouLiang · JsouLiang · commit e242a80f321e · 2022-07-21T16:33:40.000+08:00
diff --git a/display_list/display_list_builder.cc b/display_list/display_list_builder.cc
@@ -493,26 +493,6 @@ void DisplayListBuilder::saveLayer(const SkRect* bounds,
   }
 }
 
-void DisplayListBuilder::saveLayerCF(const SkRect* bounds,
-                                     const SaveLayerOptions in_options,
-                                     const DlColorFilter* color_filter) {
-  SaveLayerOptions options = in_options.without_optimizations();
-  size_t save_layer_offset = used_;
-  if (color_filter) {
-    bounds  //
-        ? Push<SaveLayerColorFilterBoundsOp>(0, 1, *bounds, options,
-                                             color_filter)
-        : Push<SaveLayerColorFilterOp>(0, 1, options, color_filter);
-  } else {
-    bounds  //
-        ? Push<SaveLayerBoundsOp>(0, 1, *bounds, options)
-        : Push<SaveLayerOp>(0, 1, options);
-  }
-  CheckLayerOpacityCompatibility(options.renders_with_attributes());
-  layer_stack_.emplace_back(current_layer_, save_layer_offset, true);
-  current_layer_ = &layer_stack_.back();
-}
-
 void DisplayListBuilder::saveLayer(const SkRect* bounds,
                                    const DlPaint* paint,
                                    const DlImageFilter* backdrop) {
@@ -525,18 +505,6 @@ void DisplayListBuilder::saveLayer(const SkRect* bounds,
   }
 }
 
-void DisplayListBuilder::saveLayer(const SkRect* bounds,
-                                   const DlPaint* paint,
-                                   const DlColorFilter* color_filter) {
-  if (paint != nullptr) {
-    setAttributesFromDlPaint(*paint,
-                             DisplayListOpFlags::kSaveLayerWithPaintFlags);
-    saveLayerCF(bounds, SaveLayerOptions::kWithAttributes, color_filter);
-  } else {
-    saveLayerCF(bounds, SaveLayerOptions::kNoAttributes, color_filter);
-  }
-}
-
 void DisplayListBuilder::translate(SkScalar tx, SkScalar ty) {
   if (SkScalarIsFinite(tx) && SkScalarIsFinite(ty) &&
       (tx != 0.0 || ty != 0.0)) {
diff --git a/display_list/display_list_builder.h b/display_list/display_list_builder.h
@@ -159,10 +159,6 @@ class DisplayListBuilder final : public virtual Dispatcher,
   void saveLayer(const SkRect* bounds,
                  const SaveLayerOptions options,
                  const DlImageFilter* backdrop) override;
-
-  void saveLayerCF(const SkRect* bounds,
-                   const SaveLayerOptions options,
-                   const DlColorFilter* backdrop) override;
   // Convenience method with just a boolean to indicate whether the saveLayer
   // should apply the rendering attributes.
   void saveLayer(const SkRect* bounds, bool renders_with_attributes) {
@@ -175,9 +171,6 @@ class DisplayListBuilder final : public virtual Dispatcher,
                  const DlPaint* paint,
                  const DlImageFilter* backdrop = nullptr);
 
-  void saveLayer(const SkRect* bounds,
-                 const DlPaint* paint,
-                 const DlColorFilter* color_filter);
   void restore() override;
   int getSaveCount() { return layer_stack_.size(); }
   void restoreToCount(int restore_count);
diff --git a/display_list/display_list_canvas_dispatcher.cc b/display_list/display_list_canvas_dispatcher.cc
@@ -73,27 +73,6 @@ void DisplayListCanvasDispatcher::saveLayer(const SkRect* bounds,
   }
 }
 
-void DisplayListCanvasDispatcher::saveLayerCF(
-    const SkRect* bounds,
-    const SaveLayerOptions options,
-    const DlColorFilter* color_filter) {
-  if (bounds == nullptr && options.can_distribute_opacity() &&
-      color_filter == nullptr) {
-    canvas_->save();
-    save_opacity(options.renders_with_attributes() ? combined_opacity()
-                                                   : opacity());
-  } else {
-    TRACE_EVENT0("flutter", "Canvas::saveLayer");
-    const SkPaint* paint = safe_paint(options.renders_with_attributes());
-    if (bounds) {
-      canvas_->saveLayer(*bounds, paint);
-      // saveLayer will apply the current opacity on behalf of the children
-      // so they will inherit an opaque opacity.
-      save_opacity(SK_Scalar1);
-    }
-  }
-}
-
 void DisplayListCanvasDispatcher::translate(SkScalar tx, SkScalar ty) {
   canvas_->translate(tx, ty);
 }
diff --git a/display_list/display_list_canvas_dispatcher.h b/display_list/display_list_canvas_dispatcher.h
@@ -33,9 +33,6 @@ class DisplayListCanvasDispatcher : public virtual Dispatcher,
   void saveLayer(const SkRect* bounds,
                  const SaveLayerOptions options,
                  const DlImageFilter* backdrop) override;
-  void saveLayerCF(const SkRect* bounds,
-                   const SaveLayerOptions options,
-                   const DlColorFilter* color_filter) override;
 
   void translate(SkScalar tx, SkScalar ty) override;
   void scale(SkScalar sx, SkScalar sy) override;
diff --git a/display_list/display_list_complexity_gl.cc b/display_list/display_list_complexity_gl.cc
@@ -64,22 +64,6 @@ void DisplayListGLComplexityCalculator::GLHelper::saveLayer(
   save_layer_count_++;
 }
 
-void DisplayListGLComplexityCalculator::GLHelper::saveLayerCF(
-    const SkRect* bounds,
-    const SaveLayerOptions options,
-    const DlColorFilter* color_filter) {
-  if (IsComplex()) {
-    return;
-  }
-  if (color_filter) {
-    // Flutter does not offer this operation so this value can only ever be
-    // non-null for a frame-wide builder which is not currently evaluated for
-    // complexity.
-    AccumulateComplexity(Ceiling());
-  }
-  save_layer_count_++;
-}
-
 void DisplayListGLComplexityCalculator::GLHelper::drawLine(const SkPoint& p0,
                                                            const SkPoint& p1) {
   if (IsComplex()) {
diff --git a/display_list/display_list_complexity_gl.h b/display_list/display_list_complexity_gl.h
@@ -40,9 +40,6 @@ class DisplayListGLComplexityCalculator
     void saveLayer(const SkRect* bounds,
                    const SaveLayerOptions options,
                    const DlImageFilter* backdrop) override;
-    void saveLayerCF(const SkRect* bounds,
-                     const SaveLayerOptions options,
-                     const DlColorFilter* backdrop) override;
 
     void drawLine(const SkPoint& p0, const SkPoint& p1) override;
     void drawRect(const SkRect& rect) override;
diff --git a/display_list/display_list_complexity_metal.cc b/display_list/display_list_complexity_metal.cc
@@ -78,22 +78,6 @@ void DisplayListMetalComplexityCalculator::MetalHelper::saveLayer(
   save_layer_count_++;
 }
 
-void DisplayListMetalComplexityCalculator::MetalHelper::saveLayerCF(
-    const SkRect* bounds,
-    const SaveLayerOptions options,
-    const DlColorFilter* color_filter) {
-  if (IsComplex()) {
-    return;
-  }
-  if (color_filter) {
-    // Flutter does not offer this operation so this value can only ever be
-    // non-null for a frame-wide builder which is not currently evaluated for
-    // complexity.
-    AccumulateComplexity(Ceiling());
-  }
-  save_layer_count_++;
-}
-
 void DisplayListMetalComplexityCalculator::MetalHelper::drawLine(
     const SkPoint& p0,
     const SkPoint& p1) {
diff --git a/display_list/display_list_complexity_metal.h b/display_list/display_list_complexity_metal.h
@@ -41,10 +41,6 @@ class DisplayListMetalComplexityCalculator
                    const SaveLayerOptions options,
                    const DlImageFilter* backdrop) override;
 
-    void saveLayerCF(const SkRect* bounds,
-                     const SaveLayerOptions options,
-                     const DlColorFilter* color_filter) override;
-
     void drawLine(const SkPoint& p0, const SkPoint& p1) override;
     void drawRect(const SkRect& rect) override;
     void drawOval(const SkRect& bounds) override;
diff --git a/display_list/display_list_dispatcher.h b/display_list/display_list_dispatcher.h
@@ -76,10 +76,6 @@ class Dispatcher {
                          const SaveLayerOptions options,
                          const DlImageFilter* backdrop = nullptr) = 0;
 
-  virtual void saveLayerCF(const SkRect* bounds,
-                           const SaveLayerOptions options,
-                           const DlColorFilter* backdrop = nullptr) = 0;
-
   virtual void restore() = 0;
 
   virtual void translate(SkScalar tx, SkScalar ty) = 0;
diff --git a/display_list/display_list_ops.h b/display_list/display_list_ops.h
@@ -344,55 +344,6 @@ struct SaveLayerBackdropBoundsOp final : DLOp {
                : DisplayListCompare::kNotEqual;
   }
 };
-
-// 4 byte header + 20 byte payload packs into minimum 24 bytes
-struct SaveLayerColorFilterOp final : DLOp {
-  static const auto kType = DisplayListOpType::kSaveLayerBackdrop;
-
-  explicit SaveLayerColorFilterOp(const SaveLayerOptions options,
-                                  const DlColorFilter* color_filter)
-      : options(options), color_filter(color_filter->shared()) {}
-
-  SaveLayerOptions options;
-  const std::shared_ptr<DlColorFilter> color_filter;
-
-  void dispatch(Dispatcher& dispatcher) const {
-    dispatcher.saveLayerCF(nullptr, options, color_filter.get());
-  }
-
-  DisplayListCompare equals(const SaveLayerColorFilterOp* other) const {
-    return options == other->options &&
-                   Equals(color_filter, other->color_filter)
-               ? DisplayListCompare::kEqual
-               : DisplayListCompare::kNotEqual;
-  }
-};
-
-// 4 byte header + 36 byte payload packs evenly into 36 bytes
-struct SaveLayerColorFilterBoundsOp final : DLOp {
-  static const auto kType = DisplayListOpType::kSaveLayerBackdropBounds;
-
-  SaveLayerColorFilterBoundsOp(SkRect rect,
-                               const SaveLayerOptions options,
-                               const DlColorFilter* color_filter)
-      : options(options), rect(rect), color_filter(color_filter->shared()) {}
-
-  SaveLayerOptions options;
-  const SkRect rect;
-  const std::shared_ptr<DlColorFilter> color_filter;
-
-  void dispatch(Dispatcher& dispatcher) const {
-    dispatcher.saveLayerCF(&rect, options, color_filter.get());
-  }
-
-  DisplayListCompare equals(const SaveLayerColorFilterBoundsOp* other) const {
-    return (options == other->options && rect == other->rect &&
-            Equals(color_filter, other->color_filter))
-               ? DisplayListCompare::kEqual
-               : DisplayListCompare::kNotEqual;
-  }
-};
-
 // 4 byte header + no payload uses minimum 8 bytes (4 bytes unused)
 struct RestoreOp final : DLOp {
   static const auto kType = DisplayListOpType::kRestore;
diff --git a/display_list/display_list_unittests.cc b/display_list/display_list_unittests.cc
@@ -1645,13 +1645,6 @@ class SaveLayerOptionsExpector : public virtual Dispatcher,
     save_layer_count_++;
   }
 
-  void saveLayerCF(const SkRect* bounds,
-                   const SaveLayerOptions options,
-                   const DlColorFilter* color_filter) override {
-    EXPECT_EQ(options, expected_[save_layer_count_]);
-    save_layer_count_++;
-  }
-
   int save_layer_count() { return save_layer_count_; }
 
  private:
diff --git a/display_list/display_list_utils.cc b/display_list/display_list_utils.cc
@@ -346,42 +346,6 @@ void DisplayListBoundsCalculator::saveLayer(const SkRect* bounds,
   }
 }
 
-void DisplayListBoundsCalculator::saveLayerCF(
-    const SkRect* bounds,
-    const SaveLayerOptions options,
-    const DlColorFilter* color_filter) {
-  SkMatrixDispatchHelper::save();
-  ClipBoundsDispatchHelper::save();
-  if (options.renders_with_attributes()) {
-    // The actual flood of the outer layer clip will occur after the
-    // (eventual) corresponding restore is called, but rather than
-    // remember this information in the LayerInfo until the restore
-    // method is processed, we just mark the unbounded state up front.
-    if (!paint_nops_on_transparency()) {
-      // We will fill the clip of the outer layer when we restore
-      AccumulateUnbounded();
-    }
-
-    layer_infos_.emplace_back(
-        std::make_unique<LayerData>(accumulator_, image_filter_));
-  } else {
-    layer_infos_.emplace_back(
-        std::make_unique<LayerData>(accumulator_, nullptr));
-  }
-
-  accumulator_ = layer_infos_.back()->layer_accumulator();
-
-  // Even though Skia claims that the bounds are only a hint, they actually
-  // use them as the temporary layer bounds during rendering the layer, so
-  // we set them as if a clip operation were performed.
-  if (bounds) {
-    clipRect(*bounds, SkClipOp::kIntersect, false);
-  }
-  if (color_filter) {
-    AccumulateUnbounded();
-  }
-}
-
 void DisplayListBoundsCalculator::restore() {
   if (layer_infos_.size() > 1) {
     SkMatrixDispatchHelper::restore();
diff --git a/display_list/display_list_utils.h b/display_list/display_list_utils.h
@@ -98,9 +98,6 @@ class IgnoreDrawDispatchHelper : public virtual Dispatcher {
   void saveLayer(const SkRect* bounds,
                  const SaveLayerOptions options,
                  const DlImageFilter* backdrop) override {}
-  void saveLayerCF(const SkRect* bounds,
-                   const SaveLayerOptions options,
-                   const DlColorFilter* color_filter) override {}
   void restore() override {}
   void drawColor(DlColor color, DlBlendMode mode) override {}
   void drawPaint() override {}
@@ -415,9 +412,6 @@ class DisplayListBoundsCalculator final
   void saveLayer(const SkRect* bounds,
                  const SaveLayerOptions options,
                  const DlImageFilter* backdrop) override;
-  void saveLayerCF(const SkRect* bounds,
-                   const SaveLayerOptions options,
-                   const DlColorFilter* color_filter) override;
   void restore() override;
 
   void drawPaint() override;
diff --git a/flow/layers/color_filter_layer.cc b/flow/layers/color_filter_layer.cc
@@ -4,6 +4,8 @@
 
 #include "flutter/flow/layers/color_filter_layer.h"
 #include <cstddef>
+#include "flutter/display_list/display_list_comparable.h"
+#include "flutter/display_list/display_list_paint.h"
 #include "flutter/flow/raster_cache_item.h"
 #include "flutter/flow/raster_cache_util.h"
 
@@ -13,15 +15,14 @@ ColorFilterLayer::ColorFilterLayer(std::shared_ptr<const DlColorFilter> filter)
     : CacheableContainerLayer(
           RasterCacheUtil::kMinimumRendersBeforeCachingFilterLayer,
           true),
-      sk_filter_(filter ? filter->skia_object() : nullptr),
       filter_(std::move(filter)) {}
 
 void ColorFilterLayer::Diff(DiffContext* context, const Layer* old_layer) {
   DiffContext::AutoSubtreeRestore subtree(context);
   auto* prev = static_cast<const ColorFilterLayer*>(old_layer);
   if (!context->IsSubtreeDirty()) {
     FML_DCHECK(prev);
-    if (filter_ != prev->filter_) {
+    if (NotEquals(filter_, prev->filter_)) {
       context->MarkSubtreeDirty(context->GetOldLayerPaintRegion(old_layer));
     }
   }
@@ -50,22 +51,21 @@ void ColorFilterLayer::Paint(PaintContext& context) const {
   if (context.raster_cache) {
     AutoCachePaint cache_paint(context);
     if (layer_raster_cache_item_->IsCacheChildren()) {
-      cache_paint.setColorFilter(sk_filter_);
+      cache_paint.setColorFilter(filter_->skia_object());
     }
     if (layer_raster_cache_item_->Draw(context, cache_paint.sk_paint())) {
       return;
     }
   }
 
   AutoCachePaint cache_paint(context);
-  cache_paint.setColorFilter(sk_filter_);
-
   if (context.leaf_nodes_builder) {
-    context.leaf_nodes_builder->saveLayer(
-        &paint_bounds(), cache_paint.dl_paint(), filter_.get());
+    cache_paint.setColorFilter(filter_.get());
+    context.leaf_nodes_builder->saveLayer(&paint_bounds(), cache_paint.dl_paint());
     PaintChildren(context);
     context.leaf_nodes_builder->restore();
   } else {
+    cache_paint.setColorFilter(filter_ ? filter_->skia_object() : nullptr);
     Layer::AutoSaveLayer save = Layer::AutoSaveLayer::Create(
         context, paint_bounds(), cache_paint.sk_paint());
     PaintChildren(context);
diff --git a/flow/layers/color_filter_layer.h b/flow/layers/color_filter_layer.h
@@ -21,10 +21,7 @@ class ColorFilterLayer : public CacheableContainerLayer {
 
   void Paint(PaintContext& context) const override;
 
-  sk_sp<SkColorFilter> sk_filter() const { return sk_filter_; }
-
  private:
-  sk_sp<SkColorFilter> sk_filter_;
   std::shared_ptr<const DlColorFilter> filter_;
   FML_DISALLOW_COPY_AND_ASSIGN(ColorFilterLayer);
 };
diff --git a/flow/layers/color_filter_layer_unittests.cc b/flow/layers/color_filter_layer_unittests.cc
diff --git a/flow/layers/layer.h b/flow/layers/layer.h
diff --git a/impeller/display_list/display_list_dispatcher.cc b/impeller/display_list/display_list_dispatcher.cc
diff --git a/impeller/display_list/display_list_dispatcher.h b/impeller/display_list/display_list_dispatcher.h
diff --git a/testing/display_list_testing.cc b/testing/display_list_testing.cc
diff --git a/testing/display_list_testing.h b/testing/display_list_testing.h
