Move GPU fences into sk_gpu_test

tools/gpu/vk/VkTestContext.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "VkTestContext.h"
 
 #ifdef SK_VULKAN
 
 #include "vk/GrVkInterface.h"
 #include "vk/GrVkUtil.h"
 #include <vulkan/vulkan.h>
 
 namespace {
 /**
- * Implements SkGpuFenceSync for Vulkan. It creates a single command buffer with
- * USAGE_SIMULTANEOUS with no content . On every insertFence request it submits
- * the command buffer with a new fence.
+ * Implements sk_gpu_test::FenceSync for Vulkan. It creates a single command
+ * buffer with USAGE_SIMULTANEOUS with no content . On every insertFence request
+ * it submits the command buffer with a new fence.
  */
-class VkFenceSync : public SkGpuFenceSync {
+class VkFenceSync : public sk_gpu_test::FenceSync {
 public:
     VkFenceSync(sk_sp<const GrVkInterface> vk, VkDevice device, VkQueue queue,
                 uint32_t queueFamilyIndex)
             : fVk(std::move(vk))
             , fDevice(device)
             , fQueue(queue) {
         SkDEBUGCODE(fUnfinishedSyncs = 0;)
         VkCommandPoolCreateInfo createInfo;
         createInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
         createInfo.pNext = nullptr;
@@ skipping 18 matching lines @@
         GR_VK_CALL_ERRCHECK(fVk, EndCommandBuffer(fCommandBuffer));
     }
 
     ~VkFenceSync() override {
         SkASSERT(!fUnfinishedSyncs);
         // If the above assertion is true then the command buffer should not be in flight.
         GR_VK_CALL(fVk, FreeCommandBuffers(fDevice, fCommandPool, 1, &fCommandBuffer));
         GR_VK_CALL(fVk, DestroyCommandPool(fDevice, fCommandPool, nullptr));
     }
 
-    SkPlatformGpuFence SK_WARN_UNUSED_RESULT insertFence() const override {
+    sk_gpu_test::PlatformFence SK_WARN_UNUSED_RESULT insertFence() const override {
         VkFence fence;
         VkFenceCreateInfo info;
         info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
         info.pNext = nullptr;
         info.flags = 0;
         GR_VK_CALL_ERRCHECK(fVk, CreateFence(fDevice, &info, nullptr, &fence));
         VkSubmitInfo submitInfo;
         submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
         submitInfo.pNext = nullptr;
         submitInfo.waitSemaphoreCount = 0;
         submitInfo.pWaitSemaphores = nullptr;
         submitInfo.pWaitDstStageMask = nullptr;
         submitInfo.commandBufferCount = 1;
         submitInfo.pCommandBuffers = &fCommandBuffer;
         submitInfo.signalSemaphoreCount = 0;
         submitInfo.pSignalSemaphores = nullptr;
         GR_VK_CALL_ERRCHECK(fVk, QueueSubmit(fQueue, 1, &submitInfo, fence));
         SkDEBUGCODE(++fUnfinishedSyncs;)
-        return reinterpret_cast<SkPlatformGpuFence>(fence);
+        return reinterpret_cast<sk_gpu_test::PlatformFence>(fence);
     }
 
-    bool waitFence(SkPlatformGpuFence opaqueFence) const override {
+    bool waitFence(sk_gpu_test::PlatformFence opaqueFence) const override {
         VkFence fence = reinterpret_cast<VkFence>(opaqueFence);
         static constexpr uint64_t kForever = ~((uint64_t)0);
         auto result = GR_VK_CALL(fVk, WaitForFences(fDevice, 1, &fence, true, kForever));
         return result != VK_TIMEOUT;
     }
 
-    void deleteFence(SkPlatformGpuFence opaqueFence) const override {
+    void deleteFence(sk_gpu_test::PlatformFence opaqueFence) const override {
         VkFence fence = reinterpret_cast<VkFence>(opaqueFence);
         GR_VK_CALL(fVk, DestroyFence(fDevice, fence, nullptr));
         SkDEBUGCODE(--fUnfinishedSyncs;)
     }
 
 private:
     sk_sp<const GrVkInterface>  fVk;
     VkDevice                    fDevice;
     VkQueue                     fQueue;
     VkCommandPool               fCommandPool;
     VkCommandBuffer             fCommandBuffer;
     SkDEBUGCODE(mutable int     fUnfinishedSyncs;)
-    typedef SkGpuFenceSync INHERITED;
+    typedef sk_gpu_test::FenceSync INHERITED;
 };
 
 // TODO: Implement swap buffers and finish
 class VkTestContextImpl : public sk_gpu_test::VkTestContext {
 public:
     static VkTestContext* Create() {
         sk_sp<const GrVkBackendContext> backendContext(GrVkBackendContext::Create());
         if (!backendContext) {
             return nullptr;
         }
@@ skipping 20 matching lines @@
             : VkTestContext(std::move(backendContext)) {
         fFenceSync = new VkFenceSync(sk_ref_sp(fVk->fInterface.get()), fVk->fDevice, fVk->fQueue,
                                      fVk->fGraphicsQueueIndex);
     }
 
     void onPlatformMakeCurrent() const override {}
     void onPlatformSwapBuffers() const override {}
 
     typedef sk_gpu_test::VkTestContext INHERITED;
 };
-}
+}  // anonymous namespace
 
 namespace sk_gpu_test {
 VkTestContext* CreatePlatformVkTestContext() { return VkTestContextImpl::Create(); }
 }  // namespace sk_gpu_test
 
 #endif