Made Picture::toImage happen on the IO thread with no need for an onscreen surface. (flutter#9813)

Made Picture::toImage happen on the IO thread with no need for a surface.

Author: gaaclarke

ci/licenses_golden/licenses_flutter

@@ -403,7 +403,6 @@ FILE: ../../../flutter/lib/ui/semantics/semantics_update.cc
 FILE: ../../../flutter/lib/ui/semantics/semantics_update.h
 FILE: ../../../flutter/lib/ui/semantics/semantics_update_builder.cc
 FILE: ../../../flutter/lib/ui/semantics/semantics_update_builder.h
-FILE: ../../../flutter/lib/ui/snapshot_delegate.h
 FILE: ../../../flutter/lib/ui/text.dart
 FILE: ../../../flutter/lib/ui/text/asset_manager_font_provider.cc
 FILE: ../../../flutter/lib/ui/text/asset_manager_font_provider.h

lib/ui/BUILD.gn

@@ -76,7 +76,6 @@ source_set("ui") {
     "semantics/semantics_update.h",
     "semantics/semantics_update_builder.cc",
     "semantics/semantics_update_builder.h",
-    "snapshot_delegate.h",
     "text/asset_manager_font_provider.cc",
     "text/asset_manager_font_provider.h",
     "text/font_collection.cc",

lib/ui/painting/picture.cc

@@ -5,9 +5,11 @@
 #include "flutter/lib/ui/painting/picture.h"
 
 #include "flutter/fml/make_copyable.h"
+#include "flutter/fml/trace_event.h"
 #include "flutter/lib/ui/painting/canvas.h"
 #include "flutter/lib/ui/ui_dart_state.h"
 #include "third_party/skia/include/core/SkImage.h"
+#include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/tonic/converter/dart_converter.h"
 #include "third_party/tonic/dart_args.h"
 #include "third_party/tonic/dart_binding_macros.h"
@@ -16,6 +18,64 @@
 #include "third_party/tonic/logging/dart_invoke.h"
 
 namespace flutter {
+namespace {
+
+sk_sp<SkSurface> MakeSnapshotSurface(const SkISize& picture_size,
+                                     fml::WeakPtr<GrContext> resource_context) {
+  SkImageInfo image_info = SkImageInfo::MakeN32Premul(
+      picture_size.width(), picture_size.height(), SkColorSpace::MakeSRGB());
+  if (resource_context) {
+    return SkSurface::MakeRenderTarget(resource_context.get(),  // context
+                                       SkBudgeted::kNo,         // budgeted
+                                       image_info               // image info
+    );
+  } else {
+    return SkSurface::MakeRaster(image_info);
+  }
+}
+
+/// Makes a RAM backed (Raster) image of a picture.
+/// @param[in] picture The picture that will get converted to an image.
+/// @param[in] surface The surface tha will be used to render the picture.  This
+///                    will be CPU or GPU based.
+/// @todo Currently this creates a RAM backed image regardless of what type of
+///       surface is used.  In certain instances we may want a GPU backed image
+///       from a GPU surface to avoid the conversion.
+sk_sp<SkImage> MakeRasterSnapshot(sk_sp<SkPicture> picture,
+                                  sk_sp<SkSurface> surface) {
+  TRACE_EVENT0("flutter", __FUNCTION__);
+
+  if (surface == nullptr || surface->getCanvas() == nullptr) {
+    return nullptr;
+  }
+
+  surface->getCanvas()->drawPicture(picture.get());
+
+  surface->getCanvas()->flush();
+
+  // Here device could mean GPU or CPU (depending on the supplied surface) and
+  // host means CPU; this is different from use cases like Flutter driver tests
+  // where device means mobile devices and host means laptops/desktops.
+  sk_sp<SkImage> device_snapshot;
+  {
+    TRACE_EVENT0("flutter", "MakeDeviceSnpashot");
+    device_snapshot = surface->makeImageSnapshot();
+  }
+
+  if (device_snapshot == nullptr) {
+    return nullptr;
+  }
+
+  {
+    TRACE_EVENT0("flutter", "DeviceHostTransfer");
+    if (auto raster_image = device_snapshot->makeRasterImage()) {
+      return raster_image;
+    }
+  }
+
+  return nullptr;
+}
+}  // namespace
 
 IMPLEMENT_WRAPPERTYPEINFO(ui, Picture);
 
@@ -75,8 +135,8 @@ Dart_Handle Picture::RasterizeToImage(sk_sp<SkPicture> picture,
       new tonic::DartPersistentValue(dart_state, raw_image_callback);
   auto unref_queue = dart_state->GetSkiaUnrefQueue();
   auto ui_task_runner = dart_state->GetTaskRunners().GetUITaskRunner();
-  auto gpu_task_runner = dart_state->GetTaskRunners().GetGPUTaskRunner();
-  auto snapshot_delegate = dart_state->GetSnapshotDelegate();
+  auto io_task_runner = dart_state->GetTaskRunners().GetIOTaskRunner();
+  fml::WeakPtr<GrContext> resource_context = dart_state->GetResourceContext();
 
   // We can't create an image on this task runner because we don't have a
   // graphics context. Even if we did, it would be slow anyway. Also, this
@@ -111,17 +171,16 @@ Dart_Handle Picture::RasterizeToImage(sk_sp<SkPicture> picture,
     delete image_callback;
   });
 
-  // Kick things off on the GPU.
-  fml::TaskRunner::RunNowOrPostTask(
-      gpu_task_runner,
-      [ui_task_runner, snapshot_delegate, picture, picture_bounds, ui_task] {
-        sk_sp<SkImage> raster_image =
-            snapshot_delegate->MakeRasterSnapshot(picture, picture_bounds);
-
-        fml::TaskRunner::RunNowOrPostTask(
-            ui_task_runner,
-            [ui_task, raster_image]() { ui_task(raster_image); });
-      });
+  fml::TaskRunner::RunNowOrPostTask(io_task_runner, [ui_task_runner, picture,
+                                                     picture_bounds, ui_task,
+                                                     resource_context] {
+    sk_sp<SkSurface> surface =
+        MakeSnapshotSurface(picture_bounds, resource_context);
+    sk_sp<SkImage> raster_image = MakeRasterSnapshot(picture, surface);
+
+    fml::TaskRunner::RunNowOrPostTask(
+        ui_task_runner, [ui_task, raster_image]() { ui_task(raster_image); });
+  });
 
   return Dart_Null();
 }

lib/ui/snapshot_delegate.h

@@ -17,7 +17,6 @@ UIDartState::UIDartState(
     TaskRunners task_runners,
     TaskObserverAdd add_callback,
     TaskObserverRemove remove_callback,
-    fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
     fml::WeakPtr<IOManager> io_manager,
     fml::WeakPtr<ImageDecoder> image_decoder,
     std::string advisory_script_uri,
@@ -28,7 +27,6 @@ UIDartState::UIDartState(
     : task_runners_(std::move(task_runners)),
       add_callback_(std::move(add_callback)),
       remove_callback_(std::move(remove_callback)),
-      snapshot_delegate_(std::move(snapshot_delegate)),
       io_manager_(std::move(io_manager)),
       image_decoder_(std::move(image_decoder)),
       advisory_script_uri_(std::move(advisory_script_uri)),
@@ -115,10 +113,6 @@ void UIDartState::AddOrRemoveTaskObserver(bool add) {
   }
 }
 
-fml::WeakPtr<SnapshotDelegate> UIDartState::GetSnapshotDelegate() const {
-  return snapshot_delegate_;
-}
-
 fml::WeakPtr<GrContext> UIDartState::GetResourceContext() const {
   if (!io_manager_) {
     return {};

lib/ui/ui_dart_state.cc

@@ -17,7 +17,6 @@
 #include "flutter/lib/ui/io_manager.h"
 #include "flutter/lib/ui/isolate_name_server/isolate_name_server.h"
 #include "flutter/lib/ui/painting/image_decoder.h"
-#include "flutter/lib/ui/snapshot_delegate.h"
 #include "third_party/dart/runtime/include/dart_api.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/tonic/dart_microtask_queue.h"
@@ -50,8 +49,6 @@ class UIDartState : public tonic::DartState {
 
   fml::RefPtr<flutter::SkiaUnrefQueue> GetSkiaUnrefQueue() const;
 
-  fml::WeakPtr<SnapshotDelegate> GetSnapshotDelegate() const;
-
   fml::WeakPtr<GrContext> GetResourceContext() const;
 
   fml::WeakPtr<ImageDecoder> GetImageDecoder() const;
@@ -78,7 +75,6 @@ class UIDartState : public tonic::DartState {
   UIDartState(TaskRunners task_runners,
               TaskObserverAdd add_callback,
               TaskObserverRemove remove_callback,
-              fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
               fml::WeakPtr<IOManager> io_manager,
               fml::WeakPtr<ImageDecoder> image_decoder,
               std::string advisory_script_uri,
@@ -101,7 +97,6 @@ class UIDartState : public tonic::DartState {
   const TaskRunners task_runners_;
   const TaskObserverAdd add_callback_;
   const TaskObserverRemove remove_callback_;
-  fml::WeakPtr<SnapshotDelegate> snapshot_delegate_;
   fml::WeakPtr<IOManager> io_manager_;
   fml::WeakPtr<ImageDecoder> image_decoder_;
   const std::string advisory_script_uri_;

lib/ui/ui_dart_state.h

@@ -35,7 +35,6 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRootIsolate(
     fml::RefPtr<const DartSnapshot> shared_snapshot,
     TaskRunners task_runners,
     std::unique_ptr<Window> window,
-    fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
     fml::WeakPtr<IOManager> io_manager,
     fml::WeakPtr<ImageDecoder> image_decoder,
     std::string advisory_script_uri,
@@ -57,18 +56,17 @@ std::weak_ptr<DartIsolate> DartIsolate::CreateRootIsolate(
   // being prepared to run.
   auto root_embedder_data = std::make_unique<std::shared_ptr<DartIsolate>>(
       std::make_shared<DartIsolate>(
-          settings,                      // settings
-          std::move(isolate_snapshot),   // isolate snapshot
-          std::move(shared_snapshot),    // shared snapshot
-          task_runners,                  // task runners
-          std::move(snapshot_delegate),  // snapshot delegate
-          std::move(io_manager),         // IO manager
-          std::move(image_decoder),      // Image Decoder
-          advisory_script_uri,           // advisory URI
-          advisory_script_entrypoint,    // advisory entrypoint
-          nullptr,                       // child isolate preparer
-          isolate_create_callback,       // isolate create callback
-          isolate_shutdown_callback      // isolate shutdown callback
+          settings,                     // settings
+          std::move(isolate_snapshot),  // isolate snapshot
+          std::move(shared_snapshot),   // shared snapshot
+          task_runners,                 // task runners
+          std::move(io_manager),        // IO manager
+          std::move(image_decoder),     // Image Decoder
+          advisory_script_uri,          // advisory URI
+          advisory_script_entrypoint,   // advisory entrypoint
+          nullptr,                      // child isolate preparer
+          isolate_create_callback,      // isolate create callback
+          isolate_shutdown_callback     // isolate shutdown callback
           ));
 
   std::tie(vm_isolate, embedder_isolate) = CreateDartVMAndEmbedderObjectPair(
@@ -106,7 +104,6 @@ DartIsolate::DartIsolate(const Settings& settings,
                          fml::RefPtr<const DartSnapshot> isolate_snapshot,
                          fml::RefPtr<const DartSnapshot> shared_snapshot,
                          TaskRunners task_runners,
-                         fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
                          fml::WeakPtr<IOManager> io_manager,
                          fml::WeakPtr<ImageDecoder> image_decoder,
                          std::string advisory_script_uri,
@@ -117,7 +114,6 @@ DartIsolate::DartIsolate(const Settings& settings,
     : UIDartState(std::move(task_runners),
                   settings.task_observer_add,
                   settings.task_observer_remove,
-                  std::move(snapshot_delegate),
                   std::move(io_manager),
                   std::move(image_decoder),
                   advisory_script_uri,
@@ -599,7 +595,6 @@ Dart_Isolate DartIsolate::DartCreateAndStartServiceIsolate(
           vm_data->GetSharedSnapshot(),   // shared snapshot
           null_task_runners,              // task runners
           nullptr,                        // window
-          {},                             // snapshot delegate
           {},                             // IO Manager
           {},                             // Image Decoder
           DART_VM_SERVICE_ISOLATE_NAME,   // script uri
@@ -712,7 +707,6 @@ DartIsolate::CreateDartVMAndEmbedderObjectPair(
             (*raw_embedder_isolate)->GetIsolateSnapshot(),  // isolate_snapshot
             (*raw_embedder_isolate)->GetSharedSnapshot(),   // shared_snapshot
             null_task_runners,                              // task_runners
-            fml::WeakPtr<SnapshotDelegate>{},               // snapshot_delegate
             fml::WeakPtr<IOManager>{},                      // io_manager
             fml::WeakPtr<ImageDecoder>{},                   // io_manager
             advisory_script_uri,         // advisory_script_uri

runtime/dart_isolate.cc

@@ -14,7 +14,6 @@
 #include "flutter/fml/macros.h"
 #include "flutter/fml/mapping.h"
 #include "flutter/lib/ui/io_manager.h"
-#include "flutter/lib/ui/snapshot_delegate.h"
 #include "flutter/lib/ui/ui_dart_state.h"
 #include "flutter/lib/ui/window/window.h"
 #include "flutter/runtime/dart_snapshot.h"
@@ -47,7 +46,6 @@ class DartIsolate : public UIDartState {
       fml::RefPtr<const DartSnapshot> shared_snapshot,
       TaskRunners task_runners,
       std::unique_ptr<Window> window,
-      fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
       fml::WeakPtr<IOManager> io_manager,
       fml::WeakPtr<ImageDecoder> image_decoder,
       std::string advisory_script_uri,
@@ -60,7 +58,6 @@ class DartIsolate : public UIDartState {
               fml::RefPtr<const DartSnapshot> isolate_snapshot,
               fml::RefPtr<const DartSnapshot> shared_snapshot,
               TaskRunners task_runners,
-              fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
               fml::WeakPtr<IOManager> io_manager,
               fml::WeakPtr<ImageDecoder> image_decoder,
               std::string advisory_script_uri,

runtime/dart_isolate.h

@@ -41,7 +41,6 @@ TEST_F(DartIsolateTest, RootIsolateCreationAndShutdown) {
       vm_data->GetSharedSnapshot(),       // shared snapshot
       std::move(task_runners),            // task runners
       nullptr,                            // window
-      {},                                 // snapshot delegate
       {},                                 // io manager
       {},                                 // image decoder
       "main.dart",                        // advisory uri
@@ -75,7 +74,6 @@ TEST_F(DartIsolateTest, IsolateShutdownCallbackIsInIsolateScope) {
       vm_data->GetSharedSnapshot(),       // shared snapshot
       std::move(task_runners),            // task runners
       nullptr,                            // window
-      {},                                 // snapshot delegate
       {},                                 // io manager
       {},                                 // image decoder
       "main.dart",                        // advisory uri
@@ -186,7 +184,6 @@ static void RunDartCodeInIsolate(DartVMRef& vm_ref,
       vm_data->GetSharedSnapshot(),       // shared snapshot
       std::move(task_runners),            // task runners
       nullptr,                            // window
-      {},                                 // snapshot delegate
       {},                                 // io manager
       {},                                 // image decoder
       "main.dart",                        // advisory uri

runtime/dart_isolate_unittests.cc

@@ -56,7 +56,6 @@ static std::shared_ptr<DartIsolate> CreateAndRunRootIsolate(
       vm.GetSharedSnapshot(),             // shared_snapshot
       runners,                            // task_runners
       {},                                 // window
-      {},                                 // snapshot_delegate
       {},                                 // io_manager
       {},                                 // image_decoder
       "main.dart",                        // advisory_script_uri

runtime/dart_lifecycle_unittests.cc

@@ -20,7 +20,6 @@ RuntimeController::RuntimeController(
     fml::RefPtr<const DartSnapshot> p_isolate_snapshot,
     fml::RefPtr<const DartSnapshot> p_shared_snapshot,
     TaskRunners p_task_runners,
-    fml::WeakPtr<SnapshotDelegate> p_snapshot_delegate,
     fml::WeakPtr<IOManager> p_io_manager,
     fml::WeakPtr<ImageDecoder> p_image_decoder,
     std::string p_advisory_script_uri,
@@ -33,7 +32,6 @@ RuntimeController::RuntimeController(
                         std::move(p_isolate_snapshot),
                         std::move(p_shared_snapshot),
                         std::move(p_task_runners),
-                        std::move(p_snapshot_delegate),
                         std::move(p_io_manager),
                         std::move(p_image_decoder),
                         std::move(p_advisory_script_uri),
@@ -49,7 +47,6 @@ RuntimeController::RuntimeController(
     fml::RefPtr<const DartSnapshot> p_isolate_snapshot,
     fml::RefPtr<const DartSnapshot> p_shared_snapshot,
     TaskRunners p_task_runners,
-    fml::WeakPtr<SnapshotDelegate> p_snapshot_delegate,
     fml::WeakPtr<IOManager> p_io_manager,
     fml::WeakPtr<ImageDecoder> p_image_decoder,
     std::string p_advisory_script_uri,
@@ -63,7 +60,6 @@ RuntimeController::RuntimeController(
       isolate_snapshot_(std::move(p_isolate_snapshot)),
       shared_snapshot_(std::move(p_shared_snapshot)),
       task_runners_(p_task_runners),
-      snapshot_delegate_(p_snapshot_delegate),
       io_manager_(p_io_manager),
       image_decoder_(p_image_decoder),
       advisory_script_uri_(p_advisory_script_uri),
@@ -81,7 +77,6 @@ RuntimeController::RuntimeController(
                                      shared_snapshot_,                 //
                                      task_runners_,                    //
                                      std::make_unique<Window>(this),   //
-                                     snapshot_delegate_,               //
                                      io_manager_,                      //
                                      image_decoder_,                   //
                                      p_advisory_script_uri,            //
@@ -142,7 +137,6 @@ std::unique_ptr<RuntimeController> RuntimeController::Clone() const {
       isolate_snapshot_,            //
       shared_snapshot_,             //
       task_runners_,                //
-      snapshot_delegate_,           //
       io_manager_,                  //
       image_decoder_,               //
       advisory_script_uri_,         //