Use a pbuffer on Andorid when in the background

Author: dnfield

shell/common/platform_view.cc

@@ -67,26 +67,32 @@ void PlatformView::SetViewportMetrics(const ViewportMetrics& metrics) {
 
 void PlatformView::NotifyCreated() {
   std::unique_ptr<Surface> surface;
-
+  std::unique_ptr<Surface> snapshot_surface;
   // Threading: We want to use the platform view on the non-platform thread.
   // Using the weak pointer is illegal. But, we are going to introduce a latch
   // so that the platform view is not collected till the surface is obtained.
   auto* platform_view = this;
   fml::ManualResetWaitableEvent latch;
   fml::TaskRunner::RunNowOrPostTask(
-      task_runners_.GetRasterTaskRunner(), [platform_view, &surface, &latch]() {
+      task_runners_.GetRasterTaskRunner(),
+      [platform_view, &surface, &latch, &snapshot_surface]() {
         surface = platform_view->CreateRenderingSurface();
         if (surface && !surface->IsValid()) {
           surface.reset();
         }
+        snapshot_surface = platform_view->CreateRasterSnapshotSurface();
+        if (snapshot_surface && !snapshot_surface->IsValid()) {
+          snapshot_surface.reset();
+        }
         latch.Signal();
       });
   latch.Wait();
   if (!surface) {
     FML_LOG(ERROR) << "Failed to create platform view rendering surface";
     return;
   }
-  delegate_.OnPlatformViewCreated(std::move(surface));
+  delegate_.OnPlatformViewCreated(std::move(surface),
+                                  std::move(snapshot_surface));
 }
 
 void PlatformView::NotifyDestroyed() {
@@ -182,4 +188,8 @@ void PlatformView::UpdateAssetResolverByType(
   delegate_.UpdateAssetResolverByType(std::move(updated_asset_resolver), type);
 }
 
+std::unique_ptr<Surface> PlatformView::CreateRasterSnapshotSurface() {
+  return nullptr;
+}
+
 }  // namespace flutter

shell/common/platform_view.h

@@ -62,9 +62,16 @@ class PlatformView {
     ///             Metal, Vulkan) specific. This is usually a sign to the
     ///             rasterizer to set up and begin rendering to that surface.
     ///
-    /// @param[in]  surface  The surface
+    /// @param[in]  surface           The surface
+    /// @param[in]  snapshot_surface  A surface suitable taking raster snapshots
+    ///                               if surface has been collected. This
+    ///                               parameter may be null if backgorund
+    ///                               snapshotting is not supported by the
+    ///                               platform.
     ///
-    virtual void OnPlatformViewCreated(std::unique_ptr<Surface> surface) = 0;
+    virtual void OnPlatformViewCreated(
+        std::unique_ptr<Surface> surface,
+        std::unique_ptr<Surface> snapshot_surface) = 0;
 
     //--------------------------------------------------------------------------
     /// @brief      Notifies the delegate that the platform view was destroyed.
@@ -804,7 +811,23 @@ class PlatformView {
   SkISize size_;
   fml::WeakPtrFactory<PlatformView> weak_factory_;
 
-  // Unlike all other methods on the platform view, this is called on the
+  //--------------------------------------------------------------------------
+  /// @brief      Creates a Surface suitable for raster snapshotting. The
+  ///             rasterizer will request this surface if no on screen surface
+  ///             is currently available and a snapshot has been requested
+  ///             by the framework, e.g. if `Scene.toImage` or `Picture.toImage`
+  ///             are called while the application is in the background.
+  ///
+  ///             Not all backends support this kind of surface usage, and the
+  ///             default implementation returns nullptr. Platforms should
+  ///             override this if they can support GPU operations in the
+  ///             background and support GPU resource context usage.
+  ///
+  ///             This is the only public method of this interface called on the
+  ///             raster task runner.
+  virtual std::unique_ptr<Surface> CreateRasterSnapshotSurface();
+
+  // This and CreateRasterSnapshotSurface are the only methods called on the
   // raster task runner.
   virtual std::unique_ptr<Surface> CreateRenderingSurface();
 

shell/common/rasterizer.cc

@@ -258,11 +258,19 @@ sk_sp<SkImage> Rasterizer::DoMakeRasterSnapshot(
   sk_sp<SkImage> result;
   SkImageInfo image_info = SkImageInfo::MakeN32Premul(
       size.width(), size.height(), SkColorSpace::MakeSRGB());
-  if (surface_ == nullptr || surface_->GetContext() == nullptr) {
+
+  std::shared_ptr<Surface> pbuffer_surface;
+  if (!surface_) {
+    pbuffer_surface = delegate_.GetSnapshotSurface();
+  }
+
+  if ((surface_ == nullptr || surface_->GetContext() == nullptr) &&
+      (pbuffer_surface == nullptr ||
+       pbuffer_surface->GetContext() == nullptr)) {
     // Raster surface is fine if there is no on screen surface. This might
     // happen in case of software rendering.
-    sk_sp<SkSurface> surface = SkSurface::MakeRaster(image_info);
-    result = DrawSnapshot(surface, draw_callback);
+    sk_sp<SkSurface> sk_surface = SkSurface::MakeRaster(image_info);
+    result = DrawSnapshot(sk_surface, draw_callback);
   } else {
     delegate_.GetIsGpuDisabledSyncSwitch()->Execute(
         fml::SyncSwitch::Handlers()
@@ -271,12 +279,17 @@ sk_sp<SkImage> Rasterizer::DoMakeRasterSnapshot(
               result = DrawSnapshot(surface, draw_callback);
             })
             .SetIfFalse([&] {
-              auto context_switch = surface_->MakeRenderContextCurrent();
+              Surface* surface = surface_.get();
+              if (!surface) {
+                surface = pbuffer_surface.get();
+              }
+              FML_DCHECK(surface);
+              auto context_switch = surface->MakeRenderContextCurrent();
               if (!context_switch->GetResult()) {
                 return;
               }
 
-              GrRecordingContext* context = surface_->GetContext();
+              GrRecordingContext* context = surface->GetContext();
               auto max_size = context->maxRenderTargetSize();
               double scale_factor = std::min(
                   1.0, static_cast<double>(max_size) /
@@ -294,19 +307,19 @@ sk_sp<SkImage> Rasterizer::DoMakeRasterSnapshot(
 
               // When there is an on screen surface, we need a render target
               // SkSurface because we want to access texture backed images.
-              sk_sp<SkSurface> surface =
+              sk_sp<SkSurface> sk_surface =
                   SkSurface::MakeRenderTarget(context,          // context
                                               SkBudgeted::kNo,  // budgeted
                                               image_info        // image info
                   );
-              if (!surface) {
+              if (!sk_surface) {
                 FML_LOG(ERROR)
                     << "DoMakeRasterSnapshot can not create GPU render target";
                 return;
               }
 
-              surface->getCanvas()->scale(scale_factor, scale_factor);
-              result = DrawSnapshot(surface, draw_callback);
+              sk_surface->getCanvas()->scale(scale_factor, scale_factor);
+              result = DrawSnapshot(sk_surface, draw_callback);
             }));
   }
 
@@ -680,6 +693,7 @@ Rasterizer::Screenshot Rasterizer::ScreenshotLastLayerTree(
     FML_LOG(ERROR) << "Screenshot data was null.";
     return {};
   }
+  FML_DLOG(ERROR) << data;
 
   if (base64_encode) {
     size_t b64_size = SkBase64::Encode(data->data(), data->size(), nullptr);

shell/common/rasterizer.h

@@ -90,6 +90,16 @@ class Rasterizer final : public SnapshotDelegate {
     /// is critical that GPU operations are not processed.
     virtual std::shared_ptr<const fml::SyncSwitch> GetIsGpuDisabledSyncSwitch()
         const = 0;
+
+    /// Called by the Rasterizer if a snapshot is requested while no surface
+    /// is currently available, for example after a platform has torn down
+    /// the surface.
+    ///
+    /// For some rendering backends or some platforms, using a GPU surface for
+    /// snapshotting while in the background may not be possible or necessary.
+    /// In that case, this method must return nullptr and the rasterizer will
+    /// attempt to use a CPU based raster surface for snapshotting.
+    virtual std::shared_ptr<Surface> GetSnapshotSurface() = 0;
   };
 
   //----------------------------------------------------------------------------

shell/common/rasterizer_unittests.cc

@@ -30,6 +30,7 @@ class MockDelegate : public Rasterizer::Delegate {
   MOCK_CONST_METHOD0(GetTaskRunners, const TaskRunners&());
   MOCK_CONST_METHOD0(GetIsGpuDisabledSyncSwitch,
                      std::shared_ptr<const fml::SyncSwitch>());
+  MOCK_METHOD0(CreateRasterSnapshotSurface, std::unique_ptr<Surface>());
 };
 
 class MockSurface : public Surface {

shell/common/shell.cc

@@ -697,11 +697,14 @@ DartVM* Shell::GetDartVM() {
 }
 
 // |PlatformView::Delegate|
-void Shell::OnPlatformViewCreated(std::unique_ptr<Surface> surface) {
+void Shell::OnPlatformViewCreated(std::unique_ptr<Surface> surface,
+                                  std::unique_ptr<Surface> snapshot_surface) {
   TRACE_EVENT0("flutter", "Shell::OnPlatformViewCreated");
   FML_DCHECK(is_setup_);
   FML_DCHECK(task_runners_.GetPlatformTaskRunner()->RunsTasksOnCurrentThread());
 
+  snapshot_surface_ = std::move(snapshot_surface);
+
   // Prevent any request to change the thread configuration for raster and
   // platform queues while the platform view is being created.
   //
@@ -1362,6 +1365,12 @@ void Shell::ReportTimings() {
   });
 }
 
+std::shared_ptr<Surface> Shell::GetSnapshotSurface() {
+  FML_DCHECK(is_setup_);
+  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
+  return snapshot_surface_;
+}
+
 size_t Shell::UnreportedFramesCount() const {
   // Check that this is running on the raster thread to avoid race conditions.
   FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());

shell/common/shell.h

@@ -435,6 +435,10 @@ class Shell final : public PlatformView::Delegate,
 
   sk_sp<GrDirectContext> shared_resource_context_;
 
+  // Created by the PlatformView on the raster task runner, used by the
+  // Rasterizer if the onscreen surface is unavailable.
+  std::shared_ptr<Surface> snapshot_surface_;
+
   Shell(DartVMRef vm,
         TaskRunners task_runners,
         Settings settings,
@@ -470,7 +474,9 @@ class Shell final : public PlatformView::Delegate,
   void ReportTimings();
 
   // |PlatformView::Delegate|
-  void OnPlatformViewCreated(std::unique_ptr<Surface> surface) override;
+  void OnPlatformViewCreated(
+      std::unique_ptr<Surface> surface,
+      std::unique_ptr<Surface> snapshot_surface) override;
 
   // |PlatformView::Delegate|
   void OnPlatformViewDestroyed() override;
@@ -590,6 +596,9 @@ class Shell final : public PlatformView::Delegate,
   // |Rasterizer::Delegate|
   fml::TimePoint GetLatestFrameTargetTime() const override;
 
+  // |Rasterizer::Delegate|
+  std::shared_ptr<Surface> GetSnapshotSurface() override;
+
   // |ServiceProtocol::Handler|
   fml::RefPtr<fml::TaskRunner> GetServiceProtocolHandlerTaskRunner(
       std::string_view method) const override;

shell/platform/android/android_context_gl.cc

@@ -227,6 +227,16 @@ std::unique_ptr<AndroidEGLSurface> AndroidContextGL::CreateOffscreenSurface()
                                              resource_context_);
 }
 
+std::unique_ptr<AndroidEGLSurface> AndroidContextGL::CreatePbufferSurface()
+    const {
+  EGLDisplay display = environment_->Display();
+
+  const EGLint attribs[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE};
+
+  EGLSurface surface = eglCreatePbufferSurface(display, config_, attribs);
+  return std::make_unique<AndroidEGLSurface>(surface, display, context_);
+}
+
 fml::RefPtr<AndroidEnvironmentGL> AndroidContextGL::Environment() const {
   return environment_;
 }

shell/platform/android/android_context_gl.h

@@ -93,6 +93,14 @@ class AndroidContextGL : public AndroidContext {
   ///
   std::unique_ptr<AndroidEGLSurface> CreateOffscreenSurface() const;
 
+  //----------------------------------------------------------------------------
+  /// @brief      Allocates an 1x1 pbuffer surface that is used for making the
+  ///             onscreen context current for snapshotting.
+  ///
+  /// @return     The pbuffer surface.
+  ///
+  std::unique_ptr<AndroidEGLSurface> CreatePbufferSurface() const;
+
   //----------------------------------------------------------------------------
   /// @return     The Android environment that contains a reference to the
   /// display.

shell/platform/android/android_surface_gl.cc

@@ -175,4 +175,16 @@ AndroidContextGL* AndroidSurfaceGL::GLContextPtr() const {
   return reinterpret_cast<AndroidContextGL*>(android_context_.get());
 }
 
+std::unique_ptr<Surface> AndroidSurfaceGL::CreatePbufferSurface() {
+  onscreen_surface_ = GLContextPtr()->CreatePbufferSurface();
+  sk_sp<GrDirectContext> main_skia_context =
+      GLContextPtr()->GetMainSkiaContext();
+  if (!main_skia_context) {
+    main_skia_context = GPUSurfaceGL::MakeGLContext(this);
+    GLContextPtr()->SetMainSkiaContext(main_skia_context);
+  }
+
+  return std::make_unique<GPUSurfaceGL>(main_skia_context, this, true);
+}
+
 }  // namespace flutter