Use Windowing system-specific WindowContext factories.

tools/viewer/sk_app/VulkanWindowContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 #include "GrRenderTarget.h"
 #include "SkSurface.h"
 #include "VulkanWindowContext.h"
 
 #include "vk/GrVkInterface.h"
 #include "vk/GrVkUtil.h"
 #include "vk/GrVkTypes.h"
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 // windows wants to define this as CreateSemaphoreA or CreateSemaphoreW
 #undef CreateSemaphore
 #endif
 
 #define GET_PROC(F) f ## F = (PFN_vk ## F) vkGetInstanceProcAddr(instance, "vk" #F)
 #define GET_DEV_PROC(F) f ## F = (PFN_vk ## F) vkGetDeviceProcAddr(device, "vk" #F)
 
 namespace sk_app {
 
-VulkanWindowContext::VulkanWindowContext(void* platformData, const DisplayParams& params)
+VulkanWindowContext::VulkanWindowContext(const DisplayParams& params,
+                                         CreateVkSurfaceFn createVkSurface,
+                                         CanPresentFn canPresent)
     : WindowContext()
     , fSurface(VK_NULL_HANDLE)
     , fSwapchain(VK_NULL_HANDLE)
     , fImages(nullptr)
     , fImageLayouts(nullptr)
     , fSurfaces(nullptr)
     , fCommandPool(VK_NULL_HANDLE)
     , fBackbuffers(nullptr) {
 
     // any config code here (particularly for msaa)?
-
-    this->initializeContext(platformData, params);
-}
-
-void VulkanWindowContext::initializeContext(void* platformData, const DisplayParams& params) {
-    fBackendContext.reset(GrVkBackendContext::Create(&fPresentQueueIndex, canPresent, 
-                                                     platformData));
+    fBackendContext.reset(GrVkBackendContext::Create(&fPresentQueueIndex, canPresent));
 
     if (!(fBackendContext->fExtensions & kKHR_surface_GrVkExtensionFlag) ||
         !(fBackendContext->fExtensions & kKHR_swapchain_GrVkExtensionFlag)) {
         fBackendContext.reset(nullptr);
         return;
     }
 
     VkInstance instance = fBackendContext->fInstance;
     VkDevice device = fBackendContext->fDevice;
     GET_PROC(DestroySurfaceKHR);
     GET_PROC(GetPhysicalDeviceSurfaceSupportKHR);
     GET_PROC(GetPhysicalDeviceSurfaceCapabilitiesKHR);
     GET_PROC(GetPhysicalDeviceSurfaceFormatsKHR);
     GET_PROC(GetPhysicalDeviceSurfacePresentModesKHR);
     GET_DEV_PROC(CreateSwapchainKHR);
     GET_DEV_PROC(DestroySwapchainKHR);
     GET_DEV_PROC(GetSwapchainImagesKHR);
     GET_DEV_PROC(AcquireNextImageKHR);
     GET_DEV_PROC(QueuePresentKHR);
 
     fContext = GrContext::Create(kVulkan_GrBackend, (GrBackendContext) fBackendContext.get());
 
-    fSurface = createVkSurface(instance, platformData);
+    fSurface = createVkSurface(instance);
     if (VK_NULL_HANDLE == fSurface) {
         fBackendContext.reset(nullptr);
         return;
     }
 
     VkBool32 supported;
     VkResult res = fGetPhysicalDeviceSurfaceSupportKHR(fBackendContext->fPhysicalDevice,
                                                        fPresentQueueIndex, fSurface,
                                                        &supported);
     if (VK_SUCCESS != res) {
@@ skipping 515 matching lines @@
         &fSwapchain, // pSwapchains
         &backbuffer->fImageIndex, // pImageIndices
         NULL // pResults
     };
 
     fQueuePresentKHR(fPresentQueue, &presentInfo);
 
 }
 
 }   //namespace sk_app