Windows: Texture Registrar: Destroy textures on raster thread

Author: jnschulze

shell/platform/windows/flutter_windows_engine.cc

@@ -509,6 +509,27 @@ bool FlutterWindowsEngine::MarkExternalTextureFrameAvailable(
               engine_, texture_id) == kSuccess);
 }
 
+bool FlutterWindowsEngine::PostRasterThreadTask(
+    std::function<void()> callback) {
+  struct Captures {
+    std::function<void()> callback;
+  };
+  auto captures = std::make_unique<Captures>();
+  captures->callback = callback;
+  if (embedder_api_.PostRenderThreadTask(
+          engine_,
+          [](void* opaque) {
+            auto captures = reinterpret_cast<Captures*>(opaque);
+            captures->callback();
+            delete captures;
+          },
+          captures.get()) == kSuccess) {
+    captures.release();
+    return true;
+  }
+  return false;
+}
+
 bool FlutterWindowsEngine::DispatchSemanticsAction(
     uint64_t target,
     FlutterSemanticsAction action,

shell/platform/windows/flutter_windows_engine.h

@@ -170,6 +170,9 @@ class FlutterWindowsEngine {
   // given |texture_id|.
   bool MarkExternalTextureFrameAvailable(int64_t texture_id);
 
+  // Posts the given callback onto the raster thread.
+  bool PostRasterThreadTask(std::function<void()> callback);
+
   // Invoke on the embedder's vsync callback to schedule a frame.
   void OnVsync(intptr_t baton);
 

shell/platform/windows/flutter_windows_engine_unittests.cc

@@ -374,5 +374,21 @@ TEST(FlutterWindowsEngine, AddPluginRegistrarDestructionCallback) {
   EXPECT_EQ(result2, 2);
 }
 
+TEST(FlutterWindowsEngine, PostRasterThreadTask) {
+  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
+  EngineModifier modifier(engine.get());
+
+  modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
+      PostRenderThreadTask, ([](auto engine, auto callback, auto context) {
+        callback(context);
+        return kSuccess;
+      }));
+
+  bool called = false;
+  engine->PostRasterThreadTask([&called]() { called = true; });
+
+  EXPECT_TRUE(called);
+}
+
 }  // namespace testing
 }  // namespace flutter

shell/platform/windows/flutter_windows_texture_registrar.cc

@@ -4,6 +4,7 @@
 
 #include "flutter/shell/platform/windows/flutter_windows_texture_registrar.h"
 
+#include <future>
 #include <iostream>
 #include <mutex>
 
@@ -78,19 +79,22 @@ int64_t FlutterWindowsTextureRegistrar::EmplaceTexture(
 }
 
 bool FlutterWindowsTextureRegistrar::UnregisterTexture(int64_t texture_id) {
-  {
+  engine_->task_runner()->RunNowOrPostTask([engine = engine_, texture_id]() {
+    engine->UnregisterExternalTexture(texture_id);
+  });
+
+  std::promise<bool> promise;
+  engine_->PostRasterThreadTask([this, &promise, texture_id]() {
     std::lock_guard<std::mutex> lock(map_mutex_);
     auto it = textures_.find(texture_id);
-    if (it == textures_.end()) {
-      return false;
+    if (it != textures_.end()) {
+      textures_.erase(it);
+      promise.set_value(true);
+    } else {
+      promise.set_value(false);
     }
-    textures_.erase(it);
-  }
-
-  engine_->task_runner()->RunNowOrPostTask([engine = engine_, texture_id]() {
-    engine->UnregisterExternalTexture(texture_id);
   });
-  return true;
+  return promise.get_future().get();
 }
 
 bool FlutterWindowsTextureRegistrar::MarkTextureFrameAvailable(

shell/platform/windows/flutter_windows_texture_registrar_unittests.cc

@@ -113,6 +113,13 @@ TEST(FlutterWindowsTextureRegistrarTest, RegisterUnregisterTexture) {
                          return kSuccess;
                        }));
 
+  modifier.embedder_api().PostRenderThreadTask =
+      MOCK_ENGINE_PROC(PostRenderThreadTask,
+                       [](auto engine, auto callback, void* callback_data) {
+                         callback(callback_data);
+                         return kSuccess;
+                       });
+
   auto texture_id = registrar.RegisterTexture(&texture_info);
   EXPECT_TRUE(register_called);
   EXPECT_NE(texture_id, -1);