Collection Need RasterCache DisplayListLayer In Preroll

Author: JsouLiang

flow/layers/display_list_layer.cc

@@ -5,6 +5,7 @@
 #include "flutter/flow/layers/display_list_layer.h"
 
 #include "flutter/display_list/display_list_builder.h"
+#include "flutter/flow/layers/layer.h"
 
 namespace flutter {
 
@@ -91,24 +92,45 @@ bool DisplayListLayer::Compare(DiffContext::Statistics& statistics,
 void DisplayListLayer::Preroll(PrerollContext* context,
                                const SkMatrix& matrix) {
   TRACE_EVENT0("flutter", "DisplayListLayer::Preroll");
+  context->raster_cached_entries.emplace_back(RasterCacheEntry(this));
 
+  auto& cache_entry = context->raster_cached_entries.back();
+  // display layer is a leaf node
+  cache_entry.num_child_entries = 0;
+  cache_entry.need_caching = IsNeedCached(context, matrix);
+}
+
+bool DisplayListLayer::IsNeedCached(PrerollContext* context,
+                                    const SkMatrix& ctm) {
   DisplayList* disp_list = display_list();
 
   SkRect bounds = disp_list->bounds().makeOffset(offset_.x(), offset_.y());
 
   if (auto* cache = context->raster_cache) {
     TRACE_EVENT0("flutter", "DisplayListLayer::RasterCache (Preroll)");
     if (context->cull_rect.intersects(bounds)) {
-      if (cache->Prepare(context, disp_list, is_complex_, will_change_, matrix,
-                         offset_)) {
-        context->subtree_can_inherit_opacity = true;
-      }
-    } else {
-      // Don't evict raster cache entry during partial repaint
-      cache->Touch(disp_list, matrix);
+      return cache->ShouldBeCached(context, disp_list, is_complex_,
+                                   will_change_, ctm);
+    }
+  }
+  return false;
+}
+
+void DisplayListLayer::TryToPrepareRasterCache(PrerollContext* context,
+                                               const SkMatrix& ctm) {
+  DisplayList* disp_list = display_list();
+
+  SkRect bounds = disp_list->bounds().makeOffset(offset_.x(), offset_.y());
+  auto* cache = context->raster_cache;
+  if (context->cull_rect.intersects(bounds)) {
+    if (cache->Prepare(context, disp_list, is_complex_, will_change_, ctm,
+                       offset_)) {
+      context->subtree_can_inherit_opacity = true;
     }
+  } else {
+    // Don't evict raster cache entry during partial repaint
+    cache->Touch(disp_list, ctm);
   }
-  set_paint_bounds(bounds);
 }
 
 void DisplayListLayer::Paint(PaintContext& context) const {

flow/layers/display_list_layer.h

@@ -7,7 +7,9 @@
 
 #include "flutter/display_list/display_list.h"
 #include "flutter/flow/layers/layer.h"
+#include "flutter/flow/raster_cache.h"
 #include "flutter/flow/skia_gpu_object.h"
+#include "include/core/SkMatrix.h"
 
 namespace flutter {
 
@@ -32,6 +34,11 @@ class DisplayListLayer : public Layer {
     return this;
   }
 
+  bool IsNeedCached(PrerollContext* context, const SkMatrix& ctm) override;
+
+  void TryToPrepareRasterCache(PrerollContext* context,
+                               const SkMatrix& ctm) override;
+
   void Preroll(PrerollContext* frame, const SkMatrix& matrix) override;
 
   void Paint(PaintContext& context) const override;

flow/layers/layer.h

@@ -364,9 +364,6 @@ 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/raster_cache.cc

@@ -265,12 +265,12 @@ bool RasterCache::Prepare(PrerollContext* context,
   return true;
 }
 
-bool RasterCache::Prepare(PrerollContext* context,
-                          DisplayList* display_list,
-                          bool is_complex,
-                          bool will_change,
-                          const SkMatrix& untranslated_matrix,
-                          const SkPoint& offset) {
+bool RasterCache::ShouldBeCached(PrerollContext* context,
+                                 DisplayList* display_list,
+                                 bool is_complex,
+                                 bool will_change,
+                                 const SkMatrix& untranslated_matrix,
+                                 const SkPoint& offset) {
   if (!GenerateNewCacheInThisFrame()) {
     return false;
   }
@@ -293,6 +293,17 @@ bool RasterCache::Prepare(PrerollContext* context,
     // The matrix was singular. No point in going further.
     return false;
   }
+  return true;
+}
+
+bool RasterCache::Prepare(PrerollContext* context,
+                          DisplayList* display_list,
+                          bool is_complex,
+                          bool will_change,
+                          const SkMatrix& untranslated_matrix,
+                          const SkPoint& offset) {
+  SkMatrix transformation_matrix = untranslated_matrix;
+  transformation_matrix.preTranslate(offset.x(), offset.y());
 
   RasterCacheKey cache_key(display_list->unique_id(),
                            RasterCacheKeyType::kDisplayList,

flow/raster_cache.h

@@ -187,6 +187,14 @@ class RasterCache {
                bool will_change,
                const SkMatrix& untranslated_matrix,
                const SkPoint& offset = SkPoint());
+
+  bool ShouldBeCached(PrerollContext* context,
+                      DisplayList* display_list,
+                      bool is_complex,
+                      bool will_change,
+                      const SkMatrix& untranslated_matrix,
+                      const SkPoint& offset = SkPoint());
+
   bool Prepare(PrerollContext* context,
                DisplayList* display_list,
                bool is_complex,