Add SkPicture RasterCache

JsouLiang · JsouLiang · commit 463110ee41c7 · 2022-04-03T14:12:27.000+08:00
diff --git a/flow/layers/display_list_layer.cc b/flow/layers/display_list_layer.cc
@@ -93,12 +93,9 @@ void DisplayListLayer::Preroll(PrerollContext* context,
                                const SkMatrix& matrix) {
   TRACE_EVENT0("flutter", "DisplayListLayer::Preroll");
   auto cacheable_entry = RasterCacheableEntry::MarkDisplayListCacheable(
-      this->display_list(), *context, matrix, offset_, is_complex_,
-      will_change_);
+      this->display_list(), *context, matrix, offset_);
   context->raster_cached_entries.push_back(cacheable_entry);
-
-  auto& cache_entry = context->raster_cached_entries.back();
-  cache_entry->need_caching = NeedCaching(context, matrix);
+  cacheable_entry->need_caching = NeedCaching(context, matrix);
 }
 
 bool DisplayListLayer::NeedCaching(PrerollContext* context,
diff --git a/flow/layers/picture_layer.cc b/flow/layers/picture_layer.cc
@@ -110,24 +110,28 @@ sk_sp<SkData> PictureLayer::SerializedPicture() const {
 void PictureLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   TRACE_EVENT0("flutter", "PictureLayer::Preroll");
 
-  SkPicture* sk_picture = picture();
+  auto cacheable_entry = RasterCacheableEntry::MarkSkPictureCacheable(
+      this->picture(), *context, matrix, offset_);
+  context->raster_cached_entries.push_back(cacheable_entry);
+  cacheable_entry->need_caching = NeedCaching(context, matrix);
+}
 
+bool PictureLayer::NeedCaching(PrerollContext* context, const SkMatrix& ctm) {
+  SkPicture* sk_picture = picture();
   SkRect bounds = sk_picture->cullRect().makeOffset(offset_.x(), offset_.y());
+  set_paint_bounds(bounds);
 
   if (auto* cache = context->raster_cache) {
     TRACE_EVENT0("flutter", "PictureLayer::RasterCache (Preroll)");
     if (context->cull_rect.intersects(bounds)) {
-      if (cache->Prepare(context, sk_picture, is_complex_, will_change_, matrix,
-                         offset_)) {
+      if (cache->ShouldBeCached(context, sk_picture, is_complex_, will_change_,
+                                ctm)) {
         context->subtree_can_inherit_opacity = true;
       }
-    } else {
-      // Don't evict raster cache entry during partial repaint
-      cache->Touch(sk_picture, matrix);
     }
+    return true;
   }
-
-  set_paint_bounds(bounds);
+  return false;
 }
 
 void PictureLayer::Paint(PaintContext& context) const {
diff --git a/flow/layers/picture_layer.h b/flow/layers/picture_layer.h
@@ -32,6 +32,8 @@ class PictureLayer : public Layer {
 
   void Paint(PaintContext& context) const override;
 
+  bool NeedCaching(PrerollContext* context, const SkMatrix& ctm);
+
  private:
   SkPoint offset_;
   // Even though pictures themselves are not GPU resources, they may reference
diff --git a/flow/raster_cache.cc b/flow/raster_cache.cc
@@ -258,12 +258,12 @@ std::unique_ptr<RasterCacheResult> RasterCache::RasterizeLayer(
       });
 }
 
-bool RasterCache::Prepare(PrerollContext* context,
-                          SkPicture* picture,
-                          bool is_complex,
-                          bool will_change,
-                          const SkMatrix& untranslated_matrix,
-                          const SkPoint& offset) {
+bool RasterCache::ShouldBeCached(PrerollContext* context,
+                                 SkPicture* picture,
+                                 bool is_complex,
+                                 bool will_change,
+                                 const SkMatrix& untranslated_matrix,
+                                 const SkPoint& offset) {
   if (!GenerateNewCacheInThisFrame()) {
     return false;
   }
@@ -272,7 +272,13 @@ bool RasterCache::Prepare(PrerollContext* context,
     // We only deal with pictures that are worthy of rasterization.
     return false;
   }
+  return true;
+}
 
+bool RasterCache::Prepare(PrerollContext* context,
+                          SkPicture* picture,
+                          const SkMatrix& untranslated_matrix,
+                          const SkPoint& offset) {
   SkMatrix transformation_matrix = untranslated_matrix;
   transformation_matrix.preTranslate(offset.x(), offset.y());
 
@@ -327,20 +333,11 @@ bool RasterCache::ShouldBeCached(PrerollContext* context,
     return false;
   }
 
-  SkMatrix transformation_matrix = untranslated_matrix;
-  transformation_matrix.preTranslate(offset.x(), offset.y());
-
-  if (!transformation_matrix.invert(nullptr)) {
-    // 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;
diff --git a/flow/raster_cache.h b/flow/raster_cache.h
@@ -176,32 +176,40 @@ class RasterCache {
     return result;
   }
 
-  // Return true if the cache is generated.
+  // Return true if the SkPicture can be cached.
   //
   // We may return false and not generate the cache if
   // 1. There are too many pictures to be cached in the current frame.
   //    (See also kDefaultPictureAndDispLayListCacheLimitPerFrame.)
   // 2. The picture is not worth rasterizing
   // 3. The matrix is singular
   // 4. The picture is accessed too few times
+  bool ShouldBeCached(PrerollContext* context,
+                      SkPicture* picture,
+                      bool is_complex,
+                      bool will_change,
+                      const SkMatrix& untranslated_matrix,
+                      const SkPoint& offset = SkPoint());
+
+  // Prepare to cache the SkPicture.
+  // Return true if the cache is generated.
   bool Prepare(PrerollContext* context,
                SkPicture* picture,
-               bool is_complex,
-               bool will_change,
                const SkMatrix& untranslated_matrix,
                const SkPoint& offset = SkPoint());
 
+  // Return true if the DisplayList can be cached.
   bool ShouldBeCached(PrerollContext* context,
                       DisplayList* display_list,
                       bool is_complex,
                       bool will_change,
                       const SkMatrix& untranslated_matrix,
                       const SkPoint& offset = SkPoint());
 
+  // Prepare to cache the DisplayList.
+  // Return true if the cache is generated.
   bool Prepare(PrerollContext* context,
                DisplayList* display_list,
-               bool is_complex,
-               bool will_change,
                const SkMatrix& untranslated_matrix,
                const SkPoint& offset = SkPoint());
 
diff --git a/flow/raster_cacheable_entry.cc b/flow/raster_cacheable_entry.cc
@@ -28,8 +28,7 @@ void CacheableDisplayListWrapper::TryToPrepareRasterCache(
         display_list_->bounds().makeOffset(offset_.x(), offset_.y());
     TRACE_EVENT0("flutter", "DisplayListLayer::RasterCache");
     if (context->cull_rect.intersects(bounds)) {
-      cache->Prepare(context, display_list_, is_complex_, will_change_, matrix,
-                     offset_);
+      cache->Prepare(context, display_list_, matrix, offset_);
     } else {
       // Don't evict raster cache entry during partial repaint
       cache->Touch(display_list_, matrix);
@@ -46,8 +45,7 @@ void CacheableSkPictureWrapper::TryToPrepareRasterCache(
 
     TRACE_EVENT0("flutter", "PictureLayer::RasterCache (Preroll)");
     if (context->cull_rect.intersects(bounds)) {
-      if (cache->Prepare(context, sk_picture_, is_complex_, will_change_,
-                         matrix, offset_)) {
+      if (cache->Prepare(context, sk_picture_, matrix, offset_)) {
         context->subtree_can_inherit_opacity = true;
       }
     } else {
diff --git a/flow/raster_cacheable_entry.h b/flow/raster_cacheable_entry.h
@@ -55,25 +55,16 @@ class CacheableLayerWrapper : public CacheableItemWrapperBase {
 // CacheableEntry is a wrapper to erasure the Entry type.
 class SkGPUObjectCacheableWrapper : public CacheableItemWrapperBase {
  public:
-  explicit SkGPUObjectCacheableWrapper(SkPoint offset,
-                                       bool is_complex,
-                                       bool will_change)
-      : offset_(offset), is_complex_(is_complex), will_change_(will_change) {}
+  explicit SkGPUObjectCacheableWrapper(SkPoint offset) : offset_(offset) {}
 
  protected:
   SkPoint offset_;
-  bool is_complex_ = false;
-  bool will_change_ = false;
 };
 
 class CacheableDisplayListWrapper : public SkGPUObjectCacheableWrapper {
  public:
-  CacheableDisplayListWrapper(DisplayList* display_list,
-                              SkPoint offset,
-                              bool is_complex,
-                              bool will_change)
-      : SkGPUObjectCacheableWrapper(offset, is_complex, will_change),
-        display_list_(display_list) {}
+  CacheableDisplayListWrapper(DisplayList* display_list, SkPoint offset)
+      : SkGPUObjectCacheableWrapper(offset), display_list_(display_list) {}
 
   void TryToPrepareRasterCache(PrerollContext* context,
                                const SkMatrix& matrix) override;
@@ -88,12 +79,8 @@ class CacheableDisplayListWrapper : public SkGPUObjectCacheableWrapper {
 
 class CacheableSkPictureWrapper : public SkGPUObjectCacheableWrapper {
  public:
-  CacheableSkPictureWrapper(SkPicture* sk_picture,
-                            SkPoint offset,
-                            bool is_complex,
-                            bool will_change)
-      : SkGPUObjectCacheableWrapper(offset, is_complex, will_change),
-        sk_picture_(sk_picture) {}
+  CacheableSkPictureWrapper(SkPicture* sk_picture, SkPoint offset)
+      : SkGPUObjectCacheableWrapper(offset), sk_picture_(sk_picture) {}
 
   void TryToPrepareRasterCache(PrerollContext* context,
                                const SkMatrix& matrix) override;
@@ -130,13 +117,10 @@ class RasterCacheableEntry {
       const PrerollContext& context,
       const SkMatrix& matrix,
       SkPoint offset,
-      bool is_complex = false,
-      bool will_change = false,
       unsigned num_child = 0,
       bool need_caching = true) {
     return std::make_shared<RasterCacheableEntry>(
-        std::make_unique<CacheableDisplayListWrapper>(display_list, offset,
-                                                      is_complex, will_change),
+        std::make_unique<CacheableDisplayListWrapper>(display_list, offset),
         context, matrix, num_child, need_caching);
   }
 
@@ -145,14 +129,11 @@ class RasterCacheableEntry {
       const PrerollContext& context,
       const SkMatrix& matrix,
       SkPoint offset,
-      bool is_complex = false,
-      bool will_change = false,
       unsigned num_child = 0,
       bool need_caching = true) {
     return std::make_shared<RasterCacheableEntry>(
-        std::make_unique<CacheableSkPictureWrapper>(picture, offset, is_complex,
-                                                    will_change),
-        context, matrix, num_child, need_caching);
+        std::make_unique<CacheableSkPictureWrapper>(picture, offset), context,
+        matrix, num_child, need_caching);
   }
 
   CacheableItemWrapperBase* GetCacheableWrapper() const { return item_.get(); }
