gave ownership of the concurrent task queue to the context

Author: gaaclarke

impeller/playground/backend/vulkan/playground_impl_vk.cc

@@ -49,9 +49,7 @@ void PlaygroundImplVK::DestroyWindowHandle(WindowHandle handle) {
 }
 
 PlaygroundImplVK::PlaygroundImplVK(PlaygroundSwitches switches)
-    : PlaygroundImpl(switches),
-      concurrent_loop_(fml::ConcurrentMessageLoop::Create()),
-      handle_(nullptr, &DestroyWindowHandle) {
+    : PlaygroundImpl(switches), handle_(nullptr, &DestroyWindowHandle) {
   if (!::glfwVulkanSupported()) {
 #ifdef TARGET_OS_MAC
     VALIDATION_LOG << "Attempted to initialize a Vulkan playground on macOS "
@@ -83,7 +81,8 @@ PlaygroundImplVK::PlaygroundImplVK(PlaygroundSwitches switches)
           &::glfwGetInstanceProcAddress);
   context_settings.shader_libraries_data = ShaderLibraryMappingsForPlayground();
   context_settings.cache_directory = fml::paths::GetCachesDirectory();
-  context_settings.worker_task_runner = concurrent_loop_->GetTaskRunner();
+  context_settings.worker_concurrent_loop =
+      fml::ConcurrentMessageLoop::Create();
   context_settings.enable_validation = switches_.enable_vulkan_validation;
 
   auto context = ContextVK::Create(std::move(context_settings));
@@ -115,11 +114,7 @@ PlaygroundImplVK::PlaygroundImplVK(PlaygroundSwitches switches)
   context_ = std::move(context);
 }
 
-PlaygroundImplVK::~PlaygroundImplVK() {
-  // Make sure to kill the concurrent loop before the context so that we don't
-  // have threads talking to a dead context.
-  concurrent_loop_.reset();
-};
+PlaygroundImplVK::~PlaygroundImplVK() = default;
 
 // |PlaygroundImpl|
 std::shared_ptr<Context> PlaygroundImplVK::GetContext() const {

impeller/renderer/backend/vulkan/context_vk.cc

@@ -305,11 +305,12 @@ void ContextVK::Setup(Settings settings) {
   //----------------------------------------------------------------------------
   /// Setup the pipeline library.
   ///
+  worker_message_loop_ = std::move(settings.worker_concurrent_loop);
   auto pipeline_library = std::shared_ptr<PipelineLibraryVK>(
-      new PipelineLibraryVK(device.value.get(),                   //
-                            caps,                                 //
-                            std::move(settings.cache_directory),  //
-                            settings.worker_task_runner           //
+      new PipelineLibraryVK(device.value.get(),                    //
+                            caps,                                  //
+                            std::move(settings.cache_directory),   //
+                            worker_message_loop_->GetTaskRunner()  //
                             ));
 
   if (!pipeline_library->IsValid()) {

impeller/renderer/backend/vulkan/context_vk.h

@@ -36,7 +36,7 @@ class ContextVK final : public Context, public BackendCast<ContextVK, Context> {
     PFN_vkGetInstanceProcAddr proc_address_callback = nullptr;
     std::vector<std::shared_ptr<fml::Mapping>> shader_libraries_data;
     fml::UniqueFD cache_directory;
-    std::shared_ptr<fml::ConcurrentTaskRunner> worker_task_runner;
+    std::unique_ptr<fml::ConcurrentMessageLoop> worker_concurrent_loop;
     bool enable_validation = false;
 
     Settings() = default;
@@ -137,6 +137,7 @@ class ContextVK final : public Context, public BackendCast<ContextVK, Context> {
   std::shared_ptr<FenceWaiterVK> fence_waiter_;
   std::string device_name_;
   const uint64_t hash_;
+  std::unique_ptr<fml::ConcurrentMessageLoop> worker_message_loop_;
 
   bool is_valid_ = false;
 

impeller/renderer/backend/vulkan/test/mock_vulkan.cc

@@ -272,8 +272,7 @@ PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance,
 
 std::shared_ptr<ContextVK> CreateMockVulkanContext(void) {
   ContextVK::Settings settings;
-  auto message_loop = fml::ConcurrentMessageLoop::Create();
-  settings.worker_task_runner = message_loop->GetTaskRunner();
+  settings.worker_concurrent_loop = fml::ConcurrentMessageLoop::Create();
   settings.proc_address_callback = GetMockVulkanProcAddress;
   return ContextVK::Create(std::move(settings));
 }

shell/platform/android/android_surface_vulkan_impeller.cc

@@ -22,7 +22,7 @@ namespace flutter {
 
 static std::shared_ptr<impeller::Context> CreateImpellerContext(
     const fml::RefPtr<vulkan::VulkanProcTable>& proc_table,
-    const std::shared_ptr<fml::ConcurrentMessageLoop>& concurrent_loop,
+    std::unique_ptr<fml::ConcurrentMessageLoop> concurrent_loop,
     bool enable_vulkan_validation) {
   std::vector<std::shared_ptr<fml::Mapping>> shader_mappings = {
       std::make_shared<fml::NonOwnedMapping>(impeller_entity_shaders_vk_data,
@@ -40,7 +40,7 @@ static std::shared_ptr<impeller::Context> CreateImpellerContext(
   settings.proc_address_callback = instance_proc_addr;
   settings.shader_libraries_data = std::move(shader_mappings);
   settings.cache_directory = fml::paths::GetCachesDirectory();
-  settings.worker_task_runner = concurrent_loop->GetTaskRunner();
+  settings.worker_concurrent_loop = std::move(concurrent_loop);
   settings.enable_validation = enable_vulkan_validation;
   return impeller::ContextVK::Create(std::move(settings));
 }
@@ -50,10 +50,10 @@ AndroidSurfaceVulkanImpeller::AndroidSurfaceVulkanImpeller(
     const std::shared_ptr<PlatformViewAndroidJNI>& jni_facade,
     bool enable_vulkan_validation)
     : AndroidSurface(android_context),
-      proc_table_(fml::MakeRefCounted<vulkan::VulkanProcTable>()),
-      workers_(fml::ConcurrentMessageLoop::Create()) {
+      proc_table_(fml::MakeRefCounted<vulkan::VulkanProcTable>()) {
   impeller_context_ =
-      CreateImpellerContext(proc_table_, workers_, enable_vulkan_validation);
+      CreateImpellerContext(proc_table_, fml::ConcurrentMessageLoop::Create(),
+                            enable_vulkan_validation);
   is_valid_ =
       proc_table_->HasAcquiredMandatoryProcAddresses() && impeller_context_;
 }

shell/platform/android/android_surface_vulkan_impeller.h

@@ -50,7 +50,6 @@ class AndroidSurfaceVulkanImpeller : public AndroidSurface {
  private:
   fml::RefPtr<vulkan::VulkanProcTable> proc_table_;
   fml::RefPtr<AndroidNativeWindow> native_window_;
-  std::shared_ptr<fml::ConcurrentMessageLoop> workers_;
   std::shared_ptr<impeller::Context> impeller_context_;
   bool is_valid_ = false;