Fix some failed cases; Add new test case for collect RasterCacheable …

…layer

flow/layers/color_filter_layer_unittests.cc

@@ -2,10 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "flutter/flow/compositor_context.h"
 #include "flutter/flow/layers/color_filter_layer.h"
 
 #include "flutter/display_list/display_list_color_filter.h"
 #include "flutter/flow/layers/opacity_layer.h"
+#include "flutter/flow/layers/layer_tree.h"
 #include "flutter/flow/testing/layer_test.h"
 #include "flutter/flow/testing/mock_layer.h"
 #include "flutter/fml/macros.h"
@@ -253,6 +255,7 @@ TEST_F(ColorFilterLayerTest, CacheChild) {
                                     RasterCacheLayerStrategy::kLayerChildren));
 
   layer->Preroll(preroll_context(), initial_transform);
+  LayerTree::TryToRasterCache(preroll_context());
 
   EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
   EXPECT_FALSE(raster_cache()->Draw(mock_layer.get(), other_canvas));
@@ -303,6 +306,7 @@ TEST_F(ColorFilterLayerTest, CacheChildren) {
                                     RasterCacheLayerStrategy::kLayerChildren));
 
   layer->Preroll(preroll_context(), initial_transform);
+  LayerTree::TryToRasterCache(preroll_context());
 
   EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
   EXPECT_FALSE(raster_cache()->Draw(mock_layer1.get(), other_canvas));

flow/layers/container_layer_unittests.cc

@@ -9,6 +9,7 @@
 #include "flutter/flow/testing/mock_layer.h"
 #include "flutter/fml/macros.h"
 #include "flutter/testing/mock_canvas.h"
+#include "gtest/gtest.h"
 
 namespace flutter {
 namespace testing {
@@ -246,6 +247,32 @@ TEST_F(ContainerLayerTest, OpacityInheritance) {
   container2->Preroll(context, SkMatrix::I());
   EXPECT_FALSE(context->subtree_can_inherit_opacity);
 }
+TEST_F(ContainerLayerTest, CollectionCacheableLayer) {
+  SkPath child_path;
+  child_path.addRect(5.0f, 6.0f, 20.5f, 21.5f);
+  SkPaint child_paint(SkColors::kGreen);
+  SkMatrix initial_transform = SkMatrix::Translate(-0.5f, -0.5f);
+
+  auto mock_layer1 = std::make_shared<MockLayer>(SkPath(), child_paint);
+  auto mock_cacheable_container_layer1 =
+      std::make_shared<MockCacheableContainerLayer>();
+  auto mock_container_layer = std::make_shared<ContainerLayer>();
+  auto mock_cacheable_layer =
+      std::make_shared<MockCacheableLayer>(child_path, child_paint);
+  mock_cacheable_container_layer1->Add(mock_cacheable_layer);
+
+  // ContainerLayer
+  //   |- MockLayer
+  //   |- MockCacheableContainerLayer
+  //        |- MockCacheableLayer
+  auto layer = std::make_shared<ContainerLayer>();
+  layer->Add(mock_cacheable_container_layer1);
+  layer->Add(mock_layer1);
+
+  layer->Preroll(preroll_context(), initial_transform);
+  ASSERT_EQ(preroll_context()->raster_cached_entries.size(),
+            static_cast<const unsigned long>(2));
+}
 
 using ContainerLayerDiffTest = DiffContextTest;
 

flow/layers/image_filter_layer_unittests.cc

@@ -4,6 +4,7 @@
 
 #include "flutter/flow/layers/image_filter_layer.h"
 
+#include "flutter/flow/layers/layer_tree.h"
 #include "flutter/flow/layers/transform_layer.h"
 #include "flutter/flow/testing/diff_context_test.h"
 #include "flutter/flow/testing/layer_test.h"
@@ -306,6 +307,7 @@ TEST_F(ImageFilterLayerTest, CacheChild) {
                                     RasterCacheLayerStrategy::kLayerChildren));
 
   layer->Preroll(preroll_context(), initial_transform);
+  LayerTree::TryToRasterCache(preroll_context());
 
   EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
   EXPECT_FALSE(raster_cache()->Draw(mock_layer.get(), other_canvas));
@@ -357,6 +359,7 @@ TEST_F(ImageFilterLayerTest, CacheChildren) {
                                     RasterCacheLayerStrategy::kLayerChildren));
 
   layer->Preroll(preroll_context(), initial_transform);
