Wire up OpacityLayer to Scenic

arbreng · arbreng · commit 319d5636fa04 · 2019-12-02T09:55:57.000-08:00
diff --git a/flow/layers/child_scene_layer.cc b/flow/layers/child_scene_layer.cc
@@ -20,10 +20,25 @@ ChildSceneLayer::ChildSceneLayer(zx_koid_t layer_id,
 void ChildSceneLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   TRACE_EVENT0("flutter", "ChildSceneLayer::Preroll");
   set_needs_system_composite(true);
+
+  // An alpha "hole punch" is required if the frame behind us is not opaque.
+  if (!context->is_opaque) {
+    set_paint_bounds(
+        SkRect::MakeXYWH(offset_.fX, offset_.fY, size_.fWidth, size_.fHeight));
+  }
 }
 
 void ChildSceneLayer::Paint(PaintContext& context) const {
-  FML_NOTREACHED() << "This layer never needs painting.";
+  TRACE_EVENT0("flutter", "ChildSceneLayer::Paint");
+  FML_DCHECK(needs_painting());
+
+  // If we are being rendered into our own frame using the system compositor,
+  // then it is neccesary to "punch a hole" in the canvas/frame behind us so
+  // that group opacity looks correct.
+  SkPaint paint;
+  paint.setColor(SK_ColorTRANSPARENT);
+  paint.setBlendMode(SkBlendMode::kSrc);
+  context.leaf_nodes_canvas->drawRect(paint_bounds(), paint);
 }
 
 void ChildSceneLayer::UpdateScene(SceneUpdateContext& context) {
diff --git a/flow/layers/fuchsia_system_composited_layer.cc b/flow/layers/fuchsia_system_composited_layer.cc
@@ -7,14 +7,20 @@
 namespace flutter {
 
 FuchsiaSystemCompositedLayer::FuchsiaSystemCompositedLayer(SkColor color,
+                                                           SkAlpha opacity,
                                                            float elevation)
-    : ElevatedContainerLayer(elevation), color_(color) {}
+    : ElevatedContainerLayer(elevation), color_(color), opacity_(opacity) {}
 
 void FuchsiaSystemCompositedLayer::Preroll(PrerollContext* context,
                                            const SkMatrix& matrix) {
   TRACE_EVENT0("flutter", "FuchsiaSystemCompositedLayer::Preroll");
 
+  const float parent_is_opaque = context->is_opaque;
+  context->mutators_stack.PushOpacity(opacity_);
+  context->is_opaque = parent_is_opaque && (opacity_ == 255);
   ElevatedContainerLayer::Preroll(context, matrix);
+  context->is_opaque = parent_is_opaque;
+  context->mutators_stack.Pop();
 
   // System-composite this layer if its elevated.
   if (elevation() != 0.0f) {
@@ -41,14 +47,15 @@ void FuchsiaSystemCompositedLayer::UpdateScene(SceneUpdateContext& context) {
 
   TRACE_EVENT_INSTANT0("flutter", "retained cache miss, creating");
   // If we can't find an existing retained surface, create one.
-  SceneUpdateContext::Frame frame(context, rrect_, color_, elevation(), this);
+  SceneUpdateContext::Frame frame(context, rrect_, color_, opacity_ / 255.0f,
+                                  elevation(), this);
   for (auto& layer : layers()) {
     if (layer->needs_painting()) {
       frame.AddPaintLayer(layer.get());
     }
   }
 
-  ContainerLayer::UpdateScene(context);
+  ElevatedContainerLayer::UpdateScene(context);
 }
 
 }  // namespace flutter
diff --git a/flow/layers/fuchsia_system_composited_layer.h b/flow/layers/fuchsia_system_composited_layer.h
@@ -13,18 +13,20 @@ class FuchsiaSystemCompositedLayer : public ElevatedContainerLayer {
  public:
   static bool can_system_composite() { return true; }
 
-  FuchsiaSystemCompositedLayer(SkColor color, float elevation);
+  FuchsiaSystemCompositedLayer(SkColor color, SkAlpha opacity, float elevation);
 
   void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
   void UpdateScene(SceneUpdateContext& context) override;
 
   void set_dimensions(SkRRect rrect) { rrect_ = rrect; }
 
   SkColor color() const { return color_; }
+  SkAlpha opacity() const { return opacity_; }
 
  private:
   SkRRect rrect_ = SkRRect::MakeEmpty();
   SkColor color_ = SK_ColorTRANSPARENT;
+  SkAlpha opacity_ = 255;
 
   FML_DISALLOW_COPY_AND_ASSIGN(FuchsiaSystemCompositedLayer);
 };
diff --git a/flow/layers/layer.h b/flow/layers/layer.h
@@ -60,10 +60,11 @@ struct PrerollContext {
   float frame_physical_depth;
   float frame_device_pixel_ratio;
 
-  // These allow us to track properties like elevation and opacity which stack
-  // with each other during Preroll.
+  // These allow us to track properties like elevation, opacity, and the
+  // prescence of a platform view during Preroll.
   float total_elevation = 0.0f;
   bool has_platform_view = false;
+  bool is_opaque = true;
 };
 
 // Represents a single composited layer. Created on the UI thread but then
diff --git a/flow/layers/layer_tree.cc b/flow/layers/layer_tree.cc
@@ -89,7 +89,7 @@ void LayerTree::UpdateScene(SceneUpdateContext& context,
       context,
       SkRRect::MakeRect(
           SkRect::MakeWH(frame_size_.width(), frame_size_.height())),
-      SK_ColorTRANSPARENT, /* elevation */ 0.0f);
+      SK_ColorTRANSPARENT, /* opacity */ 1.0f, /* elevation */ 0.0f);
   if (root_layer_->needs_system_composite()) {
     root_layer_->UpdateScene(context);
   }
diff --git a/flow/layers/opacity_layer.cc b/flow/layers/opacity_layer.cc
@@ -9,8 +9,29 @@
 
 namespace flutter {
 
-OpacityLayer::OpacityLayer(int alpha, const SkPoint& offset)
-    : alpha_(alpha), offset_(offset) {
+// The OpacityLayer has no real "elevation", but we want to avoid Z-fighting
+// when using the system compositor.  Choose a small but non-zero value for
+// this.
+constexpr float kOpacityElevationWhenUsingSystemCompositor = 0.0001f;
+
+#if !defined(OS_FUCHSIA)
+void OpacityLayerBase::Preroll(PrerollContext* context,
+                               const SkMatrix& matrix) {
+  const float parent_is_opaque = context->is_opaque;
+
+  context->mutators_stack.PushOpacity(opacity_);
+  context->is_opaque = parent_is_opaque && (opacity_ == 255);
+  ContainerLayer::Preroll(context, matrix);
+  context->is_opaque = parent_is_opaque;
+  context->mutators_stack.Pop();
+}
+#endif
+
+OpacityLayer::OpacityLayer(SkAlpha opacity, const SkPoint& offset)
+    : OpacityLayerBase(SK_ColorBLACK,
+                       opacity,
+                       kOpacityElevationWhenUsingSystemCompositor),
+      offset_(offset) {
   // Ensure OpacityLayer has only one direct child.
   //
   // This is needed to ensure that retained rendering can always be applied to
@@ -43,15 +64,30 @@ void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   ContainerLayer* container = GetChildContainer();
   FML_DCHECK(!container->layers().empty());  // OpacityLayer can't be a leaf.
 
+  // Factor in the offset during Preroll.  |OpacityLayerBase| will handle the
+  // opacity.
   SkMatrix child_matrix = matrix;
   child_matrix.postTranslate(offset_.fX, offset_.fY);
   context->mutators_stack.PushTransform(
       SkMatrix::MakeTrans(offset_.fX, offset_.fY));
-  context->mutators_stack.PushOpacity(alpha_);
-  ContainerLayer::Preroll(context, child_matrix);
-  context->mutators_stack.Pop();
+  OpacityLayerBase::Preroll(context, child_matrix);
   context->mutators_stack.Pop();
-  set_paint_bounds(paint_bounds().makeOffset(offset_.fX, offset_.fY));
+
+  // When using the system compositor, do not include the offset since we are
+  // rendering as a separate piece of geometry and the offset will be baked into
+  // that geometry's transform.
+  if (OpacityLayerBase::can_system_composite()) {
+    set_dimensions(SkRRect::MakeRect(paint_bounds()));
+
+    // If the frame behind us is opaque, don't punch a hole in it for group
+    // opacity.
+    if (context->is_opaque) {
+      set_paint_bounds(SkRect::MakeEmpty());
+    }
+    set_needs_system_composite(true);
+  } else {
+    set_paint_bounds(paint_bounds().makeOffset(offset_.fX, offset_.fY));
+  }
 
   if (!context->has_platform_view && context->raster_cache &&
       SkRect::Intersects(context->cull_rect, paint_bounds())) {
@@ -63,12 +99,38 @@ void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   }
 }
 
+#if defined(OS_FUCHSIA)
+
+void OpacityLayer::UpdateScene(SceneUpdateContext& context) {
+  SceneUpdateContext::Transform transform(
+      context, SkMatrix::MakeTrans(offset_.fX, offset_.fY));
+
+  // OpacityLayerBase will handle applying the opacity itself.
+  OpacityLayerBase::UpdateScene(context);
+}
+
+#endif
+
 void OpacityLayer::Paint(PaintContext& context) const {
   TRACE_EVENT0("flutter", "OpacityLayer::Paint");
   FML_DCHECK(needs_painting());
 
+  // The compositor will paint this layer (which is |Sk_ColorBLACK| with alpha
+  // scaled by opacity) via the model color on |SceneUpdateContext::Frame|.
+  //
+  // The child layers will be painted into the texture used by the Frame, so
+  // painting them here would actually cause them to be painted on the display
+  // twice -- once into the current canvas (which may be inside of another
+  // Frame) and once into the Frame's texture (which is then drawn on top of the
+  // current canvas).
+  if (OpacityLayerBase::can_system_composite()) {
+    FML_DCHECK(needs_system_composite());
+    OpacityLayerBase::Paint(context);
+    return;
+  }
+
   SkPaint paint;
-  paint.setAlpha(alpha_);
+  paint.setAlpha(opacity());
 
   SkAutoCanvasRestore save(context.internal_nodes_canvas, true);
   context.internal_nodes_canvas->translate(offset_.fX, offset_.fY);
@@ -95,16 +157,15 @@ void OpacityLayer::Paint(PaintContext& context) const {
   // RasterCache::GetIntegralTransCTM optimization.
   //
   // Note that the following lines are only accessible when the raster cache is
-  // not available (e.g., when we're using the software backend in golden
-  // tests).
+  // not available, or when a cache miss occurs.
   SkRect saveLayerBounds;
   paint_bounds()
       .makeOffset(-offset_.fX, -offset_.fY)
       .roundOut(&saveLayerBounds);
 
   Layer::AutoSaveLayer save_layer =
       Layer::AutoSaveLayer::Create(context, saveLayerBounds, &paint);
-  PaintChildren(context);
+  OpacityLayerBase::Paint(context);
 }
 
 ContainerLayer* OpacityLayer::GetChildContainer() const {
diff --git a/flow/layers/opacity_layer.h b/flow/layers/opacity_layer.h
@@ -5,15 +5,42 @@
 #ifndef FLUTTER_FLOW_LAYERS_OPACITY_LAYER_H_
 #define FLUTTER_FLOW_LAYERS_OPACITY_LAYER_H_
 
-#include "flutter/flow/layers/container_layer.h"
+#include "flutter/flow/layers/elevated_container_layer.h"
+#if defined(OS_FUCHSIA)
+#include "flutter/flow/layers/fuchsia_system_composited_layer.h"
+#endif
 
 namespace flutter {
 
+#if !defined(OS_FUCHSIA)
+class OpacityLayerBase : public ContainerLayer {
+ public:
+  static bool can_system_composite() { return false; }
+
+  OpacityLayerBase(SkColor color, SkAlpha opacity, float elevation)
+      : color_(color), opacity_(opacity) {}
+
+  void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
+
+  void set_dimensions(SkRRect rrect) {}
+
+  SkColor color() const { return color_; }
+  SkAlpha opacity() const { return opacity_; }
+  float elevation() const { return 0; }
+
+ private:
+  SkColor color_;
+  SkAlpha opacity_;
+};
+#else
+using OpacityLayerBase = FuchsiaSystemCompositedLayer;
+#endif
+
 // Don't add an OpacityLayer with no children to the layer tree. Painting an
 // OpacityLayer is very costly due to the saveLayer call. If there's no child,
 // having the OpacityLayer or not has the same effect. In debug_unopt build,
 // |Preroll| will assert if there are no children.
-class OpacityLayer : public ContainerLayer {
+class OpacityLayer : public OpacityLayerBase {
  public:
   // An offset is provided here because OpacityLayer.addToScene method in the
   // Flutter framework can take an optional offset argument.
@@ -25,22 +52,20 @@ class OpacityLayer : public ContainerLayer {
   // the retained rendering inefficient as a small offset change could propagate
   // to many leaf layers. Therefore we try to capture that offset here to stop
   // the propagation as repainting the OpacityLayer is expensive.
-  OpacityLayer(int alpha, const SkPoint& offset);
+  OpacityLayer(SkAlpha alpha, const SkPoint& offset);
 
   void Add(std::shared_ptr<Layer> layer) override;
 
   AnalysisResult Analyze() const override;
   void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
-
+#if defined(OS_FUCHSIA)
+  void UpdateScene(SceneUpdateContext& context) override;
+#endif
   void Paint(PaintContext& context) const override;
 
-  // TODO(chinmaygarde): Once SCN-139 is addressed, introduce a new node in the
-  // session scene hierarchy.
-
  private:
   ContainerLayer* GetChildContainer() const;
 
-  int alpha_;
   SkPoint offset_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(OpacityLayer);
diff --git a/flow/layers/physical_shape_layer.cc b/flow/layers/physical_shape_layer.cc
@@ -17,35 +17,35 @@ PhysicalShapeLayer::PhysicalShapeLayer(SkColor color,
                                        float elevation,
                                        const SkPath& path,
                                        Clip clip_behavior)
-    : PhysicalShapeLayerBase(color, elevation),
+    : PhysicalShapeLayerBase(color, SK_AlphaOPAQUE, elevation),
       shadow_color_(shadow_color),
       path_(path),
       clip_behavior_(clip_behavior) {
   // If rendering as a separate frame using the system compositor, then make
   // sure to set up the properties needed to do so.
-#if defined(OS_FUCHSIA)
-  SkRect rect;
-  SkRRect rrect;
-  if (path.isRect(&rect)) {
-    rrect = SkRRect::MakeRect(rect);
-  } else if (path.isRRect(&rrect)) {
-    // Nothing needed here, as isRRect will fill in frameRRect_ already.
-  } else if (path.isOval(&rect)) {
-    // isRRect returns false for ovals, so we need to explicitly check isOval
-    // as well.
-    rrect = SkRRect::MakeOval(rect);
-  } else {
-    // Scenic currently doesn't provide an easy way to create shapes from
-    // arbitrary paths.
-    // For shapes that cannot be represented as a rounded rectangle we
-    // default to use the bounding rectangle.
-    // TODO(amirh): fix this once we have a way to create a Scenic shape from
-    // an SkPath.
-    rrect = SkRRect::MakeRect(path.getBounds());
+  if (PhysicalShapeLayerBase::can_system_composite()) {
+    SkRect rect;
+    SkRRect rrect;
+    if (path.isRect(&rect)) {
+      rrect = SkRRect::MakeRect(rect);
+    } else if (path.isRRect(&rrect)) {
+      // Nothing needed here, as isRRect will fill in frameRRect_ already.
+    } else if (path.isOval(&rect)) {
+      // isRRect returns false for ovals, so we need to explicitly check isOval
+      // as well.
+      rrect = SkRRect::MakeOval(rect);
+    } else {
+      // Scenic currently doesn't provide an easy way to create shapes from
+      // arbitrary paths.
+      // For shapes that cannot be represented as a rounded rectangle we
+      // default to use the bounding rectangle.
+      // TODO(amirh): fix this once we have a way to create a Scenic shape from
+      // an SkPath.
+      rrect = SkRRect::MakeRect(path.getBounds());
+    }
+
+    set_dimensions(rrect);
   }
-
-  set_dimensions(rrect);
-#endif
 }
 
 Layer::AnalysisResult PhysicalShapeLayer::Analyze() const {
@@ -61,9 +61,15 @@ void PhysicalShapeLayer::Preroll(PrerollContext* context,
   TRACE_EVENT0("flutter", "PhysicalShapeLayer::Preroll");
   PhysicalShapeLayerBase::Preroll(context, matrix);
 
-  // Use the system compositor for shadows if it's available.  0-elevation
-  // doesn't cast shadows, so it never uses the system compositor.
-  if (PhysicalShapeLayerBase::can_system_composite() && elevation() != 0) {
+  // Use the system compositor for shadows if it's available and we are at a
+  // non-zero elevation.  |PhysicalShapeLayerBase| has already checked the
+  // elevation condition and set |needs_system_composite|.
+  if (PhysicalShapeLayerBase::can_system_composite()) {
+    // If the frame behind us is opaque, don't punch a hole in it for group
+    // opacity.
+    if (context->is_opaque) {
+      set_paint_bounds(SkRect::MakeEmpty());
+    }
     return;
   }
 
diff --git a/flow/layers/physical_shape_layer.h b/flow/layers/physical_shape_layer.h
diff --git a/flow/scene_update_context.cc b/flow/scene_update_context.cc
diff --git a/flow/scene_update_context.h b/flow/scene_update_context.h

Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ void LayerTree::UpdateScene(SceneUpdateContext& context,`
`89`	`89`	`context,`
`90`	`90`	`SkRRect::MakeRect(`
`91`	`91`	`SkRect::MakeWH(frame_size_.width(), frame_size_.height())),`
`92`		`- SK_ColorTRANSPARENT, /* elevation */ 0.0f);`
	`92`	`+ SK_ColorTRANSPARENT, /* opacity / 1.0f, / elevation */ 0.0f);`
`93`	`93`	`if (root_layer_->needs_system_composite()) {`
`94`	`94`	`root_layer_->UpdateScene(context);`
`95`	`95`	`}`