Layer state stack

ci/licenses_golden/licenses_flutter

@@ -171,6 +171,8 @@ FILE: ../../../flutter/flow/layers/layer.cc
 FILE: ../../../flutter/flow/layers/layer.h
 FILE: ../../../flutter/flow/layers/layer_raster_cache_item.cc
 FILE: ../../../flutter/flow/layers/layer_raster_cache_item.h
+FILE: ../../../flutter/flow/layers/layer_state_stack.cc
+FILE: ../../../flutter/flow/layers/layer_state_stack.h
 FILE: ../../../flutter/flow/layers/layer_tree.cc
 FILE: ../../../flutter/flow/layers/layer_tree.h
 FILE: ../../../flutter/flow/layers/layer_tree_unittests.cc

display_list/display_list_color_filter.h

@@ -57,6 +57,11 @@ class DlColorFilter
   // pixels non-transparent and therefore expand the bounds.
   virtual bool modifies_transparent_black() const = 0;
 
+  // Return a boolean indicating whether the color filtering operation can
+  // be applied either before or after modulating the pixels with an opacity
+  // value without changing the operation.
+  virtual bool can_commute_with_alpha() const { return false; }
+
   // Return a DlBlendColorFilter pointer to this object iff it is a Blend
   // type of ColorFilter, otherwise return nullptr.
   virtual const DlBlendColorFilter* asBlend() const { return nullptr; }
@@ -150,6 +155,12 @@ class DlMatrixColorFilter final : public DlColorFilter {
            sk_filter->filterColor(SK_ColorTRANSPARENT) != SK_ColorTRANSPARENT;
   }
 
+  bool can_commute_with_alpha() const override {
+    return matrix_[3] == 0 && matrix_[8] == 0 && matrix_[13] == 0 &&
+           matrix_[15] == 0 && matrix_[16] == 0 && matrix_[17] == 0 &&
+           (matrix_[18] >= 0.0 && matrix_[18] <= 1.0) && matrix_[19] == 0;
+  }
+
   std::shared_ptr<DlColorFilter> shared() const override {
     return std::make_shared<DlMatrixColorFilter>(this);
   }

display_list/display_list_paint.h

@@ -104,6 +104,10 @@ class DlPaint {
     color_.argb = alpha << 24 | (color_.argb & 0x00FFFFFF);
     return *this;
   }
