added second test

Author: gaaclarke

impeller/renderer/backend/vulkan/command_encoder_vk_unittests.cc

@@ -4,8 +4,10 @@
 
 #include <thread>
 
+#include "flutter/fml/synchronization/count_down_latch.h"
 #include "flutter/testing/testing.h"
 #include "impeller/renderer/backend/vulkan/command_encoder_vk.h"
+#include "impeller/renderer/backend/vulkan/fence_waiter_vk.h"
 #include "impeller/renderer/backend/vulkan/test/mock_vulkan.h"
 
 namespace impeller {
@@ -34,5 +36,41 @@ TEST(CommandEncoderVKTest, DeleteEncoderAfterThreadDies) {
   EXPECT_TRUE(free_buffers < destroy_pool);
 }
 
+TEST(CommandEncoderVKTest, CleanupAfterSubmit) {
+  // This tests deleting the TrackedObjects where the thread is killed before
+  // the fence waiter has disposed of them.
+  std::shared_ptr<std::vector<std::string>> called_functions;
+  {
+    fml::AutoResetWaitableEvent wait_for_submit;
+    fml::AutoResetWaitableEvent wait_for_thread_join;
+    auto context = CreateMockVulkanContext();
+    std::thread thread([&] {
+      CommandEncoderFactoryVK factory(context);
+      std::shared_ptr<CommandEncoderVK> encoder = factory.Create();
+      encoder->Submit([&](bool success) {
+        ASSERT_TRUE(success);
+        wait_for_thread_join.Wait();
+        wait_for_submit.Signal();
+      });
+    });
+    thread.join();
+    wait_for_thread_join.Signal();
+    auto [fence_result, fence] = context->GetDevice().createFenceUnique({});
+    ASSERT_EQ(fence_result, vk::Result::eSuccess);
+    context->GetFenceWaiter()->AddFence(std::move(fence), [] {});
+    wait_for_submit.Wait();
+    called_functions = GetMockVulkanFunctions(context->GetDevice());
+  }
+  auto destroy_pool =
+      std::find(called_functions->begin(), called_functions->end(),
+                "vkDestroyCommandPool");
+  auto free_buffers =
+      std::find(called_functions->begin(), called_functions->end(),
+                "vkFreeCommandBuffers");
+  EXPECT_TRUE(destroy_pool != called_functions->end());
+  EXPECT_TRUE(free_buffers != called_functions->end());
+  EXPECT_TRUE(free_buffers < destroy_pool);
+}
+
 }  // namespace testing
-}  // namespace impeller
+}  // namespace impeller

impeller/renderer/backend/vulkan/resource_manager_vk.h

@@ -71,11 +71,13 @@ class ResourceManagerVK
 
   using Reclaimables = std::vector<std::unique_ptr<ResourceVK>>;
 
-  std::thread waiter_;
   std::mutex reclaimables_mutex_;
   std::condition_variable reclaimables_cv_;
   Reclaimables reclaimables_;
   bool should_exit_ = false;
+  // This should be initialized last since it references the other instance
+  // variables.
+  std::thread waiter_;
 
   void Main();
 

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

@@ -361,6 +361,37 @@ void vkDestroyCommandPool(VkDevice device,
   mock_device->called_functions_->push_back("vkDestroyCommandPool");
 }
 
+VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
+  return VK_SUCCESS;
+}
+
+VkResult vkCreateFence(VkDevice device,
+                       const VkFenceCreateInfo* pCreateInfo,
+                       const VkAllocationCallbacks* pAllocator,
+                       VkFence* pFence) {
+  *pFence = reinterpret_cast<VkFence>(0xfe0ce);
+  return VK_SUCCESS;
+}
+
+VkResult vkQueueSubmit(VkQueue queue,
+                       uint32_t submitCount,
+                       const VkSubmitInfo* pSubmits,
+                       VkFence fence) {
+  return VK_SUCCESS;
+}
+
+VkResult vkWaitForFences(VkDevice device,
+                         uint32_t fenceCount,
+                         const VkFence* pFences,
+                         VkBool32 waitAll,
+                         uint64_t timeout) {
+  return VK_SUCCESS;
+}
+
+VkResult vkGetFenceStatus(VkDevice device, VkFence fence) {
+  return VK_SUCCESS;
+}
+
 PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance,
                                             const char* pName) {
   if (strcmp("vkEnumerateInstanceExtensionProperties", pName) == 0) {
@@ -443,6 +474,16 @@ PFN_vkVoidFunction GetMockVulkanProcAddress(VkInstance instance,
     return (PFN_vkVoidFunction)vkDestroyCommandPool;
   } else if (strcmp("vkFreeCommandBuffers", pName) == 0) {
     return (PFN_vkVoidFunction)vkFreeCommandBuffers;
+  } else if (strcmp("vkEndCommandBuffer", pName) == 0) {
+    return (PFN_vkVoidFunction)vkEndCommandBuffer;
+  } else if (strcmp("vkCreateFence", pName) == 0) {
+    return (PFN_vkVoidFunction)vkCreateFence;
+  } else if (strcmp("vkQueueSubmit", pName) == 0) {
+    return (PFN_vkVoidFunction)vkQueueSubmit;
+  } else if (strcmp("vkWaitForFences", pName) == 0) {
+    return (PFN_vkVoidFunction)vkWaitForFences;
+  } else if (strcmp("vkGetFenceStatus", pName) == 0) {
+    return (PFN_vkVoidFunction)vkGetFenceStatus;
   }
   return noop;
 }