Enhance image_filter_layer caching to filter a cached child

Author: flar

flow/layers/container_layer.cc

@@ -85,4 +85,36 @@ void ContainerLayer::UpdateSceneChildren(SceneUpdateContext& context) {
 
 #endif  // defined(OS_FUCHSIA)
 
+MergedContainerLayer::MergedContainerLayer() {
+  // Ensure the layer has only one direct child.
+  //
+  // This intermediary container helps container layers that want or need
+  // to cache the rendering of their children to do so more easily.
+  // TBD (flar) - mention caveat and use of GetCacheableChild() here...
+  //
+  // Any children will be actually added as children of this empty
+  // ContainerLayer.
+  ContainerLayer::Add(std::make_shared<ContainerLayer>());
+}
+
+void MergedContainerLayer::Add(std::shared_ptr<Layer> layer) {
+  GetChildContainer()->Add(std::move(layer));
+}
+
+ContainerLayer* MergedContainerLayer::GetChildContainer() const {
+  FML_DCHECK(layers().size() == 1);
+
+  return static_cast<ContainerLayer*>(layers()[0].get());
+}
+
+Layer* MergedContainerLayer::GetCacheableChild() const {
+  ContainerLayer* child_container = GetChildContainer();
+  if (child_container->layers().size() == 1) {
+    return child_container->layers()[0].get();
+  }
+
+  FML_LOG(INFO) << "Single child layer does not contain a single child";
+  return child_container;
+}
+
 }  // namespace flutter

flow/layers/container_layer.h

@@ -34,15 +34,33 @@ class ContainerLayer : public Layer {
   void UpdateSceneChildren(SceneUpdateContext& context);
 #endif  // defined(OS_FUCHSIA)
 
-  // For OpacityLayer to restructure to have a single child.
-  void ClearChildren() { layers_.clear(); }
-
  private:
   std::vector<std::shared_ptr<Layer>> layers_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(ContainerLayer);
 };
 
+class MergedContainerLayer : public ContainerLayer {
+ public:
+  MergedContainerLayer();
+
+  void Add(std::shared_ptr<Layer> layer) override;
+
+ protected:
+  ContainerLayer* GetChildContainer() const;
+
+  // The ChildContainer will be created anew whenever the MergedContainerLayer
+  // subclass is created even though the real child of the container may be
+  // the same child. If the MergedContainerLayer wants to cache the rendering
+  // of its "child" then the cache will need to be redrawn on every frame that
+  // the MergedContainer is different, defeating the purpose of caching. This
+  // method will attempt to return the real child (if there is only one) to
+  // improve the chance of caching.
+  Layer* GetCacheableChild() const;
+
+  FML_DISALLOW_COPY_AND_ASSIGN(MergedContainerLayer);
+};
+
 }  // namespace flutter
 
 #endif  // FLUTTER_FLOW_LAYERS_CONTAINER_LAYER_H_

flow/layers/image_filter_layer.cc

