Centralize system-composite and elevation logic

arbreng · arbreng · commit 9eded82b3739 · 2019-12-02T09:55:57.000-08:00
diff --git a/ci/licenses_golden/licenses_flutter b/ci/licenses_golden/licenses_flutter
@@ -48,6 +48,10 @@ FILE: ../../../flutter/flow/layers/color_filter_layer_unittests.cc
 FILE: ../../../flutter/flow/layers/container_layer.cc
 FILE: ../../../flutter/flow/layers/container_layer.h
 FILE: ../../../flutter/flow/layers/container_layer_unittests.cc
+FILE: ../../../flutter/flow/layers/elevated_container_layer.cc
+FILE: ../../../flutter/flow/layers/elevated_container_layer.h
+FILE: ../../../flutter/flow/layers/fuchsia_system_composited_layer.cc
+FILE: ../../../flutter/flow/layers/fuchsia_system_composited_layer.h
 FILE: ../../../flutter/flow/layers/layer.cc
 FILE: ../../../flutter/flow/layers/layer.h
 FILE: ../../../flutter/flow/layers/layer_tree.cc
diff --git a/flow/BUILD.gn b/flow/BUILD.gn
@@ -28,6 +28,8 @@ source_set("flow") {
     "layers/color_filter_layer.h",
     "layers/container_layer.cc",
     "layers/container_layer.h",
+    "layers/elevated_container_layer.cc",
+    "layers/elevated_container_layer.h",
     "layers/layer.cc",
     "layers/layer.h",
     "layers/layer_tree.cc",
@@ -76,6 +78,8 @@ source_set("flow") {
     sources += [
       "layers/child_scene_layer.cc",
       "layers/child_scene_layer.h",
+      "layers/fuchsia_system_composited_layer.cc",
+      "layers/fuchsia_system_composited_layer.h",
       "scene_update_context.cc",
       "scene_update_context.h",
       "view_holder.cc",
diff --git a/flow/layers/container_layer.cc b/flow/layers/container_layer.cc
@@ -90,9 +90,9 @@ void ContainerLayer::UpdateScene(SceneUpdateContext& context) {
 void ContainerLayer::UpdateSceneChildren(SceneUpdateContext& context) {
   FML_DCHECK(needs_system_composite());
 
-  // Paint all of the layers which need to be drawn into the container.
-  // These may be flattened down to a containing
-  for (auto& layer : layers_) {
+  // Update all of the Layers which are part of the container.  This may cause
+  // additional child |Frame|s to be created.
+  for (auto& layer : layers()) {
     if (layer->needs_system_composite()) {
       layer->UpdateScene(context);
     }
diff --git a/flow/layers/elevated_container_layer.cc b/flow/layers/elevated_container_layer.cc
@@ -0,0 +1,49 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/flow/layers/elevated_container_layer.h"
+
+namespace flutter {
+namespace {
+
+float ClampElevation(float elevation,
+                     float parent_elevation,
+                     float max_elevation) {
+  // TODO(mklim): Deal with bounds overflow more elegantly. We'd like to be
+  // able to have developers specify the behavior here to alternatives besides
+  // clamping, like normalization on some arbitrary curve.
+  float clamped_elevation = elevation;
+  if (max_elevation > -1 && (parent_elevation + elevation) > max_elevation) {
+    // Clamp the local z coordinate at our max bound. Take into account the
+    // parent z position here to fix clamping in cases where the child is
+    // overflowing because of its parents.
+    clamped_elevation = max_elevation - parent_elevation;
+  }
+
+  return clamped_elevation;
+}
+
+}  // namespace
+
+ElevatedContainerLayer::ElevatedContainerLayer(float elevation)
+    : elevation_(elevation), clamped_elevation_(elevation) {}
+
+void ElevatedContainerLayer::Preroll(PrerollContext* context,
+                                     const SkMatrix& matrix) {
+  TRACE_EVENT0("flutter", "ElevatedContainerLayer::Preroll");
+
+  // Track total elevation as we walk the tree, in order to deal with bounds
+  // overflow in z.
+  parent_elevation_ = context->total_elevation;
+  clamped_elevation_ = ClampElevation(elevation_, parent_elevation_,
+                                      context->frame_physical_depth);
+  context->total_elevation += clamped_elevation_;
+
+  ContainerLayer::Preroll(context, matrix);
+
+  // Restore the elevation for our parent.
+  context->total_elevation = parent_elevation_;
+}
+
+}  // namespace flutter
diff --git a/flow/layers/elevated_container_layer.h b/flow/layers/elevated_container_layer.h
@@ -0,0 +1,34 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_FLOW_LAYERS_ELEVATED_CONTAINER_LAYER_H_
+#define FLUTTER_FLOW_LAYERS_ELEVATED_CONTAINER_LAYER_H_
+
+#include "flutter/flow/layers/container_layer.h"
+
+namespace flutter {
+
+class ElevatedContainerLayer : public ContainerLayer {
+ public:
+  ElevatedContainerLayer(float elevation);
+  ~ElevatedContainerLayer() override = default;
+
+  void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
+
+  float elevation() const { return clamped_elevation_; }
+  float total_elevation() const {
+    return parent_elevation_ + clamped_elevation_;
+  }
+
+ private:
+  float parent_elevation_ = 0.0f;
+  float elevation_ = 0.0f;
+  float clamped_elevation_ = 0.0f;
+
+  FML_DISALLOW_COPY_AND_ASSIGN(ElevatedContainerLayer);
+};
+
+}  // namespace flutter
+
+#endif  // FLUTTER_FLOW_LAYERS_ELEVATED_CONTAINER_LAYER_H_
diff --git a/flow/layers/fuchsia_system_composited_layer.cc b/flow/layers/fuchsia_system_composited_layer.cc
@@ -0,0 +1,54 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/flow/layers/fuchsia_system_composited_layer.h"
+
+namespace flutter {
+
+FuchsiaSystemCompositedLayer::FuchsiaSystemCompositedLayer(SkColor color,
+                                                           float elevation)
+    : ElevatedContainerLayer(elevation), color_(color) {}
+
+void FuchsiaSystemCompositedLayer::Preroll(PrerollContext* context,
+                                           const SkMatrix& matrix) {
+  TRACE_EVENT0("flutter", "FuchsiaSystemCompositedLayer::Preroll");
+
+  ElevatedContainerLayer::Preroll(context, matrix);
+
+  // System-composite this layer if its elevated.
+  if (elevation() != 0.0f) {
+    set_needs_system_composite(true);
+    set_paint_bounds(SkRect::MakeEmpty());
+  }
+}
+
+void FuchsiaSystemCompositedLayer::UpdateScene(SceneUpdateContext& context) {
+  FML_DCHECK(needs_system_composite());
+
+  // Retained rendering: speedup by reusing a retained entity node if
+  // possible. When an entity node is reused, no paint layer is added to the
+  // frame so we won't call Paint.
+  LayerRasterCacheKey key(unique_id(), context.Matrix());
+  if (context.HasRetainedNode(key)) {
+    TRACE_EVENT_INSTANT0("flutter", "retained layer cache hit");
+    const scenic::EntityNode& retained_node = context.GetRetainedNode(key);
+    FML_DCHECK(context.top_entity());
+    FML_DCHECK(retained_node.session() == context.session());
+    context.top_entity()->embedder_node().AddChild(retained_node);
+    return;
+  }
+
+  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);
+  for (auto& layer : layers()) {
+    if (layer->needs_painting()) {
+      frame.AddPaintLayer(layer.get());
+    }
+  }
+
+  ContainerLayer::UpdateScene(context);
+}
+
+}  // namespace flutter
diff --git a/flow/layers/fuchsia_system_composited_layer.h b/flow/layers/fuchsia_system_composited_layer.h
@@ -0,0 +1,34 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef FLUTTER_FLOW_LAYERS_FUCHSIA_SYSTEM_COMPOSITED_LAYER_H_
+#define FLUTTER_FLOW_LAYERS_FUCHSIA_SYSTEM_COMPOSITED_LAYER_H_
+
+#include "flutter/flow/layers/elevated_container_layer.h"
+
+namespace flutter {
+
+class FuchsiaSystemCompositedLayer : public ElevatedContainerLayer {
+ public:
+  static bool can_system_composite() { return true; }
+
+  FuchsiaSystemCompositedLayer(SkColor color, 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_; }
+
+ private:
+  SkRRect rrect_ = SkRRect::MakeEmpty();
+  SkColor color_ = SK_ColorTRANSPARENT;
+
+  FML_DISALLOW_COPY_AND_ASSIGN(FuchsiaSystemCompositedLayer);
+};
+
+}  // namespace flutter
+
+#endif  // FLUTTER_FLOW_LAYERS_FUCHSIA_SYSTEM_COMPOSITED_LAYER_H_
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);
+      SK_ColorTRANSPARENT, /* elevation */ 0.0f);
   if (root_layer_->needs_system_composite()) {
     root_layer_->UpdateScene(context);
   }
diff --git a/flow/layers/physical_shape_layer.cc b/flow/layers/physical_shape_layer.cc
@@ -17,31 +17,35 @@ PhysicalShapeLayer::PhysicalShapeLayer(SkColor color,
                                        float elevation,
                                        const SkPath& path,
                                        Clip clip_behavior)
-    : color_(color),
+    : PhysicalShapeLayerBase(color, elevation),
       shadow_color_(shadow_color),
-      elevation_(elevation),
       path_(path),
-      isRect_(false),
       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)) {
-    isRect_ = true;
-    frameRRect_ = SkRRect::MakeRect(rect);
-  } else if (path.isRRect(&frameRRect_)) {
-    isRect_ = frameRRect_.isRect();
+    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.
-    frameRRect_ = SkRRect::MakeOval(rect);
+    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.
-    frameRRect_ = SkRRect::MakeRect(path.getBounds());
+    rrect = SkRRect::MakeRect(path.getBounds());
   }
+
+  set_dimensions(rrect);
+#endif
 }
 
 Layer::AnalysisResult PhysicalShapeLayer::Analyze() const {
@@ -55,74 +59,39 @@ Layer::AnalysisResult PhysicalShapeLayer::Analyze() const {
 void PhysicalShapeLayer::Preroll(PrerollContext* context,
                                  const SkMatrix& matrix) {
   TRACE_EVENT0("flutter", "PhysicalShapeLayer::Preroll");
-  context->total_elevation += elevation_;
-  total_elevation_ = context->total_elevation;
-  SkRect child_paint_bounds;
-  PrerollChildren(context, matrix, &child_paint_bounds);
-  context->total_elevation -= elevation_;
-
-  if (elevation_ == 0) {
-    set_paint_bounds(path_.getBounds());
-  } else {
-#if defined(OS_FUCHSIA)
-    // Let the system compositor draw all shadows for us.
-    set_needs_system_composite(true);
-#else
-    // We will draw the shadow in Paint(), so add some margin to the paint
-    // bounds to leave space for the shadow. We fill this whole region and clip
-    // children to it so we don't need to join the child paint bounds.
-    set_paint_bounds(ComputeShadowBounds(path_.getBounds(), elevation_,
-                                         context->frame_device_pixel_ratio));
-#endif  // defined(OS_FUCHSIA)
-  }
-}
-
-#if defined(OS_FUCHSIA)
+  PhysicalShapeLayerBase::Preroll(context, matrix);
 
-void PhysicalShapeLayer::UpdateScene(SceneUpdateContext& context) {
-  FML_DCHECK(needs_system_composite());
-  TRACE_EVENT0("flutter", "PhysicalShapeLayer::UpdateScene");
-
-  // Retained rendering: speedup by reusing a retained entity node if possible.
-  // When an entity node is reused, no paint layer is added to the frame so we
-  // won't call PhysicalShapeLayer::Paint.
-  LayerRasterCacheKey key(unique_id(), context.Matrix());
-  if (context.HasRetainedNode(key)) {
-    TRACE_EVENT_INSTANT0("flutter", "retained layer cache hit");
-    const scenic::EntityNode& retained_node = context.GetRetainedNode(key);
-    FML_DCHECK(context.top_entity());
-    FML_DCHECK(retained_node.session() == context.session());
-    context.top_entity()->entity_node().AddChild(retained_node);
+  // 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) {
     return;
   }
 
-  TRACE_EVENT_INSTANT0("flutter", "cache miss, creating");
-  // If we can't find an existing retained surface, create one.
-  SceneUpdateContext::Frame frame(context, frameRRect_, color_, elevation_,
-                                  total_elevation_, this);
-  for (auto& layer : layers()) {
-    if (layer->needs_painting()) {
-      frame.AddPaintLayer(layer.get());
-    }
+  // We either can't (unavailable) or shouldn't (no shadows) use the system
+  // compositor.
+  set_needs_system_composite(false);
+  set_paint_bounds(path_.getBounds());  // Ignore children bounds; use the path
+  if (elevation() != 0) {
+    // We will draw the shadow in Paint(), so add some margin to the paint
+    // bounds to leave space for the shadow. We fill this whole region and clip
+    // children to it so we don't need to join the child paint bounds.
+    set_paint_bounds(ComputeShadowBounds(paint_bounds(), elevation(),
+                                         context->frame_device_pixel_ratio));
   }
-
-  UpdateSceneChildren(context);
 }
 
-#endif  // defined(OS_FUCHSIA)
-
 void PhysicalShapeLayer::Paint(PaintContext& context) const {
   TRACE_EVENT0("flutter", "PhysicalShapeLayer::Paint");
   FML_DCHECK(needs_painting());
 
-  if (elevation_ != 0) {
-    DrawShadow(context.leaf_nodes_canvas, path_, shadow_color_, elevation_,
-               SkColorGetA(color_) != 0xff, context.frame_device_pixel_ratio);
+  if (elevation() != 0) {
+    DrawShadow(context.leaf_nodes_canvas, path_, shadow_color_, elevation(),
+               SkColorGetA(color()) != 0xff, context.frame_device_pixel_ratio);
   }
 
   // Call drawPath without clip if possible for better performance.
   SkPaint paint;
-  paint.setColor(color_);
+  paint.setColor(color());
   paint.setAntiAlias(true);
   if (clip_behavior_ != Clip::antiAliasWithSaveLayer) {
     context.leaf_nodes_canvas->drawPath(path_, paint);
@@ -152,7 +121,7 @@ void PhysicalShapeLayer::Paint(PaintContext& context) const {
     context.leaf_nodes_canvas->drawPaint(paint);
   }
 
-  PaintChildren(context);
+  PhysicalShapeLayerBase::Paint(context);
 
   context.internal_nodes_canvas->restoreToCount(saveCount);
 }
diff --git a/flow/layers/physical_shape_layer.h b/flow/layers/physical_shape_layer.h
diff --git a/flow/layers/physical_shape_layer_unittests.cc b/flow/layers/physical_shape_layer_unittests.cc
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);`
	`92`	`+ SK_ColorTRANSPARENT, /* elevation */ 0.0f);`
`93`	`93`	`if (root_layer_->needs_system_composite()) {`
`94`	`94`	`root_layer_->UpdateScene(context);`
`95`	`95`	`}`