Raster cache should preserve RTree for overlay layers

Author: knopp

flow/layers/display_list_raster_cache_item.cc

@@ -133,7 +133,8 @@ bool DisplayListRasterCacheItem::Draw(const PaintContext& context,
     return false;
   }
   if (cache_state_ == CacheState::kCurrent) {
-    return context.raster_cache->Draw(key_id_, *canvas, paint);
+    return context.raster_cache->Draw(key_id_, *canvas, paint,
+                                      context.is_root_canvas);
   }
   return false;
 }

flow/layers/layer.h

@@ -106,6 +106,11 @@ struct PaintContext {
   LayerStateStack& state_stack;
   DlCanvas* canvas;
 
+  // Whether current canvas is root canvas. Used to determine if the raster
+  // cache is painting to bottom-most surface, in which case it will not attempt
+  // to preserve the RTree.
+  bool is_root_canvas = true;
+
   GrDirectContext* gr_context;
   SkColorSpace* dst_color_space;
   ExternalViewEmbedder* view_embedder;

flow/layers/layer_raster_cache_item.cc

@@ -183,11 +183,12 @@ bool LayerRasterCacheItem::Draw(const PaintContext& context,
     case RasterCacheItem::kNone:
       return false;
     case RasterCacheItem::kCurrent: {
-      return context.raster_cache->Draw(key_id_, *canvas, paint);
+      return context.raster_cache->Draw(key_id_, *canvas, paint,
+                                        context.is_root_canvas);
     }
     case RasterCacheItem::kChildren: {
       return context.raster_cache->Draw(layer_children_id_.value(), *canvas,
-                                        paint);
+                                        paint, context.is_root_canvas);
     }
   }
 }

flow/layers/platform_view_layer.cc

@@ -44,6 +44,7 @@ void PlatformViewLayer::Paint(PaintContext& context) const {
   DlCanvas* canvas = context.view_embedder->CompositeEmbeddedView(view_id_);
   context.canvas = canvas;
   context.state_stack.set_delegate(canvas);
+  context.is_root_canvas = false;
 }
 
 }  // namespace flutter

flow/raster_cache.cc

@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "flutter/common/constants.h"
+#include "flutter/display_list/skia/dl_sk_dispatcher.h"
 #include "flutter/flow/layers/container_layer.h"
 #include "flutter/flow/layers/layer.h"
 #include "flutter/flow/paint_utils.h"