@@ -6,8 +6,10 @@
 
 namespace flutter {
 
+#define MINIMUM_FILTER_CACHE 2
+
 ImageFilterLayer::ImageFilterLayer(sk_sp<SkImageFilter> filter)
-    : filter_(std::move(filter)) {}
+    : filter_(std::move(filter)), render_count_(1) {}
 
 void ImageFilterLayer::Preroll(PrerollContext* context,
                                const SkMatrix& matrix) {
@@ -16,25 +18,29 @@ void ImageFilterLayer::Preroll(PrerollContext* context,
   Layer::AutoPrerollSaveLayerState save =
       Layer::AutoPrerollSaveLayerState::Create(context);
 
-  child_paint_bounds_ = SkRect::MakeEmpty();
-  PrerollChildren(context, matrix, &child_paint_bounds_);
+  SkRect child_bounds = SkRect::MakeEmpty();
+  PrerollChildren(context, matrix, &child_bounds);
   if (filter_) {
-    const SkIRect filter_input_bounds = child_paint_bounds_.roundOut();
+    const SkIRect filter_input_bounds = child_bounds.roundOut();
     SkIRect filter_output_bounds =
         filter_->filterBounds(filter_input_bounds, SkMatrix::I(),
                               SkImageFilter::kForward_MapDirection);
-    set_paint_bounds(SkRect::Make(filter_output_bounds));
-  } else {
-    set_paint_bounds(child_paint_bounds_);
+    child_bounds = SkRect::Make(filter_output_bounds);
   }
+  set_paint_bounds(child_bounds);
 
   if (!context->has_platform_view && context->raster_cache &&
       SkRect::Intersects(context->cull_rect, paint_bounds())) {
     SkMatrix ctm = matrix;
 #ifndef SUPPORT_FRACTIONAL_TRANSLATION
     ctm = RasterCache::GetIntegralTransCTM(ctm);
 #endif
-    context->raster_cache->Prepare(context, this, ctm);
+    if (render_count_ >= MINIMUM_FILTER_CACHE) {
+      context->raster_cache->Prepare(context, this, ctm);
+    } else {
+      render_count_++;
+      context->raster_cache->Prepare(context, GetCacheableChild(), ctm);
+    }
   }
 }
 
@@ -53,20 +59,36 @@ void ImageFilterLayer::Paint(PaintContext& context) const {
     RasterCacheResult layer_cache =
         context.raster_cache->Get((Layer*)this, ctm);
     if (layer_cache.is_valid()) {
+      FML_LOG(ERROR) << "Rendering filtered output from cache";
       layer_cache.draw(*context.leaf_nodes_canvas);
       return;
     }
+    layer_cache = context.raster_cache->Get(GetCacheableChild(), ctm);
+    if (layer_cache.is_valid()) {
+      sk_sp<SkImageFilter> transformed_filter =
+          filter_->makeWithLocalMatrix(ctm);
+      if (transformed_filter) {
+        FML_LOG(ERROR) << "Filtering from cached child";
+
+        SkPaint paint;
+        paint.setImageFilter(transformed_filter);
+
+        layer_cache.draw(*context.leaf_nodes_canvas, &paint);
+        return;
+      }
+    }
   }
 
+  FML_LOG(ERROR) << "Applying filter to child on the fly";
   SkPaint paint;
   paint.setImageFilter(filter_);
 
   // Normally a save_layer is sized to the current layer bounds, but in this
   // case the bounds of the child may not be the same as the filtered version
   // so we use the child_paint_bounds_ which were snapshotted from the
   // Preroll on the children before we adjusted them based on the filter.
-  Layer::AutoSaveLayer save_layer =
-      Layer::AutoSaveLayer::Create(context, child_paint_bounds_, &paint);
+  Layer::AutoSaveLayer save_layer = Layer::AutoSaveLayer::Create(
+      context, GetChildContainer()->paint_bounds(), &paint);
   PaintChildren(context);
 }
 

flow/layers/image_filter_layer.h

@@ -11,7 +11,7 @@
 
 namespace flutter {
 
-class ImageFilterLayer : public ContainerLayer {
+class ImageFilterLayer : public MergedContainerLayer {
  public:
   ImageFilterLayer(sk_sp<SkImageFilter> filter);
 
@@ -21,7 +21,7 @@ class ImageFilterLayer : public ContainerLayer {
 
  private:
   sk_sp<SkImageFilter> filter_;
-  SkRect child_paint_bounds_;
+  int render_count_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(ImageFilterLayer);
 };

flow/layers/opacity_layer.cc

@@ -15,20 +15,7 @@ namespace flutter {
 constexpr float kOpacityElevationWhenUsingSystemCompositor = 0.01f;
 
 OpacityLayer::OpacityLayer(SkAlpha alpha, const SkPoint& offset)
-    : alpha_(alpha), offset_(offset) {
-  // Ensure OpacityLayer has only one direct child.
-  //
-  // This is needed to ensure that retained rendering can always be applied to
-  // save the costly saveLayer.
-  //
-  // Any children will be actually added as children of this empty
-  // ContainerLayer.
-  ContainerLayer::Add(std::make_shared<ContainerLayer>());
-}
-
-void OpacityLayer::Add(std::shared_ptr<Layer> layer) {
-  GetChildContainer()->Add(std::move(layer));
-}
+    : alpha_(alpha), offset_(offset) {}
 
 void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   TRACE_EVENT0("flutter", "OpacityLayer::Preroll");
@@ -71,7 +58,7 @@ void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
 #ifndef SUPPORT_FRACTIONAL_TRANSLATION
       ctm = RasterCache::GetIntegralTransCTM(ctm);
 #endif
-      context->raster_cache->Prepare(context, container, ctm);
+      context->raster_cache->Prepare(context, GetCacheableChild(), ctm);
     }
   }
 }
@@ -92,9 +79,9 @@ void OpacityLayer::Paint(PaintContext& context) const {
 #endif
 
   if (context.raster_cache) {
-    ContainerLayer* container = GetChildContainer();
+    Layer* layer = GetCacheableChild();
     const SkMatrix& ctm = context.leaf_nodes_canvas->getTotalMatrix();
-    RasterCacheResult child_cache = context.raster_cache->Get(container, ctm);
+    RasterCacheResult child_cache = context.raster_cache->Get(layer, ctm);
     if (child_cache.is_valid()) {
       child_cache.draw(*context.leaf_nodes_canvas, &paint);
       return;
@@ -157,10 +144,4 @@ void OpacityLayer::UpdateScene(SceneUpdateContext& context) {
 
 #endif  // defined(OS_FUCHSIA)
 
-ContainerLayer* OpacityLayer::GetChildContainer() const {
-  FML_DCHECK(layers().size() == 1);
-
-  return static_cast<ContainerLayer*>(layers()[0].get());
-}
-
 }  // namespace flutter

flow/layers/opacity_layer.h

@@ -13,7 +13,7 @@ namespace flutter {
 // 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 MergedContainerLayer {
  public:
   // An offset is provided here because OpacityLayer.addToScene method in the
   // Flutter framework can take an optional offset argument.
@@ -27,8 +27,6 @@ class OpacityLayer : public ContainerLayer {
   // the propagation as repainting the OpacityLayer is expensive.
   OpacityLayer(SkAlpha alpha, const SkPoint& offset);
 
-  void Add(std::shared_ptr<Layer> layer) override;
-
   void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
 
   void Paint(PaintContext& context) const override;
@@ -38,8 +36,6 @@ class OpacityLayer : public ContainerLayer {
 #endif  // defined(OS_FUCHSIA)
 
  private:
-  ContainerLayer* GetChildContainer() const;
-
   SkAlpha alpha_;
   SkPoint offset_;
   SkRRect frameRRect_;

flow/raster_cache.cc

@@ -137,6 +137,7 @@ void RasterCache::Prepare(PrerollContext* context,
   entry.access_count++;
   entry.used_this_frame = true;
   if (!entry.image.is_valid()) {
+    FML_LOG(ERROR) << "Rasterizing " << layer->unique_id();
     entry.image = Rasterize(
         context->gr_context, ctm, context->dst_color_space,
         checkerboard_images_, layer->paint_bounds(),