+  LayerTree::TryToRasterCache(preroll_context());
 
   EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
   EXPECT_FALSE(raster_cache()->Draw(mock_layer1.get(), other_canvas));

flow/layers/layer_tree.cc

@@ -9,7 +9,6 @@
 #include "flutter/flow/layer_snapshot_store.h"
 #include "flutter/flow/layers/cacheable_layer.h"
 #include "flutter/flow/layers/layer.h"
-#include "flutter/flow/raster_cache.h"
 #include "flutter/fml/time/time_point.h"
 #include "flutter/fml/trace_event.h"
 #include "include/core/SkMatrix.h"
@@ -66,38 +65,36 @@ bool LayerTree::Preroll(CompositorContext::ScopedFrame& frame,
 
   root_layer_->Preroll(&context, frame.root_surface_transformation());
 
-  RasterCache(frame, &context);
+  TryToRasterCache(&context);
 
   return context.surface_needs_readback;
 }
 
-void LayerTree::RasterCache(CompositorContext::ScopedFrame& frame,
-                            PrerollContext* context,
-                            bool ignore_raster_cache) {
-  auto* color_space = GetColorSpace(frame.canvas());
-  auto* raster_cache =
-      ignore_raster_cache ? nullptr : &frame.context().raster_cache();
+void LayerTree::TryToRasterCache(PrerollContext* context,
+                                 bool ignore_raster_cache) {
   auto mutator_stack = MutatorsStack();
   for (unsigned i = 0; i < context->raster_cached_entries.size(); i++) {
     auto& entry = context->raster_cached_entries[i];
     if (entry->need_caching) {
-      PrerollContext context = {
-          raster_cache,
-          frame.gr_context(),
-          frame.view_embedder(),
-          mutator_stack,
-          color_space,
-          entry->cull_rect,
-          false,
-          frame.context().raster_time(),
-          frame.context().ui_time(),
-          frame.context().texture_registry(),
-          checkerboard_offscreen_layers_,
-          device_pixel_ratio_,
-          entry->has_platform_view,
-          entry->has_texture_layer,
+      PrerollContext preroll_context = {
+          // clang-format off
+          .raster_cache                  = context->raster_cache,
+          .gr_context                    = context->gr_context,
+          .view_embedder                 = context->view_embedder,
+          .mutators_stack                = mutator_stack,
+          .dst_color_space               = context->dst_color_space,
+          .cull_rect                     = entry->cull_rect,
+          .surface_needs_readback        = false,
+          .raster_time                   = context->raster_time,
+          .ui_time                       = context->ui_time,
+          .texture_registry              = context->texture_registry,
+          .checkerboard_offscreen_layers = context->checkerboard_offscreen_layers,
+          .frame_device_pixel_ratio      = context->frame_device_pixel_ratio,
+          .has_platform_view             = entry->has_platform_view,
+          .has_texture_layer             = entry->has_texture_layer,
+          // clang-format on
       };
-      entry->TryToPrepareRasterCache(&context);
+      entry->TryToPrepareRasterCache(&preroll_context);
       i += entry->num_child_entries;
     }
   }

flow/layers/layer_tree.h

@@ -10,7 +10,6 @@
 
 #include "flutter/flow/compositor_context.h"
 #include "flutter/flow/layers/layer.h"
-#include "flutter/flow/raster_cache.h"
 #include "flutter/fml/macros.h"
 #include "flutter/fml/time/time_delta.h"
 #include "third_party/skia/include/core/SkPicture.h"
@@ -33,9 +32,8 @@ class LayerTree {
                bool ignore_raster_cache = false,
                SkRect cull_rect = kGiantRect);
 
-  void RasterCache(CompositorContext::ScopedFrame& frame,
-                   PrerollContext* context,
-                   bool ignore_raster_cache = false);
+  static void TryToRasterCache(PrerollContext* context,
+                               bool ignore_raster_cache = false);
 
   void Paint(CompositorContext::ScopedFrame& frame,
              bool ignore_raster_cache = false) const;

flow/layers/layer_tree_unittests.cc

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <stddef.h>
 #include "flutter/flow/layers/layer_tree.h"
 
 #include "flutter/flow/compositor_context.h"
@@ -14,7 +15,6 @@
 
 namespace flutter {
 namespace testing {
-
 class LayerTreeTest : public CanvasTest {
  public:
   LayerTreeTest()
@@ -198,7 +198,7 @@ TEST_F(LayerTreeTest, PrerollContextInitialization) {
   // PrerollContext that this test must be revisited and updated.
   // If any fields get removed or replaced, then the expect_defaults closure
   // will fail to compile, again bringing attention to updating this test.
-  EXPECT_EQ(sizeof(PrerollContext), size_t(104));
+  EXPECT_EQ(sizeof(PrerollContext), size_t(128));
 
   MutatorsStack mock_mutators;
   FixedRefreshRateStopwatch mock_raster_time;
@@ -225,6 +225,7 @@ TEST_F(LayerTreeTest, PrerollContextInitialization) {
     EXPECT_EQ(context.has_texture_layer, false);
 
     EXPECT_EQ(context.subtree_can_inherit_opacity, false);
+    EXPECT_EQ(context.raster_cached_entries.size(), static_cast<size_t>(0));
   };
 
   // These 4 initializers are required because they are handled by reference

flow/layers/opacity_layer_unittests.cc

@@ -7,6 +7,7 @@
 #include "flutter/flow/layers/clip_rect_layer.h"
 #include "flutter/flow/layers/image_filter_layer.h"
 #include "flutter/flow/layers/transform_layer.h"
+#include "flutter/flow/layers/layer_tree.h"
 #include "flutter/flow/testing/diff_context_test.h"
 #include "flutter/flow/testing/layer_test.h"
 #include "flutter/flow/testing/mock_layer.h"
@@ -106,6 +107,7 @@ TEST_F(OpacityLayerTest, CacheChild) {
                                     RasterCacheLayerStrategy::kLayerChildren));
 
   layer->Preroll(preroll_context(), initial_transform);
+  LayerTree::TryToRasterCache(preroll_context());
 
   EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
   EXPECT_FALSE(raster_cache()->Draw(mock_layer.get(), other_canvas));
@@ -156,6 +158,7 @@ TEST_F(OpacityLayerTest, CacheChildren) {
                                     RasterCacheLayerStrategy::kLayerChildren));
 
   layer->Preroll(preroll_context(), initial_transform);
+  LayerTree::TryToRasterCache(preroll_context());
 
   EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
   EXPECT_FALSE(raster_cache()->Draw(mock_layer1.get(), other_canvas));

flow/layers/shader_mask_layer.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "flutter/flow/layers/shader_mask_layer.h"
+#include "flutter/flow/raster_cacheable_entry.h"
 
 namespace flutter {
 
@@ -12,7 +13,9 @@ ShaderMaskLayer::ShaderMaskLayer(sk_sp<SkShader> shader,
     : shader_(shader),
       mask_rect_(mask_rect),
       blend_mode_(blend_mode),
-      render_count_(1) {}
+      render_count_(1) {
+  set_layer_can_inherit_opacity(true);
+}
 
 void ShaderMaskLayer::Diff(DiffContext* context, const Layer* old_layer) {
   DiffContext::AutoSubtreeRestore subtree(context);
@@ -25,6 +28,11 @@ void ShaderMaskLayer::Diff(DiffContext* context, const Layer* old_layer) {
     }
   }
 
+#ifndef SUPPORT_FRACTIONAL_TRANSLATION
+  context->SetTransform(
+      RasterCache::GetIntegralTransCTM(context->GetTransform()));
+#endif
+
   DiffChildren(context, prev);
 
   context->SetLayerPaintRegion(this, context->CurrentSubtreeRegion());
@@ -33,34 +41,33 @@ void ShaderMaskLayer::Diff(DiffContext* context, const Layer* old_layer) {
 void ShaderMaskLayer::Preroll(PrerollContext* context, const SkMatrix& matrix) {
   Layer::AutoPrerollSaveLayerState save =
       Layer::AutoPrerollSaveLayerState::Create(context);
-  ContainerLayer::Preroll(context, matrix);
 
-  // We always paint with a saveLayer (or a cached rendering),
-  // so we can always apply opacity in any of those cases.
-  context->subtree_can_inherit_opacity = true;
+  Cacheable::AutoCache::Create(this, context, matrix);
 
-  SkMatrix child_matrix(matrix);
+  ContainerLayer::Preroll(context, matrix);
+}
+
+Cacheable::CacheType ShaderMaskLayer::NeedCaching(PrerollContext* context,
+                                                  const SkMatrix& ctm) {
   if (render_count_ >= kMinimumRendersBeforeCachingFilterLayer) {
-    TryToPrepareRasterCache(context, this, child_matrix,
-                            RasterCacheLayerStrategy::kLayer);
+    return Cacheable::CacheType::kCurrent;
   } else {
     render_count_++;
+    return Cacheable::CacheType::kNone;
   }
 }
 
 void ShaderMaskLayer::Paint(PaintContext& context) const {
   TRACE_EVENT0("flutter", "ShaderMaskLayer::Paint");
   FML_DCHECK(needs_painting(context));
 
-  AutoCachePaint cache_paint(context);
-
   if (context.raster_cache &&
       context.raster_cache->Draw(this, *context.leaf_nodes_canvas,
-                                 RasterCacheLayerStrategy::kLayer,
-                                 cache_paint.paint())) {
+                                 RasterCacheLayerStrategy::kLayer)) {
     return;
   }
 
+  AutoCachePaint cache_paint(context);
   Layer::AutoSaveLayer save = Layer::AutoSaveLayer::Create(
       context, paint_bounds(), cache_paint.paint());
   PaintChildren(context);

flow/layers/shader_mask_layer.h

@@ -5,12 +5,13 @@
 #ifndef FLUTTER_FLOW_LAYERS_SHADER_MASK_LAYER_H_
 #define FLUTTER_FLOW_LAYERS_SHADER_MASK_LAYER_H_
 
+#include "flutter/flow/layers/cacheable_layer.h"
 #include "flutter/flow/layers/container_layer.h"
 #include "third_party/skia/include/core/SkShader.h"
 
 namespace flutter {
 
-class ShaderMaskLayer : public ContainerLayer {
+class ShaderMaskLayer : public ContainerLayer, public Cacheable {
  public:
   ShaderMaskLayer(sk_sp<SkShader> shader,
                   const SkRect& mask_rect,
@@ -22,6 +23,11 @@ class ShaderMaskLayer : public ContainerLayer {
 
   void Paint(PaintContext& context) const override;
 
+  Layer* asLayer() override { return this; };
+
+  Cacheable::CacheType NeedCaching(PrerollContext* context,
+                                   const SkMatrix& ctm) override;
+
  private:
   sk_sp<SkShader> shader_;
   SkRect mask_rect_;

flow/layers/shader_mask_layer_unittests.cc

@@ -5,6 +5,7 @@
 #include "flutter/flow/layers/shader_mask_layer.h"
 
 #include "flutter/flow/layers/opacity_layer.h"
+#include "flutter/flow/layers/layer_tree.h"
 #include "flutter/flow/testing/layer_test.h"
 #include "flutter/flow/testing/mock_layer.h"
 #include "flutter/fml/macros.h"
@@ -305,16 +306,20 @@ TEST_F(ShaderMaskLayerTest, LayerCached) {
                                     RasterCacheLayerStrategy::kLayer));
 
   layer->Preroll(preroll_context(), initial_transform);
+  LayerTree::TryToRasterCache(preroll_context());
+
   EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
   EXPECT_FALSE(raster_cache()->Draw(layer.get(), cache_canvas,
                                     RasterCacheLayerStrategy::kLayer));
 
   layer->Preroll(preroll_context(), initial_transform);
+  LayerTree::TryToRasterCache(preroll_context());
   EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)0);
   EXPECT_FALSE(raster_cache()->Draw(layer.get(), cache_canvas,
                                     RasterCacheLayerStrategy::kLayer));
 
   layer->Preroll(preroll_context(), initial_transform);
+  LayerTree::TryToRasterCache(preroll_context());
   EXPECT_EQ(raster_cache()->GetLayerCachedEntriesCount(), (size_t)1);
   EXPECT_TRUE(raster_cache()->Draw(layer.get(), cache_canvas,
                                    RasterCacheLayerStrategy::kLayer));

flow/raster_cache.cc

@@ -347,7 +347,13 @@ bool RasterCache::ShouldBeCached(PrerollContext* context,
                                  DisplayList* display_list,
                                  bool is_complex,
                                  bool will_change,
-                                 const SkMatrix& transformation_matrix) {
+                                 const SkMatrix& matrix) {
+  auto transformation_matrix = matrix;
+
+  if (!transformation_matrix.invert(nullptr)) {
+    // The matrix was singular. No point in going further.
+    return false;
+  }
   if (!GenerateNewCacheInThisFrame()) {
     return false;
   }