Speculative fix for memory issues related to retrying image decompression

impeller/renderer/backend/metal/context_mtl.mm

@@ -383,7 +383,7 @@ new ContextMTL(device, command_queue,
                                  const fml::closure& failure) {
   tasks_awaiting_gpu_.push_back(PendingTasks{task, failure});
   while (tasks_awaiting_gpu_.size() > kMaxTasksAwaitingGPU) {
-    PendingTasks front = std::move(tasks_awaiting_gpu_.front());
+    const PendingTasks& front = tasks_awaiting_gpu_.front();
     if (front.failure) {
       front.failure();
     }

lib/ui/fixtures/ui_test.dart

@@ -394,6 +394,45 @@ Future<void> toByteDataRetries() async {
   }
 }
 
+@pragma('vm:entry-point')
+Future<void> toByteDataRetryOverflows() async {
+  final PictureRecorder pictureRecorder = PictureRecorder();
+  final Canvas canvas = Canvas(pictureRecorder);
+  final Paint paint = Paint()
+    ..color = Color.fromRGBO(255, 255, 255, 1.0)
+    ..style = PaintingStyle.fill;
+  final Offset c = Offset(50.0, 50.0);
+  canvas.drawCircle(c, 25.0, paint);
+  final Picture picture = pictureRecorder.endRecording();
+  List<Image> images = [];
+  // This number must be bigger than impeller::Context::kMaxTasksAwaitingGPU.
+  int numJobs = 100;
+  for (int i = 0; i < numJobs; ++i) {
+    images.add(await picture.toImage(100, 100));
+  }
+  List<Future<ByteData?>> dataFutures = [];
+  _turnOffGPU(true);
+  for (Image image in images) {
+    dataFutures.add(image.toByteData());
+  }
+  Future<void>.delayed(Duration(milliseconds: 10), () {
+    _turnOffGPU(false);
+  });
+
+  ByteData? result;
+  for (Future<ByteData?> future in dataFutures) {
+    try {
+      ByteData? byteData = await future;
+      if (byteData != null) {
+        result = byteData;
+      }
+    } catch (_) {
+      // Ignore errors from unavailable gpu.
+    }
+  }
+  _validateNotNull(result);
+}
+
 @pragma('vm:entry-point')
 Future<void> toImageRetries() async {
   final PictureRecorder pictureRecorder = PictureRecorder();
@@ -416,6 +455,40 @@ Future<void> toImageRetries() async {
   }
 }
 
+@pragma('vm:entry-point')
+Future<void> toImageRetryOverflows() async {
+  final PictureRecorder pictureRecorder = PictureRecorder();
+  final Canvas canvas = Canvas(pictureRecorder);
+  final Paint paint = Paint()
+    ..color = Color.fromRGBO(255, 255, 255, 1.0)
+    ..style = PaintingStyle.fill;
+  final Offset c = Offset(50.0, 50.0);
+  canvas.drawCircle(c, 25.0, paint);
+  final Picture picture = pictureRecorder.endRecording();
+  _turnOffGPU(true);
+  List<Future<Image>> imageFutures = [];
+  // This number must be bigger than impeller::Context::kMaxTasksAwaitingGPU.
+  int numJobs = 100;
+  for (int i = 0; i < numJobs; i++) {
+    imageFutures.add(picture.toImage(100, 100));
+  }
+  Future<void>.delayed(Duration(milliseconds: 10), () {
+    _turnOffGPU(false);
+  });
+  late Image result;
+  bool didSeeImage = false;
+  for (Future<Image> future in imageFutures) {
+    try {
+      Image image = await future;
+      result = image;
+      didSeeImage = true;
+    } catch (_) {
+      // Ignore gpu not available errors.
+    }
+  }
+  _validateNotNull(didSeeImage ? result : null);
+}
+
 @pragma('vm:entry-point')
 Future<void> pumpImage() async {
   const int width = 60;

lib/ui/painting/image_decoder_impeller.cc

@@ -418,22 +418,19 @@ void ImageDecoderImpeller::UploadTextureToPrivate(
             result(image, decode_error);
           })
           .SetIfTrue([&result, context, buffer, image_info, resize_info] {
-            // The `result` function must be copied in the capture list for each
-            // closure or the stack allocated callback will be cleared by the
-            // time to closure is executed later.
+            auto result_ptr = std::make_shared<ImageResult>(std::move(result));
             context->StoreTaskForGPU(
-                [result, context, buffer, image_info, resize_info]() {
+                [result_ptr, context, buffer, image_info, resize_info]() {
                   sk_sp<DlImage> image;
                   std::string decode_error;
-                  std::tie(image, decode_error) =
-                      std::tie(image, decode_error) =
-                          UnsafeUploadTextureToPrivate(context, buffer,
-                                                       image_info, resize_info);
-                  result(image, decode_error);
+                  std::tie(image, decode_error) = UnsafeUploadTextureToPrivate(
+                      context, buffer, image_info, resize_info);
+                  (*result_ptr)(image, decode_error);
                 },
-                [result]() {
-                  result(nullptr,
-                         "Image upload failed due to loss of GPU access.");
+                [result_ptr]() {
+                  (*result_ptr)(
+                      nullptr,
+                      "Image upload failed due to loss of GPU access.");
                 });
           }));
 }

lib/ui/painting/image_encoding_unittests.cc

@@ -280,6 +280,54 @@ TEST_F(ShellTest, EncodeImageRetries) {
   DestroyShell(std::move(shell), task_runners);
 }
 
+TEST_F(ShellTest, EncodeImageRetryOverflows) {
+#ifndef FML_OS_MACOSX
+  GTEST_SKIP() << "Only works on macos currently.";
+#endif
+  Settings settings = CreateSettingsForFixture();
+  settings.enable_impeller = true;
+  TaskRunners task_runners("test",                  // label
+                           GetCurrentTaskRunner(),  // platform
+                           CreateNewThread(),       // raster
+                           CreateNewThread(),       // ui
+                           CreateNewThread()        // io
+  );
+
+  std::unique_ptr<Shell> shell = CreateShell({
+      .settings = settings,
+      .task_runners = task_runners,
+  });
+
+  auto turn_off_gpu = [&](Dart_NativeArguments args) {
+    auto handle = Dart_GetNativeArgument(args, 0);
+    bool value = true;
+    ASSERT_TRUE(Dart_IsBoolean(handle));
+    Dart_BooleanValue(handle, &value);
+    TurnOffGPU(shell.get(), value);
+  };
+
+  AddNativeCallback("TurnOffGPU", CREATE_NATIVE_ENTRY(turn_off_gpu));
+
+  auto validate_not_null = [&](Dart_NativeArguments args) {
+    auto handle = Dart_GetNativeArgument(args, 0);
+    EXPECT_FALSE(Dart_IsNull(handle));
+    message_latch.Signal();
+  };
+
+  AddNativeCallback("ValidateNotNull", CREATE_NATIVE_ENTRY(validate_not_null));
+
+  ASSERT_TRUE(shell->IsSetup());
+  auto configuration = RunConfiguration::InferFromSettings(settings);
+  configuration.SetEntrypoint("toByteDataRetryOverflows");
+
+  shell->RunEngine(std::move(configuration), [&](auto result) {
+    ASSERT_EQ(result, Engine::RunStatus::Success);
+  });
+
+  message_latch.Wait();
+  DestroyShell(std::move(shell), task_runners);
+}
+
 TEST_F(ShellTest, ToImageRetries) {
 #ifndef FML_OS_MACOSX
   GTEST_SKIP() << "Only works on macos currently.";
@@ -327,6 +375,53 @@ TEST_F(ShellTest, ToImageRetries) {
   message_latch.Wait();
   DestroyShell(std::move(shell), task_runners);
 }
+TEST_F(ShellTest, ToImageRetryOverflow) {
+#ifndef FML_OS_MACOSX
+  GTEST_SKIP() << "Only works on macos currently.";
+#endif
+  Settings settings = CreateSettingsForFixture();
+  settings.enable_impeller = true;
+  TaskRunners task_runners("test",                  // label
+                           GetCurrentTaskRunner(),  // platform
+                           CreateNewThread(),       // raster
+                           CreateNewThread(),       // ui
+                           CreateNewThread()        // io
+  );
+
+  std::unique_ptr<Shell> shell = CreateShell({
+      .settings = settings,
+      .task_runners = task_runners,
+  });
+
+  auto turn_off_gpu = [&](Dart_NativeArguments args) {
+    auto handle = Dart_GetNativeArgument(args, 0);
+    bool value = true;
+    ASSERT_TRUE(Dart_IsBoolean(handle));
+    Dart_BooleanValue(handle, &value);
+    TurnOffGPU(shell.get(), value);
+  };
+
+  AddNativeCallback("TurnOffGPU", CREATE_NATIVE_ENTRY(turn_off_gpu));
+
+  auto validate_not_null = [&](Dart_NativeArguments args) {
+    auto handle = Dart_GetNativeArgument(args, 0);
+    EXPECT_FALSE(Dart_IsNull(handle));
+    message_latch.Signal();
+  };
+
+  AddNativeCallback("ValidateNotNull", CREATE_NATIVE_ENTRY(validate_not_null));
+
+  ASSERT_TRUE(shell->IsSetup());
+  auto configuration = RunConfiguration::InferFromSettings(settings);
+  configuration.SetEntrypoint("toImageRetryOverflows");
+
+  shell->RunEngine(std::move(configuration), [&](auto result) {
+    ASSERT_EQ(result, Engine::RunStatus::Success);
+  });
+
+  message_latch.Wait();
+  DestroyShell(std::move(shell), task_runners);
+}
 
 TEST_F(ShellTest, EncodeImageFailsWithoutGPUImpeller) {
 #ifndef FML_OS_MACOSX