Wire up OpacityLayer to Scenic

Author: arbreng

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) {

flow/layers/fuchsia_system_composited_layer.cc

@@ -6,19 +6,21 @@
 
 namespace flutter {
 
-FuchsiaSystemCompositedLayer::FuchsiaSystemCompositedLayer(
-    SkColor color,
-    float elevation)
-    : ElevatedContainerLayer(elevation), color_(color) {}
+FuchsiaSystemCompositedLayer::FuchsiaSystemCompositedLayer(SkColor color,
+                                                           SkAlpha opacity,
+                                                           float elevation)
+    : ElevatedContainerLayer(elevation), color_(color), opacity_(opacity) {}
 
 void FuchsiaSystemCompositedLayer::Preroll(PrerollContext* context,
-                                                    const SkMatrix& matrix) {
+                                           const SkMatrix& matrix) {
   TRACE_EVENT0("flutter", "FuchsiaSystemCompositedLayer::Preroll");
-#if !defined(OS_FUCHSIA)
-  FML_NOTIMPLEMENTED();
-#endif  // !defined(OS_FUCHSIA)
 
+  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) {
@@ -28,19 +30,20 @@ void FuchsiaSystemCompositedLayer::Preroll(PrerollContext* context,
 
 void FuchsiaSystemCompositedLayer::Paint(PaintContext& context) const {
   TRACE_EVENT0("flutter", "FuchsiaSystemCompositedLayer::Paint");
-#if !defined(OS_FUCHSIA)
-  FML_NOTIMPLEMENTED();
-#endif  // !defined(OS_FUCHSIA)
+  FML_DCHECK(needs_painting());
 
-  // TODO: hole punch
-  // If this is actually called, it's because flow is attempting to paint this
-  // layer onto the frame behind it which gives us a chance to hole-punch
+  if (needs_system_composite()) {
+    // 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);
+  }
 }
 
-#if defined(OS_FUCHSIA)
-
-void FuchsiaSystemCompositedLayer::UpdateScene(
-    SceneUpdateContext& context) {
+void FuchsiaSystemCompositedLayer::UpdateScene(SceneUpdateContext& context) {
   FML_DCHECK(needs_system_composite());
 
   // Retained rendering: speedup by reusing a retained entity node if
@@ -58,16 +61,15 @@ void FuchsiaSystemCompositedLayer::UpdateScene(
 
   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);
 }
 
-#endif  // defined(OS_FUCHSIA)
-
 }  // namespace flutter

flow/layers/fuchsia_system_composited_layer.h

@@ -13,7 +13,7 @@ class FuchsiaSystemCompositedLayer : public ElevatedContainerLayer {
  public:
   static bool can_system_composite() { return true; }
 
-  FuchsiaSystemCompositedLayer(SkColor color, float elevation);
+  FuchsiaSystemCompositedLayer(SkColor color, SkAlpha opacity, float elevation);
   ~FuchsiaSystemCompositedLayer() override = default;
 
   void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
@@ -25,10 +25,12 @@ class FuchsiaSystemCompositedLayer : public ElevatedContainerLayer {
   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);
 };

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

flow/layers/layer_tree.cc

@@ -81,7 +81,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);
   }

flow/layers/layer_tree_unittests.cc

@@ -17,10 +17,16 @@ namespace testing {
 
 class LayerTreeTest : public CanvasTest<::testing::Test> {
  public:
-  LayerTreeTest() : layer_tree_(SkISize::Make(64, 64), 100.0f, 1.0f),
-                    compositor_context_(fml::kDefaultFrameBudget),
-                    root_transform_(SkMatrix::MakeTrans(1.0f, 1.0f)),
-                    scoped_frame_(compositor_context_.AcquireFrame(nullptr, &mock_canvas(), nullptr, root_transform_, false, nullptr)) {}
+  LayerTreeTest()
+      : layer_tree_(SkISize::Make(64, 64), 100.0f, 1.0f),
+        compositor_context_(fml::kDefaultFrameBudget),
+        root_transform_(SkMatrix::MakeTrans(1.0f, 1.0f)),
+        scoped_frame_(compositor_context_.AcquireFrame(nullptr,
+                                                       &mock_canvas(),
+                                                       nullptr,
+                                                       root_transform_,
+                                                       false,
+                                                       nullptr)) {}
 
   LayerTree& layer_tree() { return layer_tree_; }
   CompositorContext::ScopedFrame& frame() { return *scoped_frame_.get(); }

flow/layers/opacity_layer.cc

@@ -9,8 +9,30 @@
 
 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 SkAlpha alpha = SkColorGetA(color());
+  const float parent_is_opaque = context->is_opaque;
+
+  context->mutators_stack.PushOpacity(alpha);
+  context->is_opaque = parent_is_opaque && (alpha == 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
@@ -33,15 +55,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())) {
@@ -53,12 +90,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);
@@ -85,16 +148,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 {

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)
+using OpacityLayerBase = FuchsiaSystemCompositedLayer;
+#else
+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_;
+};
+#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, the
 // |EnsureSingleChild| 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);
   ~OpacityLayer() override;
 
   void Add(std::shared_ptr<Layer> layer) 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);