+  DlPaint& setOpacity(SkScalar opacity) {
+    setAlpha(SkScalarRoundToInt(opacity * 0xff));
+    return *this;
+  }
 
   DlBlendMode getBlendMode() const {
     return static_cast<DlBlendMode>(blendMode_);
@@ -166,7 +170,7 @@ class DlPaint {
     return colorFilter_;
   }
   const DlColorFilter* getColorFilterPtr() const { return colorFilter_.get(); }
-  DlPaint& setColorFilter(std::shared_ptr<DlColorFilter> filter) {
+  DlPaint& setColorFilter(const std::shared_ptr<const DlColorFilter> filter) {
     colorFilter_ = filter ? filter->shared() : nullptr;
     return *this;
   }
@@ -179,7 +183,7 @@ class DlPaint {
     return imageFilter_;
   }
   const DlImageFilter* getImageFilterPtr() const { return imageFilter_.get(); }
-  DlPaint& setImageFilter(std::shared_ptr<DlImageFilter> filter) {
+  DlPaint& setImageFilter(const std::shared_ptr<const DlImageFilter> filter) {
     imageFilter_ = filter;
     return *this;
   }

display_list/display_list_utils.cc

@@ -19,15 +19,6 @@
 
 namespace flutter {
 
-// clang-format off
-constexpr float kInvertColorMatrix[20] = {
-  -1.0,    0,    0, 1.0, 0,
-     0, -1.0,    0, 1.0, 0,
-     0,    0, -1.0, 1.0, 0,
-   1.0,  1.0,  1.0, 1.0, 0
-};
-// clang-format on
-
 void SkPaintDispatchHelper::save_opacity(SkScalar child_opacity) {
   save_stack_.emplace_back(opacity_);
   set_opacity(child_opacity);
@@ -96,13 +87,19 @@ void SkPaintDispatchHelper::setMaskFilter(const DlMaskFilter* filter) {
 }
 
 sk_sp<SkColorFilter> SkPaintDispatchHelper::makeColorFilter() const {
-  if (!invert_colors_) {
-    return color_filter_ ? color_filter_->skia_object() : nullptr;
+  return MakeColorFilter(invert_colors_, color_filter_.get());
+}
+
+sk_sp<SkColorFilter> SkPaintDispatchHelper::MakeColorFilter(
+    bool isInvertColors,
+    const DlColorFilter* color_filter) {
+  if (!isInvertColors) {
+    return color_filter ? color_filter->skia_object() : nullptr;
   }
   sk_sp<SkColorFilter> invert_filter =
       SkColorFilters::Matrix(kInvertColorMatrix);
-  if (color_filter_) {
-    invert_filter = invert_filter->makeComposed(color_filter_->skia_object());
+  if (color_filter) {
+    invert_filter = invert_filter->makeComposed(color_filter->skia_object());
   }
   return invert_filter;
 }

display_list/display_list_utils.h

@@ -174,6 +174,18 @@ class SkPaintDispatchHelper : public virtual Dispatcher {
     }
   }
 
+  // clang-format off
+  static constexpr float kInvertColorMatrix[20] = {
+    -1.0,    0,    0, 1.0, 0,
+       0, -1.0,    0, 1.0, 0,
+       0,    0, -1.0, 1.0, 0,
+     1.0,  1.0,  1.0, 1.0, 0
+  };
+  // clang-format on
+  static sk_sp<SkColorFilter> MakeColorFilter(
+      bool isInvertColors,
+      const DlColorFilter* color_filter);
+
   void setAntiAlias(bool aa) override;
   void setDither(bool dither) override;
   void setStyle(DlDrawStyle style) override;

flow/BUILD.gn

@@ -45,6 +45,8 @@ source_set("flow") {
     "layers/layer.h",
     "layers/layer_raster_cache_item.cc",
     "layers/layer_raster_cache_item.h",
+    "layers/layer_state_stack.cc",
+    "layers/layer_state_stack.h",
     "layers/layer_tree.cc",
     "layers/layer_tree.h",
     "layers/offscreen_surface.cc",

flow/layers/backdrop_filter_layer.cc

@@ -47,38 +47,16 @@ void BackdropFilterLayer::Preroll(PrerollContext* context,
   PrerollChildren(context, matrix, &child_paint_bounds);
   child_paint_bounds.join(context->cull_rect);
   set_paint_bounds(child_paint_bounds);
-  context->subtree_can_inherit_opacity = true;
+  context->rendering_state_flags = LayerStateStack::CALLER_CAN_APPLY_OPACITY;
 }
 
 void BackdropFilterLayer::Paint(PaintContext& context) const {
   TRACE_EVENT0("flutter", "BackdropFilterLayer::Paint");
   FML_DCHECK(needs_painting(context));
 
-  AutoCachePaint save_paint(context);
-  save_paint.setBlendMode(blend_mode_);
-  if (context.leaf_nodes_builder) {
-    // Note that we perform a saveLayer directly on the
-    // leaf_nodes_builder here similar to how the SkCanvas
-    // path specifies the kLeafNodesCanvas below.
-    // See https:://flutter.dev/go/backdrop-filter-with-overlay-canvas
-    context.leaf_nodes_builder->saveLayer(&paint_bounds(),
-                                          save_paint.dl_paint(), filter_.get());
-
-    PaintChildren(context);
-
-    context.leaf_nodes_builder->restore();
-  } else {
-    auto sk_filter = filter_ ? filter_->skia_object() : nullptr;
-    Layer::AutoSaveLayer save = Layer::AutoSaveLayer::Create(
-        context,
-        SkCanvas::SaveLayerRec{&paint_bounds(), save_paint.sk_paint(),
-                               sk_filter.get(), 0},
-        // BackdropFilter should only happen on the leaf nodes canvas.
-        // See https:://flutter.dev/go/backdrop-filter-with-overlay-canvas
-        AutoSaveLayer::SaveMode::kLeafNodesCanvas);
-
-    PaintChildren(context);
-  }
+  auto save = context.state_stack.saveWithBackdropFilter(&paint_bounds(),
+                                                         filter_, blend_mode_);
+  PaintChildren(context);
 }
 
 }  // namespace flutter

flow/layers/checkerboard_layertree_unittests.cc

@@ -303,7 +303,6 @@ TEST_F(CheckerBoardLayerTest, PhysicalSaveLayerNotCheckBoard) {
   const SkPaint clip_paint;
   SkPaint layer_paint;
   layer_paint.setColor(SK_ColorGREEN);
-  layer_paint.setAntiAlias(true);
   layer->Paint(paint_context());
   EXPECT_EQ(
       mock_canvas().draw_calls(),
@@ -342,7 +341,6 @@ TEST_F(CheckerBoardLayerTest, PhysicalSaveLayerCheckBoard) {
   const SkPaint clip_paint;
   SkPaint layer_paint;
   layer_paint.setColor(SK_ColorGREEN);
-  layer_paint.setAntiAlias(true);
   layer->Paint(check_board_context());
   EXPECT_NE(
       mock_canvas().draw_calls(),

flow/layers/clip_path_layer.cc

@@ -28,8 +28,8 @@ void ClipPathLayer::OnMutatorsStackPushClipShape(
   mutators_stack.PushClipPath(clip_shape());
 }
 
-void ClipPathLayer::OnCanvasClipShape(SkCanvas* canvas) const {
-  canvas->clipPath(clip_shape(), clip_behavior() != Clip::hardEdge);
+void ClipPathLayer::OnStackClipShape(LayerStateStack& stack) const {
+  stack.clipPath(clip_shape(), clip_behavior() != Clip::hardEdge);
 }
 
 }  // namespace flutter

flow/layers/clip_path_layer.h

@@ -23,7 +23,7 @@ class ClipPathLayer : public ClipShapeLayer<SkPath> {
 
   void OnMutatorsStackPushClipShape(MutatorsStack& mutators_stack) override;
 
-  void OnCanvasClipShape(SkCanvas* canvas) const override;
+  void OnStackClipShape(LayerStateStack& stack) const override;
 
  private:
   FML_DISALLOW_COPY_AND_ASSIGN(ClipPathLayer);

flow/layers/clip_path_layer_unittests.cc

@@ -77,7 +77,7 @@ TEST_F(ClipPathLayerTest, PaintingCulledLayerDies) {
   EXPECT_EQ(mock_layer->parent_matrix(), initial_matrix);
   EXPECT_EQ(mock_layer->parent_mutators(), std::vector({Mutator(layer_path)}));
 
-  paint_context().internal_nodes_canvas->clipRect(distant_bounds, false);
+  paint_context().state_stack.clipRect(distant_bounds, false);
   EXPECT_FALSE(mock_layer->needs_painting(paint_context()));
   EXPECT_FALSE(layer->needs_painting(paint_context()));
   EXPECT_DEATH_IF_SUPPORTED(layer->Paint(paint_context()),
@@ -279,29 +279,28 @@ TEST_F(ClipPathLayerTest, OpacityInheritance) {
 
   // ClipRectLayer will pass through compatibility from a compatible child
   PrerollContext* context = preroll_context();
-  context->subtree_can_inherit_opacity = false;
   clip_path_layer->Preroll(context, SkMatrix::I());
-  EXPECT_TRUE(context->subtree_can_inherit_opacity);
+  EXPECT_EQ(context->rendering_state_flags,
+            LayerStateStack::CALLER_CAN_APPLY_OPACITY);
 
   auto path2 = SkPath().addRect({40, 40, 50, 50});
   auto mock2 = MockLayer::MakeOpacityCompatible(path2);
   clip_path_layer->Add(mock2);
 
   // ClipRectLayer will pass through compatibility from multiple
   // non-overlapping compatible children
-  context->subtree_can_inherit_opacity = false;
   clip_path_layer->Preroll(context, SkMatrix::I());
-  EXPECT_TRUE(context->subtree_can_inherit_opacity);
+  EXPECT_EQ(context->rendering_state_flags,
+            LayerStateStack::CALLER_CAN_APPLY_OPACITY);
 
   auto path3 = SkPath().addRect({20, 20, 40, 40});
   auto mock3 = MockLayer::MakeOpacityCompatible(path3);
   clip_path_layer->Add(mock3);
 
   // ClipRectLayer will not pass through compatibility from multiple
   // overlapping children even if they are individually compatible
-  context->subtree_can_inherit_opacity = false;
   clip_path_layer->Preroll(context, SkMatrix::I());
-  EXPECT_FALSE(context->subtree_can_inherit_opacity);
+  EXPECT_EQ(context->rendering_state_flags, 0);
 
   {
     // ClipRectLayer(aa with saveLayer) will always be compatible
@@ -311,15 +310,15 @@ TEST_F(ClipPathLayerTest, OpacityInheritance) {
     clip_path_saveLayer->Add(mock2);
 
     // Double check first two children are compatible and non-overlapping
-    context->subtree_can_inherit_opacity = false;
     clip_path_saveLayer->Preroll(context, SkMatrix::I());
-    EXPECT_TRUE(context->subtree_can_inherit_opacity);
+    EXPECT_EQ(context->rendering_state_flags,
+              LayerStateStack::CALLER_CAN_APPLY_OPACITY);
 
     // Now add the overlapping child and test again, should still be compatible
     clip_path_saveLayer->Add(mock3);
-    context->subtree_can_inherit_opacity = false;
     clip_path_saveLayer->Preroll(context, SkMatrix::I());
-    EXPECT_TRUE(context->subtree_can_inherit_opacity);
+    EXPECT_EQ(context->rendering_state_flags,
+              LayerStateStack::CALLER_CAN_APPLY_OPACITY);
   }
 
   // An incompatible, but non-overlapping child for the following tests
@@ -334,17 +333,16 @@ TEST_F(ClipPathLayerTest, OpacityInheritance) {
     clip_path_bad_child->Add(mock2);
 
     // Double check first two children are compatible and non-overlapping
-    context->subtree_can_inherit_opacity = false;
     clip_path_bad_child->Preroll(context, SkMatrix::I());
-    EXPECT_TRUE(context->subtree_can_inherit_opacity);
+    EXPECT_EQ(context->rendering_state_flags,
+              LayerStateStack::CALLER_CAN_APPLY_OPACITY);
 
     clip_path_bad_child->Add(mock4);
 
     // The third child is non-overlapping, but not compatible so the
     // TransformLayer should end up incompatible
-    context->subtree_can_inherit_opacity = false;
     clip_path_bad_child->Preroll(context, SkMatrix::I());
-    EXPECT_FALSE(context->subtree_can_inherit_opacity);
+    EXPECT_EQ(context->rendering_state_flags, 0);
   }
 
   {
@@ -355,15 +353,15 @@ TEST_F(ClipPathLayerTest, OpacityInheritance) {
     clip_path_saveLayer_bad_child->Add(mock2);
 
     // Double check first two children are compatible and non-overlapping
-    context->subtree_can_inherit_opacity = false;
     clip_path_saveLayer_bad_child->Preroll(context, SkMatrix::I());
-    EXPECT_TRUE(context->subtree_can_inherit_opacity);
+    EXPECT_EQ(context->rendering_state_flags,
+              LayerStateStack::CALLER_CAN_APPLY_OPACITY);
 
     // Now add the incompatible child and test again, should still be compatible
     clip_path_saveLayer_bad_child->Add(mock4);
-    context->subtree_can_inherit_opacity = false;
     clip_path_saveLayer_bad_child->Preroll(context, SkMatrix::I());
-    EXPECT_TRUE(context->subtree_can_inherit_opacity);
+    EXPECT_EQ(context->rendering_state_flags,
+              LayerStateStack::CALLER_CAN_APPLY_OPACITY);
   }
 }
 
@@ -383,15 +381,14 @@ TEST_F(ClipPathLayerTest, OpacityInheritancePainting) {
   // ClipRectLayer will pass through compatibility from multiple
   // non-overlapping compatible children
   PrerollContext* context = preroll_context();
-  context->subtree_can_inherit_opacity = false;
   clip_path_layer->Preroll(context, SkMatrix::I());
-  EXPECT_TRUE(context->subtree_can_inherit_opacity);
+  EXPECT_EQ(context->rendering_state_flags,
+            LayerStateStack::CALLER_CAN_APPLY_OPACITY);
 
   int opacity_alpha = 0x7F;
   SkPoint offset = SkPoint::Make(10, 10);
   auto opacity_layer = std::make_shared<OpacityLayer>(opacity_alpha, offset);
   opacity_layer->Add(clip_path_layer);
-  context->subtree_can_inherit_opacity = false;
   opacity_layer->Preroll(context, SkMatrix::I());
   EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
 
@@ -449,15 +446,14 @@ TEST_F(ClipPathLayerTest, OpacityInheritanceSaveLayerPainting) {
   // ClipRectLayer will pass through compatibility from multiple
   // non-overlapping compatible children
   PrerollContext* context = preroll_context();
-  context->subtree_can_inherit_opacity = false;
   clip_path_layer->Preroll(context, SkMatrix::I());
-  EXPECT_TRUE(context->subtree_can_inherit_opacity);
+  EXPECT_EQ(context->rendering_state_flags,
+            LayerStateStack::CALLER_CAN_APPLY_OPACITY);
 
   int opacity_alpha = 0x7F;
   SkPoint offset = SkPoint::Make(10, 10);
   auto opacity_layer = std::make_shared<OpacityLayer>(opacity_alpha, offset);
   opacity_layer->Add(clip_path_layer);
-  context->subtree_can_inherit_opacity = false;
   opacity_layer->Preroll(context, SkMatrix::I());
   EXPECT_TRUE(opacity_layer->children_can_accept_opacity());
 

flow/layers/clip_rect_layer.cc

@@ -28,8 +28,8 @@ void ClipRectLayer::OnMutatorsStackPushClipShape(
   mutators_stack.PushClipRect(clip_shape());
 }
 
-void ClipRectLayer::OnCanvasClipShape(SkCanvas* canvas) const {
-  canvas->clipRect(clip_shape(), clip_behavior() != Clip::hardEdge);
+void ClipRectLayer::OnStackClipShape(LayerStateStack& stack) const {
+  stack.clipRect(clip_shape(), clip_behavior() != Clip::hardEdge);
 }
 
 }  // namespace flutter

flow/layers/clip_rect_layer.h

@@ -22,7 +22,7 @@ class ClipRectLayer : public ClipShapeLayer<SkRect> {
 
   void OnMutatorsStackPushClipShape(MutatorsStack& mutators_stack) override;
 
-  void OnCanvasClipShape(SkCanvas* canvas) const override;
+  void OnStackClipShape(LayerStateStack& stack) const override;
 
  private:
   FML_DISALLOW_COPY_AND_ASSIGN(ClipRectLayer);