Conditionally use offscreen root surface only when needed

Currently helps primarily on iOS when no BackdropFilter is present by lowering energy usage

Author: flar

flow/compositor_context.cc

@@ -36,10 +36,11 @@ std::unique_ptr<CompositorContext::ScopedFrame> CompositorContext::AcquireFrame(
     ExternalViewEmbedder* view_embedder,
     const SkMatrix& root_surface_transformation,
     bool instrumentation_enabled,
+    bool surface_supports_readback,
     fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger) {
   return std::make_unique<ScopedFrame>(
       *this, gr_context, canvas, view_embedder, root_surface_transformation,
-      instrumentation_enabled, gpu_thread_merger);
+      instrumentation_enabled, surface_supports_readback, gpu_thread_merger);
 }
 
 CompositorContext::ScopedFrame::ScopedFrame(
@@ -49,13 +50,15 @@ CompositorContext::ScopedFrame::ScopedFrame(
     ExternalViewEmbedder* view_embedder,
     const SkMatrix& root_surface_transformation,
     bool instrumentation_enabled,
+    bool surface_supports_readback,
     fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger)
     : context_(context),
       gr_context_(gr_context),
       canvas_(canvas),
       view_embedder_(view_embedder),
       root_surface_transformation_(root_surface_transformation),
       instrumentation_enabled_(instrumentation_enabled),
+      surface_supports_readback_(surface_supports_readback),
       gpu_thread_merger_(gpu_thread_merger) {
   context_.BeginFrame(*this, instrumentation_enabled_);
 }
@@ -67,7 +70,8 @@ CompositorContext::ScopedFrame::~ScopedFrame() {
 RasterStatus CompositorContext::ScopedFrame::Raster(
     flutter::LayerTree& layer_tree,
     bool ignore_raster_cache) {
-  layer_tree.Preroll(*this, ignore_raster_cache);
+  bool root_needs_readback = layer_tree.Preroll(*this, ignore_raster_cache);
+  bool needs_save_layer = root_needs_readback && !surface_supports_readback();
   PostPrerollResult post_preroll_result = PostPrerollResult::kSuccess;
   if (view_embedder_ && gpu_thread_merger_) {
     post_preroll_result = view_embedder_->PostPrerollAction(gpu_thread_merger_);
@@ -79,9 +83,19 @@ RasterStatus CompositorContext::ScopedFrame::Raster(
   // Clearing canvas after preroll reduces one render target switch when preroll
   // paints some raster cache.
   if (canvas()) {
+    if (needs_save_layer) {
+      FML_LOG(INFO) << "Using SaveLayer to protect non-readback surface";
+      SkRect bounds = SkRect::Make(layer_tree.frame_size());
+      SkPaint paint;
+      paint.setBlendMode(SkBlendMode::kSrc);
+      canvas()->saveLayer(&bounds, &paint);
+    }
     canvas()->clear(SK_ColorTRANSPARENT);
   }
   layer_tree.Paint(*this, ignore_raster_cache);
+  if (canvas() && needs_save_layer) {
+    canvas()->restore();
+  }
   return RasterStatus::kSuccess;
 }
 

flow/compositor_context.h

@@ -45,6 +45,7 @@ class CompositorContext {
                 ExternalViewEmbedder* view_embedder,
                 const SkMatrix& root_surface_transformation,
                 bool instrumentation_enabled,
+                bool surface_supports_readback,
                 fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger);
 
     virtual ~ScopedFrame();
@@ -59,6 +60,8 @@ class CompositorContext {
       return root_surface_transformation_;
     }
 
+    bool surface_supports_readback() { return surface_supports_readback_; }
+
     GrContext* gr_context() const { return gr_context_; }
 
     virtual RasterStatus Raster(LayerTree& layer_tree,
@@ -71,6 +74,7 @@ class CompositorContext {
     ExternalViewEmbedder* view_embedder_;
     const SkMatrix& root_surface_transformation_;
     const bool instrumentation_enabled_;
+    const bool surface_supports_readback_;
     fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger_;
 
     FML_DISALLOW_COPY_AND_ASSIGN(ScopedFrame);
@@ -86,6 +90,7 @@ class CompositorContext {
       ExternalViewEmbedder* view_embedder,
       const SkMatrix& root_surface_transformation,
       bool instrumentation_enabled,
+      bool surface_supports_readback,
       fml::RefPtr<fml::GpuThreadMerger> gpu_thread_merger);
 
   void OnGrContextCreated();

flow/layers/backdrop_filter_layer.cc

@@ -9,6 +9,13 @@ namespace flutter {
 BackdropFilterLayer::BackdropFilterLayer(sk_sp<SkImageFilter> filter)
     : filter_(std::move(filter)) {}
 
+void BackdropFilterLayer::Preroll(PrerollContext* context,
+                                  const SkMatrix& matrix) {
+  Layer::AutoPrerollSaveLayerState save =
+      Layer::AutoPrerollSaveLayerState::Create(context, true, bool(filter_));
+  ContainerLayer::Preroll(context, matrix);
+}
+
 void BackdropFilterLayer::Paint(PaintContext& context) const {
   TRACE_EVENT0("flutter", "BackdropFilterLayer::Paint");
   FML_DCHECK(needs_painting());

flow/layers/backdrop_filter_layer.h

@@ -15,6 +15,8 @@ class BackdropFilterLayer : public ContainerLayer {
  public:
   BackdropFilterLayer(sk_sp<SkImageFilter> filter);
 
+  void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
+
   void Paint(PaintContext& context) const override;
 
  private:

flow/layers/backdrop_filter_layer_unittests.cc

@@ -182,5 +182,36 @@ TEST_F(BackdropFilterLayerTest, Nested) {
                  MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
 }
 
+TEST_F(BackdropFilterLayerTest, Readback) {
+  sk_sp<SkImageFilter> no_filter;
+  auto layer_filter = SkImageFilters::Paint(SkPaint(SkColors::kMagenta));
+  auto initial_transform = SkMatrix();
+
+  // BDF with filter always reads from surface
+  auto layer1 = std::make_shared<BackdropFilterLayer>(layer_filter);
+  preroll_context()->surface_needs_readback = false;
+  layer1->Preroll(preroll_context(), initial_transform);
+  EXPECT_TRUE(preroll_context()->surface_needs_readback);
+
+  // BDF with no filter does not read from surface itself
+  auto layer2 = std::make_shared<BackdropFilterLayer>(no_filter);
+  preroll_context()->surface_needs_readback = false;
+  layer2->Preroll(preroll_context(), initial_transform);
+  EXPECT_FALSE(preroll_context()->surface_needs_readback);
+
+  // BDF with no filter does not block prior readback value
+  preroll_context()->surface_needs_readback = true;
+  layer2->Preroll(preroll_context(), initial_transform);
+  EXPECT_TRUE(preroll_context()->surface_needs_readback);
+
+  // BDF with no filter blocks child with readback
+  auto mock_layer =
+      std::make_shared<MockLayer>(SkPath(), SkPaint(), false, false, true);
+  layer2->Add(mock_layer);
+  preroll_context()->surface_needs_readback = false;
+  layer2->Preroll(preroll_context(), initial_transform);
+  EXPECT_FALSE(preroll_context()->surface_needs_readback);
+}
+
 }  // namespace testing
 }  // namespace flutter

flow/layers/clip_path_layer.cc

@@ -22,6 +22,8 @@ void ClipPathLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   SkRect clip_path_bounds = clip_path_.getBounds();
   children_inside_clip_ = context->cull_rect.intersect(clip_path_bounds);
   if (children_inside_clip_) {
+    Layer::AutoPrerollSaveLayerState save =
+        Layer::AutoPrerollSaveLayerState::Create(context, UsesSaveLayer());
     context->mutators_stack.PushClipPath(clip_path_);
     SkRect child_paint_bounds = SkRect::MakeEmpty();
     PrerollChildren(context, matrix, &child_paint_bounds);
@@ -57,11 +59,11 @@ void ClipPathLayer::Paint(PaintContext& context) const {
   context.internal_nodes_canvas->clipPath(clip_path_,
                                           clip_behavior_ != Clip::hardEdge);
 
-  if (clip_behavior_ == Clip::antiAliasWithSaveLayer) {
+  if (UsesSaveLayer()) {
     context.internal_nodes_canvas->saveLayer(paint_bounds(), nullptr);
   }
   PaintChildren(context);
-  if (clip_behavior_ == Clip::antiAliasWithSaveLayer) {
+  if (UsesSaveLayer()) {
     context.internal_nodes_canvas->restore();
   }
 }

flow/layers/clip_path_layer.h

@@ -17,6 +17,10 @@ class ClipPathLayer : public ContainerLayer {
 
   void Paint(PaintContext& context) const override;
 
+  bool UsesSaveLayer() const {
+    return clip_behavior_ == Clip::antiAliasWithSaveLayer;
+  }
+
 #if defined(OS_FUCHSIA)
   void UpdateScene(SceneUpdateContext& context) override;
 #endif  // defined(OS_FUCHSIA)

flow/layers/clip_path_layer_unittests.cc

@@ -192,5 +192,65 @@ TEST_F(ClipPathLayerTest, PartiallyContainedChild) {
            MockCanvas::DrawCall{1, MockCanvas::RestoreData{0}}}));
 }
 
+static bool ReadbackResult(PrerollContext* context,
+                           Clip clip_behavior,
+                           std::shared_ptr<Layer> child,
+                           bool before) {
+  const SkMatrix initial_matrix = SkMatrix();
+  const SkRect layer_bounds = SkRect::MakeXYWH(0.5, 1.0, 5.0, 6.0);
+  const SkPath layer_path = SkPath().addRect(layer_bounds);
+  auto layer = std::make_shared<ClipPathLayer>(layer_path, clip_behavior);
+  if (child != nullptr) {
+    layer->Add(child);
+  }
+  context->surface_needs_readback = before;
+  layer->Preroll(context, initial_matrix);
+  return context->surface_needs_readback;
+}
+
+TEST_F(ClipPathLayerTest, Readback) {
+  PrerollContext* context = preroll_context();
+  SkPath path;
+  SkPaint paint;
+
+  const Clip hard = Clip::hardEdge;
+  const Clip soft = Clip::antiAlias;
+  const Clip save_layer = Clip::antiAliasWithSaveLayer;
+
+  std::shared_ptr<MockLayer> nochild;
+  auto reader = std::make_shared<MockLayer>(path, paint, false, false, true);
+  auto nonreader = std::make_shared<MockLayer>(path, paint);
+
+  // No children, no prior readback -> no readback after
+  EXPECT_FALSE(ReadbackResult(context, hard, nochild, false));
+  EXPECT_FALSE(ReadbackResult(context, soft, nochild, false));
+  EXPECT_FALSE(ReadbackResult(context, save_layer, nochild, false));
+
+  // No children, prior readback -> readback after
+  EXPECT_TRUE(ReadbackResult(context, hard, nochild, true));
+  EXPECT_TRUE(ReadbackResult(context, soft, nochild, true));
+  EXPECT_TRUE(ReadbackResult(context, save_layer, nochild, true));
+
+  // Non readback child, no prior readback -> no readback after
+  EXPECT_FALSE(ReadbackResult(context, hard, nonreader, false));
+  EXPECT_FALSE(ReadbackResult(context, soft, nonreader, false));
+  EXPECT_FALSE(ReadbackResult(context, save_layer, nonreader, false));
+
+  // Non readback child, prior readback -> readback after
+  EXPECT_TRUE(ReadbackResult(context, hard, nonreader, true));
+  EXPECT_TRUE(ReadbackResult(context, soft, nonreader, true));
+  EXPECT_TRUE(ReadbackResult(context, save_layer, nonreader, true));
+
+  // Readback child, no prior readback -> readback after unless SaveLayer
+  EXPECT_TRUE(ReadbackResult(context, hard, reader, false));
+  EXPECT_TRUE(ReadbackResult(context, soft, reader, false));
+  EXPECT_FALSE(ReadbackResult(context, save_layer, reader, false));
+
+  // Readback child, prior readback -> readback after
+  EXPECT_TRUE(ReadbackResult(context, hard, reader, true));
+  EXPECT_TRUE(ReadbackResult(context, soft, reader, true));
+  EXPECT_TRUE(ReadbackResult(context, save_layer, reader, true));
+}
+
 }  // namespace testing
 }  // namespace flutter

flow/layers/clip_rect_layer.cc

@@ -15,6 +15,8 @@ void ClipRectLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   SkRect previous_cull_rect = context->cull_rect;
   children_inside_clip_ = context->cull_rect.intersect(clip_rect_);
   if (children_inside_clip_) {
+    Layer::AutoPrerollSaveLayerState save =
+        Layer::AutoPrerollSaveLayerState::Create(context, UsesSaveLayer());
     context->mutators_stack.PushClipRect(clip_rect_);
     SkRect child_paint_bounds = SkRect::MakeEmpty();
     PrerollChildren(context, matrix, &child_paint_bounds);
@@ -50,11 +52,11 @@ void ClipRectLayer::Paint(PaintContext& context) const {
   context.internal_nodes_canvas->clipRect(clip_rect_,
                                           clip_behavior_ != Clip::hardEdge);
 
-  if (clip_behavior_ == Clip::antiAliasWithSaveLayer) {
+  if (UsesSaveLayer()) {
     context.internal_nodes_canvas->saveLayer(clip_rect_, nullptr);
   }
   PaintChildren(context);
-  if (clip_behavior_ == Clip::antiAliasWithSaveLayer) {
+  if (UsesSaveLayer()) {
     context.internal_nodes_canvas->restore();
   }
 }

flow/layers/clip_rect_layer.h

@@ -16,6 +16,10 @@ class ClipRectLayer : public ContainerLayer {
   void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
   void Paint(PaintContext& context) const override;
 
+  bool UsesSaveLayer() const {
+    return clip_behavior_ == Clip::antiAliasWithSaveLayer;
+  }
+
 #if defined(OS_FUCHSIA)
   void UpdateScene(SceneUpdateContext& context) override;
 #endif  // defined(OS_FUCHSIA)