hold DisplayList objects in SkiaGPUObject wrappers

flow/layers/display_list_layer.cc

@@ -9,11 +9,11 @@
 namespace flutter {
 
 DisplayListLayer::DisplayListLayer(const SkPoint& offset,
-                                   sk_sp<DisplayList> display_list,
+                                   SkiaGPUObject<DisplayList> display_list,
                                    bool is_complex,
                                    bool will_change)
     : offset_(offset),
-      display_list_(display_list),
+      display_list_(std::move(display_list)),
       is_complex_(is_complex),
       will_change_(will_change) {}
 
@@ -42,15 +42,15 @@ void DisplayListLayer::Diff(DiffContext* context, const Layer* old_layer) {
 #endif
   }
   context->PushTransform(SkMatrix::Translate(offset_.x(), offset_.y()));
-  context->AddLayerBounds(display_list_->bounds());
+  context->AddLayerBounds(display_list()->bounds());
   context->SetLayerPaintRegion(this, context->CurrentSubtreeRegion());
 }
 
 bool DisplayListLayer::Compare(DiffContext::Statistics& statistics,
                                const DisplayListLayer* l1,
                                const DisplayListLayer* l2) {
-  const auto& dl1 = l1->display_list_;
-  const auto& dl2 = l2->display_list_;
+  const auto& dl1 = l1->display_list_.skia_object();
+  const auto& dl2 = l2->display_list_.skia_object();
   if (dl1.get() == dl2.get()) {
     statistics.AddSameInstancePicture();
     return true;
@@ -101,7 +101,7 @@ void DisplayListLayer::Preroll(PrerollContext* context,
 
 void DisplayListLayer::Paint(PaintContext& context) const {
   TRACE_EVENT0("flutter", "DisplayListLayer::Paint");
-  FML_DCHECK(display_list_.get());
+  FML_DCHECK(display_list_.skia_object());
   FML_DCHECK(needs_painting(context));
 
   SkAutoCanvasRestore save(context.leaf_nodes_canvas, true);

flow/layers/display_list_layer.h

@@ -7,6 +7,7 @@
 
 #include "flutter/flow/display_list.h"
 #include "flutter/flow/layers/layer.h"
+#include "flutter/flow/skia_gpu_object.h"
 
 namespace flutter {
 
@@ -15,11 +16,13 @@ class DisplayListLayer : public Layer {
   static constexpr size_t kMaxBytesToCompare = 10000;
 
   DisplayListLayer(const SkPoint& offset,
-                   sk_sp<DisplayList> display_list,
+                   SkiaGPUObject<DisplayList> display_list,
                    bool is_complex,
                    bool will_change);
 
-  DisplayList* display_list() const { return display_list_.get(); }
+  DisplayList* display_list() const {
+    return display_list_.skia_object().get();
+  }
 
 #ifdef FLUTTER_ENABLE_DIFF_CONTEXT
 
@@ -39,14 +42,12 @@ class DisplayListLayer : public Layer {
 
  private:
   SkPoint offset_;
-  sk_sp<DisplayList> display_list_;
+  flutter::SkiaGPUObject<DisplayList> display_list_;
   bool is_complex_ = false;
   bool will_change_ = false;
 
 #ifdef FLUTTER_ENABLE_DIFF_CONTEXT
 
-  sk_sp<SkData> SerializedPicture() const;
-  mutable sk_sp<SkData> cached_serialized_picture_;
   static bool Compare(DiffContext::Statistics& statistics,
                       const DisplayListLayer* l1,
                       const DisplayListLayer* l2);

flow/layers/display_list_layer_unittests.cc

@@ -7,6 +7,7 @@
 #include "flutter/flow/layers/display_list_layer.h"
 
 #include "flutter/flow/testing/diff_context_test.h"
+#include "flutter/flow/testing/skia_gpu_object_layer_test.h"
 #include "flutter/fml/macros.h"
 #include "flutter/testing/mock_canvas.h"
 
@@ -17,22 +18,27 @@
 namespace flutter {
 namespace testing {
 
-using DisplayListLayerTest = LayerTest;
+using DisplayListLayerTest = SkiaGPUObjectLayerTest;
 
 #ifndef NDEBUG
 TEST_F(DisplayListLayerTest, PaintBeforePrerollInvalidDisplayListDies) {
   const SkPoint layer_offset = SkPoint::Make(0.0f, 0.0f);
   auto layer = std::make_shared<DisplayListLayer>(
-      layer_offset, sk_ref_sp<DisplayList>(nullptr), false, false);
+      layer_offset, SkiaGPUObject<DisplayList>(), false, false);
 
   EXPECT_DEATH_IF_SUPPORTED(layer->Paint(paint_context()),
-                            "display_list_\\.get\\(\\)");
+                            "display_list_\\.skia_object\\(\\)");
 }
 
 TEST_F(DisplayListLayerTest, PaintBeforePrerollDies) {
   const SkPoint layer_offset = SkPoint::Make(0.0f, 0.0f);
+  const SkRect picture_bounds = SkRect::MakeLTRB(5.0f, 6.0f, 20.5f, 21.5f);
+  DisplayListBuilder builder;
+  builder.drawRect(picture_bounds);
+  auto display_list = builder.Build();
   auto layer = std::make_shared<DisplayListLayer>(
-      layer_offset, sk_make_sp<DisplayList>(), false, false);
+      layer_offset, SkiaGPUObject<DisplayList>(display_list, unref_queue()),
+      false, false);
 
   EXPECT_EQ(layer->paint_bounds(), SkRect::MakeEmpty());
   EXPECT_DEATH_IF_SUPPORTED(layer->Paint(paint_context()),
@@ -41,8 +47,13 @@ TEST_F(DisplayListLayerTest, PaintBeforePrerollDies) {
 
 TEST_F(DisplayListLayerTest, PaintingEmptyLayerDies) {
   const SkPoint layer_offset = SkPoint::Make(0.0f, 0.0f);
+  const SkRect picture_bounds = SkRect::MakeEmpty();
+  DisplayListBuilder builder;
+  builder.drawRect(picture_bounds);
+  auto display_list = builder.Build();
   auto layer = std::make_shared<DisplayListLayer>(
-      layer_offset, sk_make_sp<DisplayList>(), false, false);
+      layer_offset, SkiaGPUObject<DisplayList>(display_list, unref_queue()),
+      false, false);
 
   layer->Preroll(preroll_context(), SkMatrix());
   EXPECT_EQ(layer->paint_bounds(), SkRect::MakeEmpty());
@@ -55,7 +66,7 @@ TEST_F(DisplayListLayerTest, PaintingEmptyLayerDies) {
 TEST_F(DisplayListLayerTest, InvalidDisplayListDies) {
   const SkPoint layer_offset = SkPoint::Make(0.0f, 0.0f);
   auto layer = std::make_shared<DisplayListLayer>(
-      layer_offset, sk_ref_sp<DisplayList>(nullptr), false, false);
+      layer_offset, SkiaGPUObject<DisplayList>(), false, false);
 
   // Crashes reading a nullptr.
   EXPECT_DEATH_IF_SUPPORTED(layer->Preroll(preroll_context(), SkMatrix()), "");
@@ -70,8 +81,8 @@ TEST_F(DisplayListLayerTest, SimpleDisplayList) {
   DisplayListBuilder builder;
   builder.drawRect(picture_bounds);
   auto display_list = builder.Build();
-  auto layer = std::make_shared<DisplayListLayer>(layer_offset, display_list,
-                                                  false, false);
+  auto layer = std::make_shared<DisplayListLayer>(
+      layer_offset, SkiaGPUObject(display_list, unref_queue()), false, false);
 
   layer->Preroll(preroll_context(), SkMatrix());
   EXPECT_EQ(layer->paint_bounds(),

flow/testing/diff_context_test.cc

@@ -53,7 +53,8 @@ sk_sp<DisplayList> DiffContextTest::CreateDisplayList(const SkRect& bounds,
 std::shared_ptr<DisplayListLayer> DiffContextTest::CreateDisplayListLayer(
     sk_sp<DisplayList> display_list,
     const SkPoint& offset) {
-  return std::make_shared<DisplayListLayer>(offset, display_list, false, false);
+  return std::make_shared<DisplayListLayer>(
+      offset, SkiaGPUObject(display_list, unref_queue()), false, false);
 }
 
 std::shared_ptr<ContainerLayer> DiffContextTest::CreateContainerLayer(

lib/ui/compositing/scene_builder.cc

@@ -273,7 +273,8 @@ void SceneBuilder::addPicture(double dx,
     AddLayer(std::move(layer));
   } else {
     auto layer = std::make_unique<flutter::DisplayListLayer>(
-        SkPoint::Make(dx, dy), picture->display_list(), !!(hints & 1),
+        SkPoint::Make(dx, dy),
+        UIDartState::CreateGPUObject(picture->display_list()), !!(hints & 1),
         !!(hints & 2));
     AddLayer(std::move(layer));
   }

lib/ui/painting/picture.cc

@@ -37,8 +37,9 @@ fml::RefPtr<Picture> Picture::Create(
   return canvas_picture;
 }
 
-fml::RefPtr<Picture> Picture::Create(Dart_Handle dart_handle,
-                                     sk_sp<DisplayList> display_list) {
+fml::RefPtr<Picture> Picture::Create(
+    Dart_Handle dart_handle,
+    flutter::SkiaGPUObject<DisplayList> display_list) {
   auto canvas_picture = fml::MakeRefCounted<Picture>(std::move(display_list));
 
   canvas_picture->AssociateWithDartWrapper(dart_handle);
@@ -48,17 +49,17 @@ fml::RefPtr<Picture> Picture::Create(Dart_Handle dart_handle,
 Picture::Picture(flutter::SkiaGPUObject<SkPicture> picture)
     : picture_(std::move(picture)) {}
 
-Picture::Picture(sk_sp<DisplayList> display_list)
+Picture::Picture(flutter::SkiaGPUObject<DisplayList> display_list)
     : display_list_(std::move(display_list)) {}
 
 Picture::~Picture() = default;
 
 Dart_Handle Picture::toImage(uint32_t width,
                              uint32_t height,
                              Dart_Handle raw_image_callback) {
-  if (display_list_) {
+  if (display_list_.skia_object()) {
     return RasterizeToImage(
-        [display_list = display_list_](SkCanvas* canvas) {
+        [display_list = display_list_.skia_object()](SkCanvas* canvas) {
           display_list->RenderTo(canvas);
         },
         width, height, raw_image_callback);
@@ -80,8 +81,8 @@ void Picture::dispose() {
 size_t Picture::GetAllocationSize() const {
   if (auto picture = picture_.skia_object()) {
     return picture->approximateBytesUsed() + sizeof(Picture);
-  } else if (display_list_) {
-    return display_list_->bytes() + sizeof(Picture);
+  } else if (auto display_list = display_list_.skia_object()) {
+    return display_list->bytes() + sizeof(Picture);
   } else {
     return sizeof(Picture);
   }

lib/ui/painting/picture.h

@@ -27,11 +27,14 @@ class Picture : public RefCountedDartWrappable<Picture> {
   ~Picture() override;
   static fml::RefPtr<Picture> Create(Dart_Handle dart_handle,
                                      flutter::SkiaGPUObject<SkPicture> picture);
-  static fml::RefPtr<Picture> Create(Dart_Handle dart_handle,
-                                     sk_sp<DisplayList> display_list);
+  static fml::RefPtr<Picture> Create(
+      Dart_Handle dart_handle,
+      flutter::SkiaGPUObject<DisplayList> display_list);
 
   sk_sp<SkPicture> picture() const { return picture_.skia_object(); }
-  sk_sp<DisplayList> display_list() const { return display_list_; }
+  sk_sp<DisplayList> display_list() const {
+    return display_list_.skia_object();
+  }
 
   Dart_Handle toImage(uint32_t width,
                       uint32_t height,
@@ -56,10 +59,10 @@ class Picture : public RefCountedDartWrappable<Picture> {
 
  private:
   Picture(flutter::SkiaGPUObject<SkPicture> picture);
-  Picture(sk_sp<DisplayList> display_list);
+  Picture(flutter::SkiaGPUObject<DisplayList> display_list);
 
   flutter::SkiaGPUObject<SkPicture> picture_;
-  sk_sp<DisplayList> display_list_;
+  flutter::SkiaGPUObject<DisplayList> display_list_;
 };
 
 }  // namespace flutter

lib/ui/painting/picture_recorder.cc

@@ -56,7 +56,9 @@ fml::RefPtr<Picture> PictureRecorder::endRecording(Dart_Handle dart_picture) {
   fml::RefPtr<Picture> picture;
 
   if (display_list_recorder_) {
-    picture = Picture::Create(dart_picture, display_list_recorder_->Build());
+    picture = Picture::Create(
+        dart_picture,
+        UIDartState::CreateGPUObject(display_list_recorder_->Build()));
     display_list_recorder_ = nullptr;
   } else {
     picture = Picture::Create(