Collection Need RasterCache Layer in Preroll

Author: JsouLiang

flow/layers/container_layer.cc

@@ -188,6 +188,18 @@ void ContainerLayer::PaintChildren(PaintContext& context) const {
   }
 }
 
+void ContainerLayer::TryToPrepareRasterCache(PrerollContext* context,
+                                             const SkMatrix& ctm) {
+  if (!context->has_platform_view && !context->has_texture_layer &&
+      context->raster_cache &&
+      SkRect::Intersects(context->cull_rect, this->paint_bounds())) {
+    context->raster_cache->Prepare(context, this, ctm);
+  } else if (context->raster_cache) {
+    // Don't evict raster cache entry during partial repaint
+    context->raster_cache->Touch(this, ctm);
+  }
+}
+
 void ContainerLayer::TryToPrepareRasterCache(PrerollContext* context,
                                              Layer* layer,
                                              const SkMatrix& matrix) {

flow/layers/container_layer.h

@@ -20,6 +20,9 @@ class ContainerLayer : public Layer {
 
   virtual void Add(std::shared_ptr<Layer> layer);
 
+  void TryToPrepareRasterCache(PrerollContext* context,
+                               const SkMatrix& ctm) override;
+
   void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
   void Paint(PaintContext& context) const override;
 

flow/layers/image_filter_layer.cc

@@ -39,12 +39,22 @@ void ImageFilterLayer::Diff(DiffContext* context, const Layer* old_layer) {
 void ImageFilterLayer::Preroll(PrerollContext* context,
                                const SkMatrix& matrix) {
   TRACE_EVENT0("flutter", "ImageFilterLayer::Preroll");
+
   Layer::AutoPrerollSaveLayerState save =
       Layer::AutoPrerollSaveLayerState::Create(context);
 
+  context->raster_cached_entries.emplace_back(RasterCacheEntry(this));
+  auto current_index = context->raster_cached_entries.size();
+
+  auto& cache_entry = context->raster_cached_entries.back();
+
   SkRect child_bounds = SkRect::MakeEmpty();
   PrerollChildren(context, matrix, &child_bounds);
 
+  cache_entry.num_child_entries =
+      context->raster_cached_entries.size() - current_index;
+  cache_entry.need_caching = IsNeedCached(context, matrix);
+
   if (!filter_) {
     set_paint_bounds(child_bounds);
     return;
@@ -56,37 +66,36 @@ void ImageFilterLayer::Preroll(PrerollContext* context,
   child_bounds = SkRect::Make(filter_output_bounds);
 
   set_paint_bounds(child_bounds);
+}
 
-  transformed_filter_ = nullptr;
+bool ImageFilterLayer::IsNeedCached(PrerollContext* context,
+                                    const SkMatrix& ctm) {
   if (render_count_ >= kMinimumRendersBeforeCachingFilterLayer) {
-    // We have rendered this same ImageFilterLayer object enough
-    // times to consider its properties and children to be stable
-    // from frame to frame so we try to cache the layer itself
-    // for maximum performance.
-    TryToPrepareRasterCache(context, this, matrix);
-  } else {
-    // This ImageFilterLayer is not yet considered stable so we
-    // increment the count to measure how many times it has been
-    // seen from frame to frame.
-    render_count_++;
-
-    // Now we will try to pre-render the children into the cache.
-    // To apply the filter to pre-rendered children, we must first
-    // modify the filter to be aware of the transform under which
-    // the cached bitmap was produced. Some SkImageFilter
-    // instances can do this operation on some transforms and some
-    // (filters or transforms) cannot. We can only cache the children
-    // and apply the filter on the fly if this operation succeeds.
-    transformed_filter_ = filter_->makeWithLocalMatrix(matrix);
-    if (transformed_filter_) {
-      // With a modified SkImageFilter we can now try to cache the
-      // children to avoid their rendering costs if they remain
-      // stable between frames and also avoiding a rendering surface
-      // switch during the Paint phase even if they are not stable.
-      // This benefit is seen most during animations.
-      TryToPrepareRasterCache(context, GetCacheableChild(), matrix);
-    }
+    return true;
+  }
+  transformed_filter_ = nullptr;
+  // This ImageFilterLayer is not yet considered stable so we
+  // increment the count to measure how many times it has been
+  // seen from frame to frame.
+  render_count_++;
+
+  // Now we will try to pre-render the children into the cache.
+  // To apply the filter to pre-rendered children, we must first
+  // modify the filter to be aware of the transform under which
+  // the cached bitmap was produced. Some SkImageFilter
+  // instances can do this operation on some transforms and some
+  // (filters or transforms) cannot. We can only cache the children
+  // and apply the filter on the fly if this operation succeeds.
+  transformed_filter_ = filter_->makeWithLocalMatrix(ctm);
+  if (transformed_filter_) {
+    // With a modified SkImageFilter we can now try to cache the
+    // children to avoid their rendering costs if they remain
+    // stable between frames and also avoiding a rendering surface
+    // switch during the Paint phase even if they are not stable.
+    // This benefit is seen most during animations.
+    return true;
   }
+  return false;
 }
 
 void ImageFilterLayer::Paint(PaintContext& context) const {

flow/layers/image_filter_layer.h

@@ -20,6 +20,8 @@ class ImageFilterLayer : public MergedContainerLayer {
 
   void Paint(PaintContext& context) const override;
 
+  bool IsNeedCached(PrerollContext* context, const SkMatrix& ctm) override;
+
  private:
   // The ImageFilterLayer might cache the filtered output of this layer
   // if the layer remains stable (if it is not animating for instance).

flow/layers/layer.cc

@@ -3,8 +3,11 @@
 // found in the LICENSE file.
 
 #include "flutter/flow/layers/layer.h"
+#include <algorithm>
 
 #include "flutter/flow/paint_utils.h"
+#include "flutter/flow/raster_cache.h"
+#include "include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 
 namespace flutter {
@@ -29,6 +32,9 @@ uint64_t Layer::NextUniqueID() {
 
 void Layer::Preroll(PrerollContext* context, const SkMatrix& matrix) {}
 
+void Layer::TryToPrepareRasterCache(PrerollContext* context,
+                                    const SkMatrix& ctm) {}
+
 Layer::AutoPrerollSaveLayerState::AutoPrerollSaveLayerState(
     PrerollContext* preroll_context,
     bool save_layer_is_active,

flow/layers/layer.h

@@ -5,7 +5,9 @@
 #ifndef FLUTTER_FLOW_LAYERS_LAYER_H_
 #define FLUTTER_FLOW_LAYERS_LAYER_H_
 
+#include <algorithm>
 #include <memory>
+#include <unordered_set>
 #include <vector>
 
 #include "flutter/common/graphics/texture.h"
@@ -34,11 +36,24 @@ namespace testing {
 class MockLayer;
 }  // namespace testing
 
+class PictureLayer;
+class DisplayListLayer;
+class PerformanceOverlayLayer;
+class TextureLayer;
+
 static constexpr SkRect kGiantRect = SkRect::MakeLTRB(-1E9F, -1E9F, 1E9F, 1E9F);
 
 // This should be an exact copy of the Clip enum in painting.dart.
 enum Clip { none, hardEdge, antiAlias, antiAliasWithSaveLayer };
 
+struct RasterCacheEntry {
+  explicit RasterCacheEntry(Layer* layer)
+      : layer(layer), num_child_entries(0), need_caching(false) {}
+
+  Layer* layer;
+  unsigned num_child_entries;
+  bool need_caching;
+};
 struct PrerollContext {
   RasterCache* raster_cache;
   GrDirectContext* gr_context;
@@ -80,12 +95,9 @@ struct PrerollContext {
   // than to remember the value so that it can choose the right strategy
   // for its |Paint| method.
   bool subtree_can_inherit_opacity = false;
-};
 
-class PictureLayer;
-class DisplayListLayer;
-class PerformanceOverlayLayer;
-class TextureLayer;
+  std::vector<RasterCacheEntry> raster_cached_entries;
+};
 
 // Represents a single composited layer. Created on the UI thread but then
 // subquently used on the Rasterizer thread.
@@ -105,9 +117,16 @@ class Layer {
     return original_layer_id_ == old_layer->original_layer_id_;
   }
 
+  virtual bool IsNeedCached(PrerollContext* context, const SkMatrix& ctm) {
+    return false;
+  }
+
   // Performs diff with given layer
   virtual void Diff(DiffContext* context, const Layer* old_layer) {}
 
+  virtual void TryToPrepareRasterCache(PrerollContext* context,
+                                       const SkMatrix& ctm);
+
   // Used when diffing retained layer; In case the layer is identical, it
   // doesn't need to be diffed, but the paint region needs to be stored in diff
   // context so that it can be used in next frame
@@ -178,7 +197,7 @@ class Layer {
 
   class AutoCachePaint {
    public:
-    AutoCachePaint(PaintContext& context) : context_(context) {
+    explicit AutoCachePaint(PaintContext& context) : context_(context) {
       needs_paint_ = context.inherited_opacity < SK_Scalar1;
       if (needs_paint_) {
         paint_.setAlphaf(context.inherited_opacity);
@@ -345,6 +364,9 @@ class Layer {
   uint64_t original_layer_id_;
   bool subtree_has_platform_view_;
   bool layer_can_inherit_opacity_;
+  std::unordered_set<uint64_t> ancestors_ = {};
+
+  unsigned level_ = 0;
 
   static uint64_t NextUniqueID();
 

flow/layers/layer_tree.cc

@@ -6,8 +6,10 @@
 
 #include "flutter/flow/frame_timings.h"
 #include "flutter/flow/layers/layer.h"
+#include "flutter/flow/raster_cache.h"
 #include "flutter/fml/time/time_point.h"
 #include "flutter/fml/trace_event.h"
+#include "include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/utils/SkNWayCanvas.h"
 
@@ -52,9 +54,22 @@ bool LayerTree::Preroll(CompositorContext::ScopedFrame& frame,
       device_pixel_ratio_};
 
   root_layer_->Preroll(&context, frame.root_surface_transformation());
+
+  RasterCache(&context, frame.root_surface_transformation());
+
   return context.surface_needs_readback;
 }
 
+void LayerTree::RasterCache(PrerollContext* context, const SkMatrix& ctm) {
+  for (unsigned i = 0; i < context->raster_cached_entries.size(); i++) {
+    auto& entry = context->raster_cached_entries[i];
+    if (entry.need_caching) {
+      entry.layer->TryToPrepareRasterCache(context, ctm);
+      i += entry.num_child_entries;
+    }
+  }
+}
+
 void LayerTree::Paint(CompositorContext::ScopedFrame& frame,
                       bool ignore_raster_cache) const {
   TRACE_EVENT0("flutter", "LayerTree::Paint");

flow/layers/layer_tree.h

@@ -32,6 +32,8 @@ class LayerTree {
                bool ignore_raster_cache = false,
                SkRect cull_rect = kGiantRect);
 
+  void RasterCache(PrerollContext* context, const SkMatrix& ctm);
+
   void Paint(CompositorContext::ScopedFrame& frame,
              bool ignore_raster_cache = false) const;