Collection Need RasterCache Layer in Preroll

Author: JsouLiang

flow/layers/container_layer.cc

@@ -104,6 +104,9 @@ void ContainerLayer::DiffChildren(DiffContext* context,
 }
 
 void ContainerLayer::Add(std::shared_ptr<Layer> layer) {
+  layer->SetLevel(level() + 1);
+  layer->SetAncestors(GetAncestors());
+  layer->AddAncestor(unique_id());
   layers_.emplace_back(std::move(layer));
 }
 
@@ -188,6 +191,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

@@ -42,6 +42,8 @@ void ImageFilterLayer::Preroll(PrerollContext* context,
   Layer::AutoPrerollSaveLayerState save =
       Layer::AutoPrerollSaveLayerState::Create(context);
 
+  AutoGatherLayers raster_cache_layers(context->raster_cached_layers);
+
   SkRect child_bounds = SkRect::MakeEmpty();
   PrerollChildren(context, matrix, &child_bounds);
 
@@ -63,7 +65,8 @@ void ImageFilterLayer::Preroll(PrerollContext* context,
     // 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);
+    // TryToPrepareRasterCache(context, this, matrix);
+    raster_cache_layers.SetCurrentLayer(this);
   } else {
     // This ImageFilterLayer is not yet considered stable so we
     // increment the count to measure how many times it has been
@@ -84,7 +87,8 @@ void ImageFilterLayer::Preroll(PrerollContext* context,
       // 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);
+      //  TryToPrepareRasterCache(context, GetCacheableChild(), matrix);
+      raster_cache_layers.SetCurrentLayer(GetCacheableChild());
     }
   }
 }

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,6 +36,11 @@ 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.
@@ -80,12 +87,32 @@ 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;
+
+  std::vector<Layer*> raster_cached_layers;
 };
 
-class PictureLayer;
-class DisplayListLayer;
-class PerformanceOverlayLayer;
-class TextureLayer;
+class AutoGatherLayers {
+ public:
+  explicit AutoGatherLayers(std::vector<Layer*>& layers)
+      : current_layer_(nullptr),
+        layers_(layers),
+        initial_size_(layers.size()) {}
+
+  void SetCurrentLayer(Layer* current_layer) { current_layer_ = current_layer; }
+
+  ~AutoGatherLayers() {
+    if (current_layer_) {
+      layers_.resize(
+          initial_size_);  // remove all child layers added in the meanwhile
+      layers_.push_back(current_layer_);
+    }
+  }
+
+ private:
+  Layer* current_layer_;
+  std::vector<Layer*>& layers_;
+  size_t initial_size_;
+};
 
 // Represents a single composited layer. Created on the UI thread but then
 // subquently used on the Rasterizer thread.
@@ -108,6 +135,9 @@ class Layer {
   // 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 +208,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);
@@ -329,6 +359,21 @@ class Layer {
 
   uint64_t unique_id() const { return unique_id_; }
 
+  void SetLevel(unsigned value) { level_ = value; }
+  unsigned level() const { return level_; }
+
+  void SetAncestors(const std::unordered_set<uint64_t>& ancestors) {
+    ancestors_ = ancestors;
+  }
+
+  void AddAncestor(uint64_t id) { ancestors_.insert(id); }
+
+  const std::unordered_set<uint64_t> GetAncestors() const { return ancestors_; }
+
+  bool HasAncestor(uint64_t id) {
+    return ancestors_.find(id) != ancestors_.end();
+  }
+
   virtual const PictureLayer* as_picture_layer() const { return nullptr; }
   virtual const DisplayListLayer* as_display_list_layer() const {
     return nullptr;
@@ -345,6 +390,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,37 @@ 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) {
+  auto& need_raster_cache_layers = context->raster_cached_layers;
+  std::sort(
+      need_raster_cache_layers.begin(), need_raster_cache_layers.end(),
+      [](const Layer* a, const Layer* b) { return a->level() < b->level(); });
+
+  const int length = need_raster_cache_layers.size();
+  for (int i = 0; i < length; i++) {
+    auto* current_layer = need_raster_cache_layers[i];
+    // check the ancestor has raster cached
+    bool current_layer_need_raster_cache = true;
+    for (int j = i - 1; j >= 0; j--) {
+      auto* low_level_layer = need_raster_cache_layers[j];
+      // if the ancestor also need raster cache, skip current layer
+      if (current_layer->HasAncestor(low_level_layer->unique_id())) {
+        current_layer_need_raster_cache = false;
+        break;
+      }
+    }
+    if (current_layer_need_raster_cache) {
+      current_layer->TryToPrepareRasterCache(context, ctm);
+    }
+  }
+}
+
 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;