raster cache process analysis

Author: JsouLiang

flow/layers/display_list_raster_cache_item.cc

@@ -81,6 +81,7 @@ void DisplayListRasterCacheItem::PrerollSetup(PrerollContext* context,
     return;
   }
 
+  matrix_ = matrix;
   transformation_matrix_ = matrix;
   transformation_matrix_.preTranslate(offset_.x(), offset_.y());
 
@@ -117,11 +118,18 @@ void DisplayListRasterCacheItem::PrerollFinalize(PrerollContext* context,
     context->subtree_can_inherit_opacity = true;
     cache_state_ = CacheState::kCurrent;
   } else {
+    // if the bounds with the cull rect is not intersect, we only touch the
+    // cache entry. And should not cache the display list
+    cache_state_ = CacheState::kNone;
     raster_cache->Touch(key_id_, matrix);
   }
   return;
 }
 
+bool DisplayListRasterCacheItem::Touch(const PaintContext* context) const {
+  return context->raster_cache->Touch(key_id_, transformation_matrix_);
+}
+
 bool DisplayListRasterCacheItem::Draw(const PaintContext& context,
                                       const SkPaint* paint) const {
   return Draw(context, context.leaf_nodes_canvas, paint);
@@ -133,27 +141,20 @@ bool DisplayListRasterCacheItem::Draw(const PaintContext& context,
   if (!context.raster_cache || !canvas) {
     return false;
   }
-  if (cache_state_ == CacheState::kCurrent) {
-    return context.raster_cache->Draw(key_id_, *canvas, paint);
-  }
-  // This display_list doesn't cache itself, this only increase the entry
-  // access_count;
-  context.raster_cache->Touch(key_id_, canvas->getTotalMatrix());
-  return false;
+  return context.raster_cache->Draw(key_id_, *canvas, paint);
 }
 
 static const auto* flow_type = "RasterCacheFlow::DisplayList";
 
 bool DisplayListRasterCacheItem::TryToPrepareRasterCache(
-    const PaintContext& context,
-    bool parent_cached) const {
+    const PaintContext& context) const {
   // If we don't have raster_cache we should not cache the current display_list.
   // If the current node's ancestor has been cached we also should not cache the
   // current node. In the current frame, the raster_cache will collect all
   // display_list or picture_list to calculate the memory they used, we
   // shouldn't cache the current node if the memory is more significant than the
   // limit.
-  if (cache_state_ == kNone || !context.raster_cache || parent_cached ||
+  if (cache_state_ == kNone || !context.raster_cache ||
       !context.raster_cache->GenerateNewCacheInThisFrame()) {
     return false;
   }

flow/layers/display_list_raster_cache_item.h

@@ -38,14 +38,15 @@ class DisplayListRasterCacheItem : public RasterCacheItem {
   void PrerollFinalize(PrerollContext* context,
                        const SkMatrix& matrix) override;
 
+  bool Touch(const PaintContext* context) const override;
+
   bool Draw(const PaintContext& context, const SkPaint* paint) const override;
 
   bool Draw(const PaintContext& context,
             SkCanvas* canvas,
             const SkPaint* paint) const override;
 
-  bool TryToPrepareRasterCache(const PaintContext& context,
-                               bool parent_cached = false) const override;
+  bool TryToPrepareRasterCache(const PaintContext& context) const override;
 
   void ModifyMatrix(SkPoint offset) const {
     matrix_ = matrix_.preTranslate(offset.x(), offset.y());

flow/layers/layer_raster_cache_item.cc

@@ -42,18 +42,11 @@ void LayerRasterCacheItem::PrerollFinalize(PrerollContext* context,
   if (!context->raster_cache || !context->raster_cached_entries) {
     return;
   }
-  // We've marked the cache entry that we would like to cache so it stays
-  // alive, but if the following conditions apply then we need to set our
-  // state back to kDoNotCache so that we don't populate the entry later.
-  if (context->has_platform_view || context->has_texture_layer ||
-      !SkRect::Intersects(context->cull_rect, layer_->paint_bounds())) {
-    return;
-  }
   child_items_ = context->raster_cached_entries->size() - child_items_;
+  // Determine cache current layer or cache children.
   if (num_cache_attempts_ >= layer_cached_threshold_) {
     // the layer can be cached
     cache_state_ = CacheState::kCurrent;
-    context->raster_cache->MarkSeen(key_id_, matrix_);
   } else {
     num_cache_attempts_++;
     // access current layer
@@ -67,9 +60,25 @@ void LayerRasterCacheItem::PrerollFinalize(PrerollContext* context,
                                    RasterCacheKeyType::kLayerChildren);
       }
       cache_state_ = CacheState::kChildren;
-      context->raster_cache->MarkSeen(layer_children_id_.value(), matrix_);
     }
   }
+  // We've marked the cache entry that we would like to cache so it stays
+  // alive, but if the following conditions apply then we need to set our
+  // state back to kDoNotCache so that we don't populate the entry later.
+  if (context->has_platform_view || context->has_texture_layer ||
+      !SkRect::Intersects(context->cull_rect, layer_->paint_bounds())) {
+    if (cache_state_ != CacheState::kNone) {
+      // Only touch the entry, do not to cache the layer or children.
+      context->raster_cache->Touch(GetId().value(), matrix);
+      cache_state_ = CacheState::kNone;
+    }
+    return;
+  }
+  // The layer can be cache, so we should create a entry.
+  if (cache_state_ != CacheState::kNone) {
+    // Create Cache entry
+    context->raster_cache->MarkSeen(GetId().value(), matrix);
+  }
 }
 
 std::optional<RasterCacheKeyID> LayerRasterCacheItem::GetId() const {
@@ -138,9 +147,9 @@ bool Rasterize(RasterCacheItem::CacheState cache_state,
 
 static const auto* flow_type = "RasterCacheFlow::Layer";
 
-bool LayerRasterCacheItem::TryToPrepareRasterCache(const PaintContext& context,
-                                                   bool parent_cached) const {
-  if (!context.raster_cache || parent_cached) {
+bool LayerRasterCacheItem::TryToPrepareRasterCache(
+    const PaintContext& context) const {
+  if (!context.raster_cache) {
     return false;
   }
   if (cache_state_ != kNone) {
@@ -171,6 +180,10 @@ bool LayerRasterCacheItem::Draw(const PaintContext& context,
   return Draw(context, context.leaf_nodes_canvas, paint);
 }
 
+bool LayerRasterCacheItem::Touch(const PaintContext* context) const {
+  return context->raster_cache->Touch(GetId().value(), matrix_);
+}
+
 bool LayerRasterCacheItem::Draw(const PaintContext& context,
                                 SkCanvas* canvas,
                                 const SkPaint* paint) const {

flow/layers/layer_raster_cache_item.h

@@ -38,12 +38,13 @@ class LayerRasterCacheItem : public RasterCacheItem {
 
   bool Draw(const PaintContext& context, const SkPaint* paint) const override;
 
+  bool Touch(const PaintContext* context) const override;
+
   bool Draw(const PaintContext& context,
             SkCanvas* canvas,
             const SkPaint* paint) const override;
 
-  bool TryToPrepareRasterCache(const PaintContext& context,
-                               bool parent_cached = false) const override;
+  bool TryToPrepareRasterCache(const PaintContext& context) const override;
 
   void MarkCacheChildren() { can_cache_children_ = true; }
 

flow/layers/layer_tree.cc

@@ -84,12 +84,13 @@ void LayerTree::TryToRasterCache(
       // try to cache current layer
       // If parent failed to cache, just proceed to the next entry
       // cache current entry, this entry's parent must not cache
-      if (item->TryToPrepareRasterCache(*paint_context, false)) {
+      if (item->TryToPrepareRasterCache(*paint_context)) {
         // if parent cached, then foreach child layer to touch them.
         for (unsigned j = 0; j < item->child_items(); j++) {
           auto* child_item = raster_cached_items[i + j + 1];
           if (child_item->need_caching()) {
-            child_item->TryToPrepareRasterCache(*paint_context, true);
+            // If parent has cached, we only touch this cache entry.
+            child_item->Touch(paint_context);
           }
         }
         i += item->child_items() + 1;

flow/raster_cache_item.h

@@ -45,6 +45,8 @@ class RasterCacheItem {
   virtual void PrerollFinalize(PrerollContext* context,
                                const SkMatrix& matrix) = 0;
 
+  virtual bool Touch(const PaintContext* context) const = 0;
+
   virtual bool Draw(const PaintContext& context,
                     const SkPaint* paint) const = 0;
 
@@ -54,8 +56,7 @@ class RasterCacheItem {
 
   virtual std::optional<RasterCacheKeyID> GetId() const { return key_id_; }
 
-  virtual bool TryToPrepareRasterCache(const PaintContext& context,
-                                       bool parent_cached = false) const = 0;
+  virtual bool TryToPrepareRasterCache(const PaintContext& context) const = 0;
 
   unsigned child_items() const { return child_items_; }