@@ -26,10 +27,16 @@ namespace flutter {
 
 RasterCacheResult::RasterCacheResult(sk_sp<DlImage> image,
                                      const SkRect& logical_rect,
-                                     const char* type)
-    : image_(std::move(image)), logical_rect_(logical_rect), flow_(type) {}
-
-void RasterCacheResult::draw(DlCanvas& canvas, const DlPaint* paint) const {
+                                     const char* type,
+                                     sk_sp<const DlRTree> rtree)
+    : image_(std::move(image)),
+      logical_rect_(logical_rect),
+      flow_(type),
+      rtree_(std::move(rtree)) {}
+
+void RasterCacheResult::draw(DlCanvas& canvas,
+                             const DlPaint* paint,
+                             bool is_root_canvas) const {
   DlAutoCanvasRestore auto_restore(&canvas, true);
 
   auto matrix = RasterCacheUtil::GetIntegralTransCTM(canvas.GetTransform());
@@ -39,8 +46,21 @@ void RasterCacheResult::draw(DlCanvas& canvas, const DlPaint* paint) const {
              std::abs(bounds.height() - image_->dimensions().height()) <= 1);
   canvas.TransformReset();
   flow_.Step();
-  canvas.DrawImage(image_, {bounds.fLeft, bounds.fTop},
-                   DlImageSampling::kNearestNeighbor, paint);
+  if (is_root_canvas || !rtree_) {
+    canvas.DrawImage(image_, {bounds.fLeft, bounds.fTop},
+                     DlImageSampling::kNearestNeighbor, paint);
+  } else {
+    // On some platforms RTree from overlay layers is used for unobstructed
+    // platform views and hit testing. To preserve the RTree raster cache must
+    // paint individual rects instead of the whole image.
+    auto rects = rtree_->searchAndConsolidateRects(kGiantRect);
+    for (auto rect : rects) {
+      SkRect dst(rect);
+      dst.offset(bounds.fLeft, bounds.fTop);
+      canvas.DrawImageRect(image_, rect, dst, DlImageSampling::kNearestNeighbor,
+                           paint);
+    }
+  }
 }
 
 RasterCache::RasterCache(size_t access_threshold,
@@ -73,8 +93,12 @@ std::unique_ptr<RasterCacheResult> RasterCache::Rasterize(
     return nullptr;
   }
 
-  DlSkCanvasAdapter canvas(surface->getCanvas());
-  canvas.Clear(DlColor::kTransparent());
+  // Clear the surface canvas directly to avoid RTree storing a giant clear
+  // rect.
+  auto surfaceCanvas = surface->getCanvas();
+  surfaceCanvas->clear(SK_ColorTRANSPARENT);
+
+  DisplayListBuilder canvas(true);
   canvas.Translate(-dest_rect.left(), -dest_rect.top());
   canvas.Transform(matrix);
   draw_function(&canvas);
@@ -83,9 +107,13 @@ std::unique_ptr<RasterCacheResult> RasterCache::Rasterize(
     draw_checkerboard(&canvas, context.logical_rect);
   }
 
+  auto display_list = canvas.Build();
+  DlSkCanvasDispatcher dispatcher(surfaceCanvas);
+  display_list->Dispatch(dispatcher);
+  auto rtree = display_list->rtree();
   auto image = DlImage::Make(surface->makeImageSnapshot());
   return std::make_unique<RasterCacheResult>(image, context.logical_rect,
-                                             context.flow_type);
+                                             context.flow_type, rtree);
 }
 
 bool RasterCache::UpdateCacheEntry(
@@ -146,7 +174,8 @@ bool RasterCache::HasEntry(const RasterCacheKeyID& id,
 
 bool RasterCache::Draw(const RasterCacheKeyID& id,
                        DlCanvas& canvas,
-                       const DlPaint* paint) const {
+                       const DlPaint* paint,
+                       bool is_root_canvas) const {
   auto it = cache_.find(RasterCacheKey(id, canvas.GetTransform()));
   if (it == cache_.end()) {
     return false;
@@ -155,7 +184,7 @@ bool RasterCache::Draw(const RasterCacheKeyID& id,
   Entry& entry = it->second;
 
   if (entry.image) {
-    entry.image->draw(canvas, paint);
+    entry.image->draw(canvas, paint, is_root_canvas);
     return true;
   }
 

flow/raster_cache.h

@@ -30,11 +30,14 @@ class RasterCacheResult {
  public:
   RasterCacheResult(sk_sp<DlImage> image,
                     const SkRect& logical_rect,
-                    const char* type);
+                    const char* type,
+                    sk_sp<const DlRTree> rtree = nullptr);
 
   virtual ~RasterCacheResult() = default;
 
-  virtual void draw(DlCanvas& canvas, const DlPaint* paint) const;
+  virtual void draw(DlCanvas& canvas,
+                    const DlPaint* paint,
+                    bool is_root_canvas) const;
 
   virtual SkISize image_dimensions() const {
     return image_ ? image_->dimensions() : SkISize::Make(0, 0);
@@ -48,6 +51,7 @@ class RasterCacheResult {
   sk_sp<DlImage> image_;
   SkRect logical_rect_;
   fml::tracing::TraceFlow flow_;
+  sk_sp<const DlRTree> rtree_;
 };
 
 class Layer;
@@ -143,9 +147,12 @@ class RasterCache {
   // if the item was disabled due to conditions discovered during |Preroll|
   // or if the attempt to populate the entry failed due to bounds overflow
   // conditions.
+  // If |is_root_canvas| is false, the raster cache will preserve the original
+  // RTree of cached content.
   bool Draw(const RasterCacheKeyID& id,
             DlCanvas& canvas,
-            const DlPaint* paint) const;
+            const DlPaint* paint,
+            bool is_root_canvas = true) const;
 
   bool HasEntry(const RasterCacheKeyID& id, const SkMatrix&) const;
 

flow/raster_cache_unittests.cc

@@ -886,6 +886,56 @@ TEST_F(RasterCacheTest, RasterCacheKeyIDLayerChildrenIds) {
   ASSERT_EQ(ids, expected_ids);
 }
 
+TEST(RasterCache, PreservesRTree) {
+  flutter::RasterCache cache(1);
+  LayerStateStack preroll_state_stack;
+  SkMatrix matrix = SkMatrix::I();
+  preroll_state_stack.set_preroll_delegate(kGiantRect, matrix);
+
+  FixedRefreshRateStopwatch raster_time;
+  FixedRefreshRateStopwatch ui_time;
+  PaintContextHolder paint_context_holder = GetSamplePaintContextHolder(
+      preroll_state_stack, &cache, &raster_time, &ui_time);
+  auto& paint_context = paint_context_holder.paint_context;
+  RasterCache::Context r_context = {
+      // clang-format off
+      .gr_context         = paint_context.gr_context,
+      .dst_color_space    = paint_context.dst_color_space,
+      .matrix             = matrix,
+      .logical_rect       = SkRect::MakeWH(100, 100),
+      .flow_type          = "RasterCacheFlow::DisplayList",
+      // clang-format on
+  };
+
+  RasterCacheKeyID id(10, RasterCacheKeyType::kLayer);
+  cache.UpdateCacheEntry(id, r_context, [&](DlCanvas* canvas) {
+    canvas->DrawRect(SkRect::MakeXYWH(0, 0, 100, 10), DlPaint());
+    canvas->DrawRect(SkRect::MakeXYWH(0, 40, 100, 10), DlPaint());
+  });
+
+  {
+    DisplayListBuilder canvas(true);
+    cache.Draw(id, canvas, nullptr, true);
+    auto display_list = canvas.Build();
+    auto rtree = display_list->rtree();
+    auto rects = rtree->searchAndConsolidateRects(kGiantRect);
+    // For root canvas the display may clober the RTree.
+    ASSERT_EQ(rects.size(), 1u);
+    ASSERT_EQ(rects.front(), SkRect::MakeWH(100, 100));
+  }
+  {
+    DisplayListBuilder canvas(true);
+    cache.Draw(id, canvas, nullptr, false);
+    auto display_list = canvas.Build();
+    auto rtree = display_list->rtree();
+    auto rects = rtree->searchAndConsolidateRects(kGiantRect);
+    // For non-root canvas the RTree must be preserved
+    ASSERT_EQ(rects.size(), 2u);
+    ASSERT_EQ(rects.front(), SkRect::MakeXYWH(0, 0, 100, 10));
+    ASSERT_EQ(*std::next(rects.begin(), 1), SkRect::MakeXYWH(0, 40, 100, 10));
+  }
+}
+
 }  // namespace testing
 }  // namespace flutter
 

flow/testing/mock_raster_cache.h

@@ -29,7 +29,9 @@ class MockRasterCacheResult : public RasterCacheResult {
  public:
   explicit MockRasterCacheResult(SkRect device_rect);
 
-  void draw(DlCanvas& canvas, const DlPaint* paint = nullptr) const override{};
+  void draw(DlCanvas& canvas,
+            const DlPaint* paint = nullptr,
+            bool is_root_canvas = true) const override{};
 
   SkISize image_dimensions() const override {
     return SkSize::Make(device_rect_.width(), device_rect_.height()).toCeil();