Collection Raster Cacheable OpacityLayer in Preroll

Author: JsouLiang

flow/layers/color_filter_layer.cc

@@ -41,9 +41,7 @@ void ColorFilterLayer::Preroll(PrerollContext* context,
       context->raster_cached_entries.size() - current_index;
   auto cache_type = NeedCaching(context, matrix);
   if (cache_type == CacheableLayer::CacheType::kChildren) {
-    cacheable_entry->GetCacheableWrapper()
-        ->GetCacheableLayer()
-        ->NeedCacheChildren();
+    cacheable_entry->MarkLayerChildrenNeedCached();
   }
 }
 

flow/layers/image_filter_layer.cc

@@ -60,9 +60,7 @@ void ImageFilterLayer::Preroll(PrerollContext* context,
     cacheable_entry->need_caching = false;
   } else if (cache_type == CacheableLayer::CacheType::kChildren) {
     // Replace Cacheable child
-    cacheable_entry->GetCacheableWrapper()
-        ->GetCacheableLayer()
-        ->NeedCacheChildren();
+    cacheable_entry->MarkLayerChildrenNeedCached();
   }
 
   if (!filter_) {

flow/layers/opacity_layer.cc

@@ -4,6 +4,8 @@
 
 #include "flutter/flow/layers/opacity_layer.h"
 
+#include "flutter/flow/layers/cacheable_layer.h"
+#include "flutter/flow/raster_cacheable_entry.h"
 #include "flutter/fml/trace_event.h"
 #include "third_party/skia/include/core/SkPaint.h"
 
@@ -39,6 +41,11 @@ void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   TRACE_EVENT0("flutter", "OpacityLayer::Preroll");
   FML_DCHECK(!layers().empty());  // We can't be a leaf.
 
+  auto cacheable_entry =
+      RasterCacheableEntry::MarkLayerCacheable(this, *context, matrix);
+  context->raster_cached_entries.emplace_back(cacheable_entry);
+  auto current_index = context->raster_cached_entries.size();
+
   SkMatrix child_matrix = matrix;
   child_matrix.preTranslate(offset_.fX, offset_.fY);
 
@@ -54,23 +61,36 @@ void OpacityLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   ContainerLayer::Preroll(context, child_matrix);
   context->mutators_stack.Pop();
   context->mutators_stack.Pop();
-
   set_children_can_accept_opacity(context->subtree_can_inherit_opacity);
 
   set_paint_bounds(paint_bounds().makeOffset(offset_.fX, offset_.fY));
 
-  if (!children_can_accept_opacity()) {
+  cacheable_entry->num_child_entries =
+      context->raster_cached_entries.size() - current_index;
+
+  auto cache_type = NeedCaching(context, matrix);
+  if (cache_type == CacheableLayer::CacheType::kChildren) {
 #ifndef SUPPORT_FRACTIONAL_TRANSLATION
     child_matrix = RasterCache::GetIntegralTransCTM(child_matrix);
 #endif
-    TryToPrepareRasterCache(context, child_matrix,
-                            RasterCacheLayerStrategy::kLayerChildren);
+    cacheable_entry->matrix = child_matrix;
+    cacheable_entry->MarkLayerChildrenNeedCached();
+  } else if (cache_type == CacheableLayer::CacheType::kNone) {
+    cacheable_entry->need_caching = false;
   }
 
   // Restore cull_rect
   context->cull_rect = context->cull_rect.makeOffset(offset_.fX, offset_.fY);
 }
 
+CacheableLayer::CacheType OpacityLayer::NeedCaching(PrerollContext* context,
+                                                    const SkMatrix& ctm) {
+  if (!children_can_accept_opacity()) {
+    return CacheableLayer::CacheType::kChildren;
+  }
+  return CacheableLayer::CacheType::kNone;
+}
+
 void OpacityLayer::Paint(PaintContext& context) const {
   TRACE_EVENT0("flutter", "OpacityLayer::Paint");
   FML_DCHECK(needs_painting(context));

flow/layers/opacity_layer.h

@@ -33,6 +33,9 @@ class OpacityLayer : public ContainerLayer {
 
   void Paint(PaintContext& context) const override;
 
+  CacheableLayer::CacheType NeedCaching(PrerollContext* context,
+                                        const SkMatrix& ctm) override;
+
   // Returns whether the children are capable of inheriting an opacity value
   // and modifying their rendering accordingly. This value is only guaranteed
   // to be valid after the local |Preroll| method is called.

flow/raster_cacheable_entry.h

@@ -6,7 +6,6 @@
 #define FLUTTER_FLOW_RASTER_CACHEABLE_ENTRY_H_
 
 #include <memory>
-#include <unordered_map>
 
 #include "flutter/flow/embedded_views.h"
 #include "include/core/SkPicture.h"
@@ -158,6 +157,10 @@ class RasterCacheableEntry {
 
   CacheableItemWrapperBase* GetCacheableWrapper() const { return item_.get(); }
 
+  void MarkLayerChildrenNeedCached() {
+    item_->GetCacheableLayer()->NeedCacheChildren();
+  }
+
   void TryToPrepareRasterCache(PrerollContext* context);
 
   SkMatrix matrix;