Include TextureViews in the output of Scene.toImage[Sync]

flow/layers/layer_tree.cc

@@ -171,29 +171,33 @@ void LayerTree::Paint(CompositorContext::ScopedFrame& frame,
   }
 }
 
-sk_sp<DisplayList> LayerTree::Flatten(const SkRect& bounds) {
+sk_sp<DisplayList> LayerTree::Flatten(
+    const SkRect& bounds,
+    std::shared_ptr<TextureRegistry> texture_registry,
+    GrDirectContext* gr_context) {
   TRACE_EVENT0("flutter", "LayerTree::Flatten");
 
   DisplayListCanvasRecorder builder(bounds);
 
   MutatorsStack unused_stack;
   const FixedRefreshRateStopwatch unused_stopwatch;
   SkMatrix root_surface_transformation;
+
   // No root surface transformation. So assume identity.
   root_surface_transformation.reset();
 
   PrerollContext preroll_context{
       // clang-format off
       .raster_cache                  = nullptr,
-      .gr_context                    = nullptr,
+      .gr_context                    = gr_context,
       .view_embedder                 = nullptr,
       .mutators_stack                = unused_stack,
       .dst_color_space               = nullptr,
       .cull_rect                     = kGiantRect,
       .surface_needs_readback        = false,
       .raster_time                   = unused_stopwatch,
       .ui_time                       = unused_stopwatch,
-      .texture_registry              = nullptr,
+      .texture_registry              = texture_registry,
       .checkerboard_offscreen_layers = false,
       .frame_device_pixel_ratio      = device_pixel_ratio_
       // clang-format on
@@ -209,12 +213,12 @@ sk_sp<DisplayList> LayerTree::Flatten(const SkRect& bounds) {
       // clang-format off
       .internal_nodes_canvas         = &internal_nodes_canvas,
       .leaf_nodes_canvas             = &builder,
-      .gr_context                    = nullptr,
+      .gr_context                    = gr_context,
       .dst_color_space               = nullptr,
       .view_embedder                 = nullptr,
       .raster_time                   = unused_stopwatch,
       .ui_time                       = unused_stopwatch,
-      .texture_registry              = nullptr,
+      .texture_registry              = texture_registry,
       .raster_cache                  = nullptr,
       .checkerboard_offscreen_layers = false,
       .frame_device_pixel_ratio      = device_pixel_ratio_,

flow/layers/layer_tree.h

@@ -8,6 +8,7 @@
 #include <cstdint>
 #include <memory>
 
+#include "flutter/common/graphics/texture.h"
 #include "flutter/flow/compositor_context.h"
 #include "flutter/flow/layers/layer.h"
 #include "flutter/flow/raster_cache.h"
@@ -41,7 +42,10 @@ class LayerTree {
   void Paint(CompositorContext::ScopedFrame& frame,
              bool ignore_raster_cache = false) const;
 
-  sk_sp<DisplayList> Flatten(const SkRect& bounds);
+  sk_sp<DisplayList> Flatten(
+      const SkRect& bounds,
+      std::shared_ptr<TextureRegistry> texture_registry = nullptr,
+      GrDirectContext* gr_context = nullptr);
 
   Layer* root_layer() const { return root_layer_.get(); }
 

lib/ui/compositing.dart

@@ -38,7 +38,6 @@ class Scene extends NativeFieldWrapperClass1 {
   external String? _toImageSync(int width, int height, _Image outImage);
 
   /// Creates a raster image representation of the current state of the scene.
-  /// This is a slow operation that is performed on a background thread.
   ///
   /// Callers must dispose the [Image] when they are done with it. If the result
   /// will be shared with other methods or classes, [Image.clone] should be used
@@ -47,18 +46,16 @@ class Scene extends NativeFieldWrapperClass1 {
     if (width <= 0 || height <= 0) {
       throw Exception('Invalid image dimensions.');
     }
-    return _futurize((_Callback<Image?> callback) => _toImage(width, height, (_Image? image) {
-        if (image == null) {
-          callback(null);
-        } else {
-          callback(Image._(image, image.width, image.height));
-        }
-      }),
-    );
+    final _Image image = _Image._();
+    final String? result =  _toImage(width, height, image);
+    if (result != null) {
+      throw PictureRasterizationException._(result);
+    }
+    return Future<Image>.value(Image._(image, image.width, image.height));
   }
 
   @FfiNative<Handle Function(Pointer<Void>, Uint32, Uint32, Handle)>('Scene::toImage')
-  external String? _toImage(int width, int height, _Callback<_Image?> callback);
+  external String? _toImage(int width, int height, _Image outImage);
 
   /// Releases the resources used by this scene.
   ///

lib/ui/compositing/scene.cc

@@ -5,6 +5,7 @@
 #include "flutter/lib/ui/compositing/scene.h"
 
 #include "flutter/fml/trace_event.h"
+#include "flutter/lib/ui/painting/display_list_deferred_image_gpu.h"
 #include "flutter/lib/ui/painting/image.h"
 #include "flutter/lib/ui/painting/picture.h"
 #include "flutter/lib/ui/ui_dart_state.h"
@@ -42,7 +43,7 @@ Scene::Scene(std::shared_ptr<flutter::Layer> rootLayer,
                               ->get_window(0)
                               ->viewport_metrics();
 
-  layer_tree_ = std::make_unique<LayerTree>(
+  layer_tree_ = std::make_shared<LayerTree>(
       SkISize::Make(viewport_metrics.physical_width,
                     viewport_metrics.physical_height),
       static_cast<float>(viewport_metrics.device_pixel_ratio));
@@ -69,33 +70,46 @@ Dart_Handle Scene::toImageSync(uint32_t width,
     return tonic::ToDart("Scene did not contain a layer tree.");
   }
 
-  auto picture = layer_tree_->Flatten(SkRect::MakeWH(width, height));
-  if (!picture) {
-    return tonic::ToDart("Could not flatten scene into a layer tree.");
-  }
-
-  Picture::RasterizeToImageSync(picture, width, height, raw_image_handle);
+  Scene::RasterizeToImage(width, height, raw_image_handle);
   return Dart_Null();
 }
 
 Dart_Handle Scene::toImage(uint32_t width,
                            uint32_t height,
-                           Dart_Handle raw_image_callback) {
+                           Dart_Handle raw_image_handle) {
   TRACE_EVENT0("flutter", "Scene::toImage");
 
   if (!layer_tree_) {
     return tonic::ToDart("Scene did not contain a layer tree.");
   }
 
-  auto picture = layer_tree_->Flatten(SkRect::MakeWH(width, height));
-  if (!picture) {
-    return tonic::ToDart("Could not flatten scene into a layer tree.");
-  }
+  Scene::RasterizeToImage(width, height, raw_image_handle);
+  return Dart_Null();
+}
 
-  return Picture::RasterizeToImage(picture, width, height, raw_image_callback);
+void Scene::RasterizeToImage(uint32_t width,
+                             uint32_t height,
+                             Dart_Handle raw_image_handle) {
+  auto* dart_state = UIDartState::Current();
+  if (!dart_state) {
+    return;
+  }
+  auto unref_queue = dart_state->GetSkiaUnrefQueue();
+  auto snapshot_delegate = dart_state->GetSnapshotDelegate();
+  auto raster_task_runner = dart_state->GetTaskRunners().GetRasterTaskRunner();
+
+  auto image = CanvasImage::Create();
+  const SkImageInfo image_info = SkImageInfo::Make(
+      width, height, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
+  auto dl_image = DlDeferredImageGPU::MakeFromLayerTree(
+      image_info, std::move(layer_tree_), width, height,
+      std::move(snapshot_delegate), std::move(raster_task_runner),
+      std::move(unref_queue));
+  image->set_image(dl_image);
+  image->AssociateWithDartWrapper(raw_image_handle);
 }
 
-std::unique_ptr<flutter::LayerTree> Scene::takeLayerTree() {
+std::shared_ptr<flutter::LayerTree> Scene::takeLayerTree() {
   return std::move(layer_tree_);
 }
 

lib/ui/compositing/scene.h

@@ -26,25 +26,34 @@ class Scene : public RefCountedDartWrappable<Scene> {
                      bool checkerboardRasterCacheImages,
                      bool checkerboardOffscreenLayers);
 
-  std::unique_ptr<flutter::LayerTree> takeLayerTree();
+  std::shared_ptr<flutter::LayerTree> takeLayerTree();
 
   Dart_Handle toImageSync(uint32_t width,
                           uint32_t height,
                           Dart_Handle raw_image_handle);
 
   Dart_Handle toImage(uint32_t width,
                       uint32_t height,
-                      Dart_Handle image_callback);
+                      Dart_Handle raw_image_handle);
 
   void dispose();
 
  private:
-  explicit Scene(std::shared_ptr<flutter::Layer> rootLayer,
-                 uint32_t rasterizerTracingThreshold,
-                 bool checkerboardRasterCacheImages,
-                 bool checkerboardOffscreenLayers);
-
-  std::unique_ptr<flutter::LayerTree> layer_tree_;
+  Scene(std::shared_ptr<flutter::Layer> rootLayer,
+        uint32_t rasterizerTracingThreshold,
+        bool checkerboardRasterCacheImages,
+        bool checkerboardOffscreenLayers);
+
+  void RasterizeToImage(uint32_t width,
+                        uint32_t height,
+                        Dart_Handle raw_image_handle);
+
+  // This is a shared_ptr to support flattening the layer tree from the UI
+  // thread onto the raster thread - allowing access to the texture registry
+  // required to render TextureLayers.
+  //
+  // No longer valid after calling `takeLayerTree`.
+  std::shared_ptr<flutter::LayerTree> layer_tree_;
 };
 
 }  // namespace flutter

lib/ui/painting/display_list_deferred_image_gpu.cc

@@ -22,6 +22,22 @@ sk_sp<DlDeferredImageGPU> DlDeferredImageGPU::Make(
       raster_task_runner));
 }
 
+sk_sp<DlDeferredImageGPU> DlDeferredImageGPU::MakeFromLayerTree(
+    const SkImageInfo& image_info,
+    std::shared_ptr<LayerTree> layer_tree,
+    uint32_t width,
+    uint32_t height,
+    fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
+    fml::RefPtr<fml::TaskRunner> raster_task_runner,
+    fml::RefPtr<SkiaUnrefQueue> unref_queue) {
+  return sk_sp<DlDeferredImageGPU>(new DlDeferredImageGPU(
+      ImageWrapper::MakeFromLayerTree(image_info, std::move(layer_tree), width,
+                                      height, std::move(snapshot_delegate),
+                                      raster_task_runner,
+                                      std::move(unref_queue)),
+      raster_task_runner));
+}
+
 DlDeferredImageGPU::DlDeferredImageGPU(
     std::shared_ptr<ImageWrapper> image_wrapper,
     fml::RefPtr<fml::TaskRunner> raster_task_runner)
@@ -86,23 +102,50 @@ DlDeferredImageGPU::ImageWrapper::Make(
     fml::RefPtr<fml::TaskRunner> raster_task_runner,
     fml::RefPtr<SkiaUnrefQueue> unref_queue) {
   auto wrapper = std::shared_ptr<ImageWrapper>(new ImageWrapper(
-      image_info, std::move(display_list), std::move(snapshot_delegate),
-      std::move(raster_task_runner), std::move(unref_queue)));
+      image_info,
+      std::variant<sk_sp<DisplayList>, std::shared_ptr<LayerTree>>(
+          std::move(display_list)),
+      std::move(snapshot_delegate), std::move(raster_task_runner),
+      std::move(unref_queue), 0, 0));
+  wrapper->SnapshotDisplayList();
+  return wrapper;
+}
+
+std::shared_ptr<DlDeferredImageGPU::ImageWrapper>
+DlDeferredImageGPU::ImageWrapper::MakeFromLayerTree(
+    const SkImageInfo& image_info,
+    std::shared_ptr<LayerTree> layer_tree,
+    uint32_t width,
+    uint32_t height,
+    fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
+    fml::RefPtr<fml::TaskRunner> raster_task_runner,
+    fml::RefPtr<SkiaUnrefQueue> unref_queue) {
+  auto wrapper = std::shared_ptr<ImageWrapper>(new ImageWrapper(
+      image_info,
+      std::variant<sk_sp<DisplayList>, std::shared_ptr<LayerTree>>(
+          std::move(layer_tree)),
+      std::move(snapshot_delegate), std::move(raster_task_runner),
+      std::move(unref_queue), width, height));
   wrapper->SnapshotDisplayList();
   return wrapper;
 }
 
 DlDeferredImageGPU::ImageWrapper::ImageWrapper(
     const SkImageInfo& image_info,
-    sk_sp<DisplayList> display_list,
+    std::variant<sk_sp<DisplayList>, std::shared_ptr<LayerTree>>
+        display_list_or_layer_tree,
     fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
     fml::RefPtr<fml::TaskRunner> raster_task_runner,
-    fml::RefPtr<SkiaUnrefQueue> unref_queue)
+    fml::RefPtr<SkiaUnrefQueue> unref_queue,
+    uint32_t width,
+    uint32_t height)
     : image_info_(image_info),
-      display_list_(std::move(display_list)),
+      display_list_or_layer_tree_(std::move(display_list_or_layer_tree)),
       snapshot_delegate_(std::move(snapshot_delegate)),
       raster_task_runner_(std::move(raster_task_runner)),
-      unref_queue_(std::move(unref_queue)) {}
+      unref_queue_(std::move(unref_queue)),
+      width_(width),
+      height_(height) {}
 
 void DlDeferredImageGPU::ImageWrapper::OnGrContextCreated() {
   FML_DCHECK(raster_task_runner_->RunsTasksOnCurrentThread());
@@ -142,8 +185,20 @@ void DlDeferredImageGPU::ImageWrapper::SnapshotDisplayList() {
         if (!snapshot_delegate) {
           return;
         }
-        auto result = snapshot_delegate->MakeGpuImage(wrapper->display_list_,
-                                                      wrapper->image_info_);
+        if (std::holds_alternative<std::shared_ptr<LayerTree>>(
+                wrapper->display_list_or_layer_tree_)) {
+          auto layer_tree = std::get<std::shared_ptr<LayerTree>>(
+              wrapper->display_list_or_layer_tree_);
+          auto display_list = layer_tree->Flatten(
+              SkRect::MakeWH(wrapper->width_, wrapper->height_),
+              snapshot_delegate.get()->GetTextureRegistry(),
+              snapshot_delegate.get()->GetGrContext());
+          wrapper->display_list_or_layer_tree_.emplace<sk_sp<DisplayList>>(
+              display_list);
+        }
+        auto result = snapshot_delegate->MakeGpuImage(
+            std::get<sk_sp<DisplayList>>(wrapper->display_list_or_layer_tree_),
+            wrapper->image_info_);
         if (result->texture.isValid()) {
           wrapper->texture_ = result->texture;
           wrapper->context_ = std::move(result->context);