Add SkPicture RasterCache

Author: JsouLiang

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,

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 {

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

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;

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());