Get Vulkan building on Windows

This CL adds support for Vulkan on windows but disables it in builds.
This makes it easy to enable and test.

BUG=850724

Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;luci.chromium.try:linux_optional_gpu_tests_rel;luci.chromium.try:mac_optional_gpu_tests_rel;luci.chromium.try:win_optional_gpu_tests_rel
Change-Id: I8396b2f59133df5d72d1086cf22e154dba0bb15e
Reviewed-on: https://chromium-review.googlesource.com/c/1270098
Commit-Queue: Chris Blume <cblume@chromium.org>
Reviewed-by: Eric Karl <ericrk@chromium.org>
Cr-Commit-Position: refs/heads/master@{#600127}

gpu/vulkan/features.gni

@@ -8,11 +8,5 @@ import("//build/config/ui.gni")
 # For details see declare_args() in build/config/BUILDCONFIG.gn.
 declare_args() {
   # Enable experimental vulkan backend.
-  enable_vulkan = is_linux || is_android || is_fuchsia
-
-  # We want to temporarily disable Vulkan on Android to give us time to
-  # investigate ways to reduce its binary size.
-  if (is_android) {
-    enable_vulkan = false
-  }
+  enable_vulkan = is_linux || is_fuchsia
 }

gpu/vulkan/init/BUILD.gn

@@ -32,4 +32,7 @@ component("init") {
   if (use_ozone) {
     deps += [ "//ui/ozone" ]
   }
+  if (is_win) {
+    deps += [ "//gpu/vulkan/win32" ]
+  }
 }

gpu/vulkan/init/vulkan_factory.cc

@@ -11,6 +11,10 @@
 #include "gpu/vulkan/android/vulkan_implementation_android.h"
 #endif
 
+#if defined(OS_WIN)
+#include "gpu/vulkan/win32/vulkan_implementation_win32.h"
+#endif
+
 #if defined(USE_X11)
 #include "gpu/vulkan/x/vulkan_implementation_x11.h"  // nogncheck
 #endif
@@ -31,6 +35,8 @@ std::unique_ptr<VulkanImplementation> CreateVulkanImplementation() {
   return ui::OzonePlatform::GetInstance()
       ->GetSurfaceFactoryOzone()
       ->CreateVulkanImplementation();
+#elif defined(OS_WIN)
+  return std::make_unique<VulkanImplementationWin32>();
 #else
 #error Unsupported Vulkan Platform.
 #endif

gpu/vulkan/win32/BUILD.gn

+# Copyright 2018 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/config/ui.gni")
+import("//gpu/vulkan/features.gni")
+
+assert(enable_vulkan)
+assert(is_win)
+
+config("vulkan_win32") {
+  defines = [ "VK_USE_PLATFORM_WIN32_KHR" ]
+}
+
+component("win32") {
+  output_name = "vulkan_win32"
+
+  sources = [
+    "vulkan_implementation_win32.cc",
+    "vulkan_implementation_win32.h",
+  ]
+
+  defines = [ "IS_VULKAN_WIN32_IMPL" ]
+
+  public_configs = [ ":vulkan_win32" ]
+
+  deps = [
+    "//ui/gfx",
+  ]
+
+  public_deps = [
+    "//base",
+    "//gpu/vulkan",
+  ]
+}

gpu/vulkan/win32/vulkan_implementation_win32.cc

+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "gpu/vulkan/win32/vulkan_implementation_win32.h"
+
+#include <Windows.h>
+
+#include "base/files/file_path.h"
+#include "base/logging.h"
+#include "gpu/vulkan/vulkan_function_pointers.h"
+#include "gpu/vulkan/vulkan_instance.h"
+#include "gpu/vulkan/vulkan_surface.h"
+#include "ui/gfx/gpu_fence.h"
+
+namespace gpu {
+
+VulkanImplementationWin32::~VulkanImplementationWin32() = default;
+
+bool VulkanImplementationWin32::InitializeVulkanInstance() {
+  std::vector<const char*> required_extensions = {
+      VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME};
+
+  VulkanFunctionPointers* vulkan_function_pointers =
+      gpu::GetVulkanFunctionPointers();
+
+  base::NativeLibraryLoadError native_library_load_error;
+  vulkan_function_pointers->vulkan_loader_library_ = base::LoadNativeLibrary(
+      base::FilePath(L"vulkan-1.dll"), &native_library_load_error);
+  if (!vulkan_function_pointers->vulkan_loader_library_)
+    return false;
+
+  if (!vulkan_instance_.Initialize(required_extensions, {})) {
+    vulkan_instance_.Destroy();
+    return false;
+  }
+
+  // Initialize platform function pointers
+  vkGetPhysicalDeviceWin32PresentationSupportKHR_ =
+      reinterpret_cast<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>(
+          vkGetInstanceProcAddr(
+              vulkan_instance_.vk_instance(),
+              "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
+  if (!vkGetPhysicalDeviceWin32PresentationSupportKHR_) {
+    LOG(ERROR) << "vkGetPhysicalDeviceWin32PresentationSupportKHR not found";
+    vulkan_instance_.Destroy();
+    return false;
+  }
+
+  vkCreateWin32SurfaceKHR_ =
+      reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(vkGetInstanceProcAddr(
+          vulkan_instance_.vk_instance(), "vkCreateWin32SurfaceKHR"));
+  if (!vkCreateWin32SurfaceKHR_) {
+    LOG(ERROR) << "vkCreateWin32SurfaceKHR not found";
+    vulkan_instance_.Destroy();
+    return false;
+  }
+
+  return true;
+}
+
+VkInstance VulkanImplementationWin32::GetVulkanInstance() {
+  return vulkan_instance_.vk_instance();
+}
+
+std::unique_ptr<VulkanSurface> VulkanImplementationWin32::CreateViewSurface(
+    gfx::AcceleratedWidget window) {
+  VkSurfaceKHR surface;
+  VkWin32SurfaceCreateInfoKHR surface_create_info = {};
+  surface_create_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+  surface_create_info.hinstance =
+      reinterpret_cast<HINSTANCE>(GetWindowLongPtr(window, GWLP_HINSTANCE));
+  surface_create_info.hwnd = window;
+  VkResult result = vkCreateWin32SurfaceKHR_(
+      GetVulkanInstance(), &surface_create_info, nullptr, &surface);
+  if (VK_SUCCESS != result) {
+    DLOG(ERROR) << "vkCreatWin32SurfaceKHR() failed: " << result;
+    return nullptr;
+  }
+
+  return std::make_unique<VulkanSurface>(GetVulkanInstance(), surface);
+}
+
+bool VulkanImplementationWin32::GetPhysicalDevicePresentationSupport(
+    VkPhysicalDevice device,
+    const std::vector<VkQueueFamilyProperties>& queue_family_properties,
+    uint32_t queue_family_index) {
+  return vkGetPhysicalDeviceWin32PresentationSupportKHR_(device,
+                                                         queue_family_index);
+}
+
+std::vector<const char*>
+VulkanImplementationWin32::GetRequiredDeviceExtensions() {
+  return {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
+}
+
+VkFence VulkanImplementationWin32::CreateVkFenceForGpuFence(
+    VkDevice vk_device) {
+  NOTREACHED();
+  return VK_NULL_HANDLE;
+}
+
+std::unique_ptr<gfx::GpuFence>
+VulkanImplementationWin32::ExportVkFenceToGpuFence(VkDevice vk_device,
+                                                   VkFence vk_fence) {
+  NOTREACHED();
+  return nullptr;
+}
+
+}  // namespace gpu

gpu/vulkan/win32/vulkan_implementation_win32.h

+// Copyright (c) 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GPU_VULKAN_WIN32_VULKAN_IMPLEMENTATION_WIN32_H_
+#define GPU_VULKAN_WIN32_VULKAN_IMPLEMENTATION_WIN32_H_
+
+#include <memory>
+
+#include "base/component_export.h"
+#include "gpu/vulkan/vulkan_implementation.h"
+#include "gpu/vulkan/vulkan_instance.h"
+
+namespace gpu {
+
+class COMPONENT_EXPORT(VULKAN_WIN32) VulkanImplementationWin32
+    : public VulkanImplementation {
+ public:
+  VulkanImplementationWin32() = default;
+  ~VulkanImplementationWin32() override;
+
+  // VulkanImplementation:
+  bool InitializeVulkanInstance() override;
+  VkInstance GetVulkanInstance() override;
+  std::unique_ptr<VulkanSurface> CreateViewSurface(
+      gfx::AcceleratedWidget window) override;
+  bool GetPhysicalDevicePresentationSupport(
+      VkPhysicalDevice device,
+      const std::vector<VkQueueFamilyProperties>& queue_family_properties,
+      uint32_t queue_family_index) override;
+  std::vector<const char*> GetRequiredDeviceExtensions() override;
+  VkFence CreateVkFenceForGpuFence(VkDevice vk_device) override;
+  std::unique_ptr<gfx::GpuFence> ExportVkFenceToGpuFence(
+      VkDevice vk_device,
+      VkFence vk_fence) override;
+
+ private:
+  VulkanInstance vulkan_instance_;
+
+  PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR
+      vkGetPhysicalDeviceWin32PresentationSupportKHR_ = nullptr;
+  PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(VulkanImplementationWin32);
+};
+
+}  // namespace gpu
+
+#endif  // GPU_VULKAN_WIN32_VULKAN_IMPLEMENTATION_WIN32_H_