[Impeller] implements a retry mechanism for dart:ui/Image.toByteData.

Author: gaaclarke

impeller/renderer/backend/metal/BUILD.gn

@@ -8,6 +8,8 @@ impeller_component("metal") {
   sources = [
     "allocator_mtl.h",
     "allocator_mtl.mm",
+    "app_state_notifier.h",
+    "app_state_notifier.mm",
     "blit_command_mtl.h",
     "blit_command_mtl.mm",
     "blit_pass_mtl.h",
@@ -54,4 +56,7 @@ impeller_component("metal") {
   ]
 
   frameworks = [ "Metal.framework" ]
+  if (is_ios) {
+    frameworks += [ "UIKit.framework" ]
+  }
 }

impeller/renderer/backend/metal/app_state_notifier.h

@@ -0,0 +1,32 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#pragma once
+
+#include <functional>
+#include <memory>
+
+namespace impeller {
+
+class AppStateNotifier {
+ public:
+  struct AppStateNotifierImpl;
+
+  AppStateNotifier();
+
+  /// Callback is executed on the platform thread.
+  void SetAppDidBecomeActiveCallback(std::function<void()> callback) {
+    app_did_become_active_callback_ = callback;
+  }
+
+  void OnAppBecameActive();
+
+ private:
+  static void DeleteImpl(AppStateNotifierImpl* impl);
+  std::function<void()> app_did_become_active_callback_;
+  std::unique_ptr<AppStateNotifierImpl, decltype(&AppStateNotifier::DeleteImpl)>
+      impl_;
+};
+
+}  // namespace impeller

impeller/renderer/backend/metal/app_state_notifier.mm

@@ -0,0 +1,94 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "impeller/renderer/backend/metal/app_state_notifier.h"
+
+#import <Foundation/Foundation.h>
+
+#include "flutter/fml/logging.h"
+
+#if !__has_feature(objc_arc)
+#error ARC must be enabled !
+#endif
+
+#ifdef FML_OS_IOS
+#import <UIKit/UIKit.h>
+#endif
+
+@interface ImpellerAppStateNotifier : NSObject
+@property(nonatomic, assign) impeller::AppStateNotifier* parent;
+- (instancetype)initWithParent:(impeller::AppStateNotifier*)parent
+    NS_DESIGNATED_INITIALIZER;
+- (void)onAppBecameActive:(NSNotification*)notification;
+@end
+
+#ifdef FML_OS_IOS
+@implementation ImpellerAppStateNotifier
+- (instancetype)initWithParent:(impeller::AppStateNotifier*)parent {
+  self = [super init];
+  if (self) {
+    _parent = parent;
+    [[NSNotificationCenter defaultCenter]
+        addObserver:self
+           selector:@selector(onAppBecameActive:)
+               name:UIApplicationDidBecomeActiveNotification
+             object:nil];
+  }
+  return self;
+}
+
+- (void)dealloc {
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+}
+
+- (void)onAppBecameActive:(NSNotification*)notification {
+  _parent->OnAppBecameActive();
+}
+
+@end
+#else
+
+@implementation ImpellerAppStateNotifier
+
+- (instancetype)init {
+  self = [self initWithParent:nil];
+  return self;
+}
+
+- (instancetype)initWithParent:(impeller::AppStateNotifier*)parent {
+  // Note: Not supported on macOS.
+  return [super init];
+}
+
+- (void)onAppBecameActive:(NSNotification*)notification {
+}
+@end
+
+#endif  // FML_OS_IOS
+
+namespace impeller {
+
+struct AppStateNotifier::AppStateNotifierImpl {
+  ImpellerAppStateNotifier* notifier_;
+};
+
+AppStateNotifier::AppStateNotifier()
+    : impl_(
+          new AppStateNotifierImpl{
+              .notifier_ =
+                  [[ImpellerAppStateNotifier alloc] initWithParent:this],
+          },
+          &AppStateNotifier::DeleteImpl) {}
+
+void AppStateNotifier::OnAppBecameActive() {
+  if (app_did_become_active_callback_) {
+    app_did_become_active_callback_();
+  }
+}
+
+void AppStateNotifier::DeleteImpl(AppStateNotifierImpl* impl) {
+  delete impl;
+}
+
+}  // namespace impeller

impeller/renderer/backend/metal/context_mtl.h

@@ -15,6 +15,7 @@
 #include "impeller/base/backend_cast.h"
 #include "impeller/core/sampler.h"
 #include "impeller/renderer/backend/metal/allocator_mtl.h"
+#include "impeller/renderer/backend/metal/app_state_notifier.h"
 #include "impeller/renderer/backend/metal/command_buffer_mtl.h"
 #include "impeller/renderer/backend/metal/pipeline_library_mtl.h"
 #include "impeller/renderer/backend/metal/shader_library_mtl.h"
@@ -93,6 +94,9 @@ class ContextMTL final : public Context,
 
   std::shared_ptr<const fml::SyncSwitch> GetIsGpuDisabledSyncSwitch() const;
 
+  // |Context|
+  void StoreTaskForGPU(std::function<void()> task) override;
+
  private:
   id<MTLDevice> device_ = nullptr;
   id<MTLCommandQueue> command_queue_ = nullptr;
@@ -103,6 +107,8 @@ class ContextMTL final : public Context,
   std::shared_ptr<const Capabilities> device_capabilities_;
   std::shared_ptr<fml::ConcurrentMessageLoop> raster_message_loop_;
   std::shared_ptr<const fml::SyncSwitch> is_gpu_disabled_sync_switch_;
+  std::vector<std::function<void()>> tasks_awaiting_gpu_;
+  AppStateNotifier app_state_notifier_;
   bool is_valid_ = false;
 
   ContextMTL(
@@ -114,6 +120,8 @@ class ContextMTL final : public Context,
   std::shared_ptr<CommandBuffer> CreateCommandBufferInQueue(
       id<MTLCommandQueue> queue) const;
 
+  void FlushTasksAwaitingGPU();
+
   FML_DISALLOW_COPY_AND_ASSIGN(ContextMTL);
 };
 

impeller/renderer/backend/metal/context_mtl.mm

@@ -83,6 +83,9 @@ static bool DeviceSupportsComputeSubgroups(id<MTLDevice> device) {
     return;
   }
 
+  app_state_notifier_.SetAppDidBecomeActiveCallback(
+      [this] { this->FlushTasksAwaitingGPU(); });
+
   // Worker task runner.
   {
     raster_message_loop_ = fml::ConcurrentMessageLoop::Create(
@@ -376,4 +379,15 @@ new ContextMTL(device, command_queue,
   return buffer;
 }
 
+void ContextMTL::StoreTaskForGPU(std::function<void()> task) {
+  tasks_awaiting_gpu_.emplace_back(std::move(task));
+}
+
+void ContextMTL::FlushTasksAwaitingGPU() {
+  for (const auto& task : tasks_awaiting_gpu_) {
+    task();
+  }
+  tasks_awaiting_gpu_.clear();
+}
+
 }  // namespace impeller

impeller/renderer/context.h

@@ -176,6 +176,12 @@ class Context {
 
   CaptureContext capture;
 
+  /// Threadsafe.
+  /// `task` should be executed on the platform thread.
+  virtual void StoreTaskForGPU(std::function<void()> task) {
+    FML_CHECK(false && "not supported in this context");
+  }
+
  protected:
   Context();
 

lib/ui/painting/image_encoding_impeller.cc

@@ -56,21 +56,23 @@ sk_sp<SkImage> ConvertBufferToSkImage(
   return raster_image;
 }
 
-void DoConvertImageToRasterImpeller(
+[[nodiscard]] fml::Status DoConvertImageToRasterImpeller(
     const sk_sp<DlImage>& dl_image,
-    std::function<void(fml::StatusOr<sk_sp<SkImage>>)> encode_task,
+    const std::function<void(fml::StatusOr<sk_sp<SkImage>>)>& encode_task,
     const std::shared_ptr<const fml::SyncSwitch>& is_gpu_disabled_sync_switch,
     const std::shared_ptr<impeller::Context>& impeller_context) {
+  fml::Status result;
   is_gpu_disabled_sync_switch->Execute(
       fml::SyncSwitch::Handlers()
-          .SetIfTrue([&encode_task] {
-            encode_task(
-                fml::Status(fml::StatusCode::kUnavailable, "GPU unavailable."));
+          .SetIfTrue([&result] {
+            result =
+                fml::Status(fml::StatusCode::kUnavailable, "GPU unavailable.");
           })
           .SetIfFalse([&dl_image, &encode_task, &impeller_context] {
             ImageEncodingImpeller::ConvertDlImageToSkImage(
                 dl_image, std::move(encode_task), impeller_context);
           }));
+  return result;
 }
 
 }  // namespace
@@ -153,18 +155,57 @@ void ImageEncodingImpeller::ConvertImageToRaster(
   };
 
   if (dl_image->owning_context() != DlImage::OwningContext::kRaster) {
-    DoConvertImageToRasterImpeller(dl_image, std::move(encode_task),
-                                   is_gpu_disabled_sync_switch,
-                                   impeller_context);
+    fml::Status status = DoConvertImageToRasterImpeller(
+        dl_image, encode_task, is_gpu_disabled_sync_switch, impeller_context);
+    if (!status.ok()) {
+      if (status.code() == fml::StatusCode::kUnavailable) {
+        impeller_context->StoreTaskForGPU([dl_image = std::move(dl_image),
+                                           encode_task = std::move(encode_task),
+                                           is_gpu_disabled_sync_switch,
+                                           impeller_context] {
+          fml::Status retry_status = DoConvertImageToRasterImpeller(
+              dl_image, encode_task, is_gpu_disabled_sync_switch,
+              impeller_context);
+          if (!retry_status.ok()) {
+            encode_task(retry_status);
+          }
+        });
+      } else {
+        encode_task(status);
+      }
+    }
     return;
   }
 
   raster_task_runner->PostTask([dl_image, encode_task = std::move(encode_task),
                                 io_task_runner, is_gpu_disabled_sync_switch,
-                                impeller_context]() mutable {
-    DoConvertImageToRasterImpeller(dl_image, std::move(encode_task),
-                                   is_gpu_disabled_sync_switch,
-                                   impeller_context);
+                                impeller_context,
+                                raster_task_runner]() mutable {
+    fml::Status status = DoConvertImageToRasterImpeller(
+        dl_image, std::move(encode_task), is_gpu_disabled_sync_switch,
+        impeller_context);
+    if (!status.ok()) {
+      if (status.code() == fml::StatusCode::kUnavailable) {
+        impeller_context->StoreTaskForGPU(
+            [dl_image = std::move(dl_image),
+             encode_task = std::move(encode_task), is_gpu_disabled_sync_switch,
+             impeller_context, raster_task_runner] {
+              raster_task_runner->PostTask(
+                  [dl_image = std::move(dl_image),
+                   encode_task = std::move(encode_task),
+                   is_gpu_disabled_sync_switch, impeller_context] {
+                    fml::Status retry_status = DoConvertImageToRasterImpeller(
+                        dl_image, encode_task, is_gpu_disabled_sync_switch,
+                        impeller_context);
+                    if (!retry_status.ok()) {
+                      encode_task(retry_status);
+                    }
+                  });
+            });
+      } else {
+        encode_task(status);
+      }
+    }
   });
 }