vulkan_tests: Support Windows.

Tested with swiftshader on Windows 10.

Bug: 1065499,963988
Change-Id: Ibce9fbca12332aec8fbc98ed838dfcc9d457ac21
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2125302Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
Commit-Queue: Peng Huang <penghuang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#754464}

gpu/vulkan/BUILD.gn

@@ -126,11 +126,14 @@ if (enable_vulkan) {
       deps += [ "//ui/gfx/x" ]
       configs += [ "//build/config/linux:x11" ]
     }
+    if (is_win) {
+      sources += [ "tests/native_window_win.cc" ]
+    }
   }
 
   # TODO(penghuang): support more platforms
   # https://crbug.com/1065499
-  if (is_android || use_x11) {
+  if (is_android || use_x11 || is_win) {
     test("vulkan_tests") {
       sources = [
         "tests/basic_vulkan_test.cc",

gpu/vulkan/generate_bindings.py

@@ -66,6 +66,14 @@ VULKAN_INSTANCE_FUNCTIONS = [
       'vkGetPhysicalDeviceXlibPresentationSupportKHR',
     ]
   },
+  {
+    'ifdef': 'defined(OS_WIN)',
+    'extension': 'VK_KHR_WIN32_SURFACE_EXTENSION_NAME',
+    'functions': [
+      'vkCreateWin32SurfaceKHR',
+      'vkGetPhysicalDeviceWin32PresentationSupportKHR',
+    ]
+  },
   {
     'ifdef': 'defined(OS_ANDROID)',
     'extension': 'VK_KHR_ANDROID_SURFACE_EXTENSION_NAME',
@@ -329,6 +337,10 @@ def GenerateHeaderFile(file):
 #include <vulkan/vulkan_xlib.h>
 #endif
 
+#if defined(OS_WIN)
+#include <vulkan/vulkan_win32.h>
+#endif
+
 namespace gpu {
 
 struct VulkanFunctionPointers;

gpu/vulkan/init/vulkan_factory.cc

@@ -30,7 +30,7 @@ std::unique_ptr<VulkanImplementation> CreateVulkanImplementation(
     bool use_swiftshader,
     bool allow_protected_memory,
     bool enforce_protected_memory) {
-#if !defined(USE_X11)
+#if !defined(USE_X11) && !defined(OS_WIN)
   // TODO(samans): Support Swiftshader on more platforms.
   // https://crbug.com/963988
   DCHECK(!use_swiftshader)
@@ -50,7 +50,7 @@ std::unique_ptr<VulkanImplementation> CreateVulkanImplementation(
       ->CreateVulkanImplementation(allow_protected_memory,
                                    enforce_protected_memory);
 #elif defined(OS_WIN)
-  return std::make_unique<VulkanImplementationWin32>();
+  return std::make_unique<VulkanImplementationWin32>(use_swiftshader);
 #else
 #error Unsupported Vulkan Platform.
 #endif

gpu/vulkan/tests/basic_vulkan_test.cc

@@ -4,6 +4,7 @@
 
 #include "gpu/vulkan/tests/basic_vulkan_test.h"
 
+#include "base/command_line.h"
 #include "gpu/vulkan/init/vulkan_factory.h"
 #include "gpu/vulkan/tests/native_window.h"
 #include "gpu/vulkan/vulkan_surface.h"
@@ -22,17 +23,21 @@ BasicVulkanTest::~BasicVulkanTest() {}
 
 void BasicVulkanTest::SetUp() {
   platform_event_source_ = ui::PlatformEventSource::CreateDefault();
-#if defined(USE_X11)
+#if defined(USE_X11) || defined(OS_WIN)
+  bool use_swiftshader =
+      base::CommandLine::ForCurrentProcess()->HasSwitch("use-swiftshader");
   const gfx::Rect kDefaultBounds(10, 10, 100, 100);
   window_ = CreateNativeWindow(kDefaultBounds);
 #elif defined(OS_ANDROID)
+  // Vulkan swiftshader is not supported on Android.
+  bool use_swiftshader = false;
   // TODO(penghuang): Not depend on gl.
   uint texture = 0;
   surface_texture_ = gl::SurfaceTexture::Create(texture);
   window_ = surface_texture_->CreateSurface();
   ASSERT_TRUE(window_ != gfx::kNullAcceleratedWidget);
 #endif
-  vulkan_implementation_ = CreateVulkanImplementation();
+  vulkan_implementation_ = CreateVulkanImplementation(use_swiftshader);
   ASSERT_TRUE(vulkan_implementation_);
   ASSERT_TRUE(vulkan_implementation_->InitializeVulkanInstance());
   device_queue_ = gpu::CreateVulkanDeviceQueue(
@@ -43,7 +48,7 @@ void BasicVulkanTest::SetUp() {
 }
 
 void BasicVulkanTest::TearDown() {
-#if defined(USE_X11)
+#if defined(USE_X11) || defined(OS_WIN)
   DestroyNativeWindow(window_);
 #elif defined(OS_ANDROID)
   ANativeWindow_release(window_);

gpu/vulkan/tests/native_window_win.cc

+// Copyright 2020 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/tests/native_window.h"
+
+#include <windows.h>
+
+#include <memory>
+
+#include "base/containers/flat_map.h"
+#include "ui/gfx/win/window_impl.h"
+
+namespace gpu {
+
+class Window;
+
+base::flat_map<gfx::AcceleratedWidget, std::unique_ptr<Window>> g_windows_;
+
+class Window : public gfx::WindowImpl {
+ public:
+  Window() { set_window_style(WS_VISIBLE | WS_POPUP); }
+  ~Window() override = default;
+
+ private:
+  // Overridden from gfx::WindowImpl:
+  BOOL ProcessWindowMessage(HWND window,
+                            UINT message,
+                            WPARAM w_param,
+                            LPARAM l_param,
+                            LRESULT& result,
+                            DWORD msg_map_id) override {
+    return false;  // Results in DefWindowProc().
+  }
+};
+
+gfx::AcceleratedWidget CreateNativeWindow(const gfx::Rect& bounds) {
+  auto window = std::make_unique<Window>();
+  window->Init(/*parent=*/nullptr, bounds);
+  gfx::AcceleratedWidget widget = window->hwnd();
+  g_windows_[widget] = std::move(window);
+  return widget;
+}
+
+void DestroyNativeWindow(gfx::AcceleratedWidget window) {
+  auto it = g_windows_.find(window);
+  DCHECK(it != g_windows_.end());
+
+  it->second.reset();
+  g_windows_.erase(it);
+}
+
+}  // namespace gpu

gpu/vulkan/vulkan_fence_helper.h

@@ -28,7 +28,7 @@ class VULKAN_EXPORT VulkanFenceHelper {
 
   // Class representing a fence registered with this system. Should be treated
   // as an opaque handle.
-  class FenceHandle {
+  class VULKAN_EXPORT FenceHandle {
    public:
     FenceHandle();
     FenceHandle(const FenceHandle& other);

gpu/vulkan/vulkan_function_pointers.cc

@@ -261,6 +261,29 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
   }
 #endif  // defined(USE_VULKAN_XLIB)
 
+#if defined(OS_WIN)
+  if (gfx::HasExtension(enabled_extensions,
+                        VK_KHR_WIN32_SURFACE_EXTENSION_NAME)) {
+    vkCreateWin32SurfaceKHRFn = reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(
+        vkGetInstanceProcAddr(vk_instance, "vkCreateWin32SurfaceKHR"));
+    if (!vkCreateWin32SurfaceKHRFn) {
+      DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
+                    << "vkCreateWin32SurfaceKHR";
+      return false;
+    }
+
+    vkGetPhysicalDeviceWin32PresentationSupportKHRFn =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>(
+            vkGetInstanceProcAddr(
+                vk_instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
+    if (!vkGetPhysicalDeviceWin32PresentationSupportKHRFn) {
+      DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
+                    << "vkGetPhysicalDeviceWin32PresentationSupportKHR";
+      return false;
+    }
+  }
+#endif  // defined(OS_WIN)
+
 #if defined(OS_ANDROID)
   if (gfx::HasExtension(enabled_extensions,
                         VK_KHR_ANDROID_SURFACE_EXTENSION_NAME)) {

gpu/vulkan/vulkan_function_pointers.h

@@ -36,6 +36,10 @@
 #include <vulkan/vulkan_xlib.h>
 #endif
 
+#if defined(OS_WIN)
+#include <vulkan/vulkan_win32.h>
+#endif
+
 namespace gpu {
 
 struct VulkanFunctionPointers;
@@ -134,6 +138,12 @@ struct VulkanFunctionPointers {
       vkGetPhysicalDeviceXlibPresentationSupportKHRFn;
 #endif  // defined(USE_VULKAN_XLIB)
 
+#if defined(OS_WIN)
+  VulkanFunction<PFN_vkCreateWin32SurfaceKHR> vkCreateWin32SurfaceKHRFn;
+  VulkanFunction<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>
+      vkGetPhysicalDeviceWin32PresentationSupportKHRFn;
+#endif  // defined(OS_WIN)
+
 #if defined(OS_ANDROID)
   VulkanFunction<PFN_vkCreateAndroidSurfaceKHR> vkCreateAndroidSurfaceKHRFn;
 #endif  // defined(OS_ANDROID)
@@ -317,6 +327,14 @@ struct VulkanFunctionPointers {
       ->vkGetPhysicalDeviceXlibPresentationSupportKHRFn
 #endif  // defined(USE_VULKAN_XLIB)
 
+#if defined(OS_WIN)
+#define vkCreateWin32SurfaceKHR \
+  gpu::GetVulkanFunctionPointers()->vkCreateWin32SurfaceKHRFn
+#define vkGetPhysicalDeviceWin32PresentationSupportKHR \
+  gpu::GetVulkanFunctionPointers()                     \
+      ->vkGetPhysicalDeviceWin32PresentationSupportKHRFn
+#endif  // defined(OS_WIN)
+
 #if defined(OS_ANDROID)
 #define vkCreateAndroidSurfaceKHR \
   gpu::GetVulkanFunctionPointers()->vkCreateAndroidSurfaceKHRFn

gpu/vulkan/win32/vulkan_implementation_win32.cc

@@ -17,44 +17,32 @@
 
 namespace gpu {
 
+VulkanImplementationWin32::VulkanImplementationWin32(bool use_swiftshader)
+    : VulkanImplementation(use_swiftshader) {}
+
 VulkanImplementationWin32::~VulkanImplementationWin32() = default;
 
 bool VulkanImplementationWin32::InitializeVulkanInstance(bool using_surface) {
   DCHECK(using_surface);
   std::vector<const char*> required_extensions = {
-      VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME};
+      VK_KHR_SURFACE_EXTENSION_NAME,
+      VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
+  };
 
   VulkanFunctionPointers* vulkan_function_pointers =
       gpu::GetVulkanFunctionPointers();
 
+  base::FilePath path(use_swiftshader() ? L"vk_swiftshader.dll"
+                                        : L"vulkan-1.dll");
+
   base::NativeLibraryLoadError native_library_load_error;
-  vulkan_function_pointers->vulkan_loader_library = base::LoadNativeLibrary(
-      base::FilePath(L"vulkan-1.dll"), &native_library_load_error);
+  vulkan_function_pointers->vulkan_loader_library =
+      base::LoadNativeLibrary(path, &native_library_load_error);
   if (!vulkan_function_pointers->vulkan_loader_library)
     return false;
 
   if (!vulkan_instance_.Initialize(required_extensions, {}))
     return false;
-
-  // Initialize platform function pointers
-  vkGetPhysicalDeviceWin32PresentationSupportKHR_ =
-      reinterpret_cast<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>(
-          vkGetInstanceProcAddr(
-              vulkan_instance_.vk_instance(),
-              "vkGetPhysicalDeviceWin32PresentationSupportKHR"));
-  if (!vkGetPhysicalDeviceWin32PresentationSupportKHR_) {
-    LOG(ERROR) << "vkGetPhysicalDeviceWin32PresentationSupportKHR not found";
-    return false;
-  }
-
-  vkCreateWin32SurfaceKHR_ =
-      reinterpret_cast<PFN_vkCreateWin32SurfaceKHR>(vkGetInstanceProcAddr(
-          vulkan_instance_.vk_instance(), "vkCreateWin32SurfaceKHR"));
-  if (!vkCreateWin32SurfaceKHR_) {
-    LOG(ERROR) << "vkCreateWin32SurfaceKHR not found";
-    return false;
-  }
-
   return true;
 }
 
@@ -70,7 +58,7 @@ std::unique_ptr<VulkanSurface> VulkanImplementationWin32::CreateViewSurface(
   surface_create_info.hinstance =
       reinterpret_cast<HINSTANCE>(GetWindowLongPtr(window, GWLP_HINSTANCE));
   surface_create_info.hwnd = window;
-  VkResult result = vkCreateWin32SurfaceKHR_(
+  VkResult result = vkCreateWin32SurfaceKHR(
       vulkan_instance_.vk_instance(), &surface_create_info, nullptr, &surface);
   if (VK_SUCCESS != result) {
     DLOG(ERROR) << "vkCreatWin32SurfaceKHR() failed: " << result;
@@ -86,13 +74,15 @@ bool VulkanImplementationWin32::GetPhysicalDevicePresentationSupport(
     VkPhysicalDevice device,
     const std::vector<VkQueueFamilyProperties>& queue_family_properties,
     uint32_t queue_family_index) {
-  return vkGetPhysicalDeviceWin32PresentationSupportKHR_(device,
-                                                         queue_family_index);
+  return vkGetPhysicalDeviceWin32PresentationSupportKHR(device,
+                                                        queue_family_index);
 }
 
 std::vector<const char*>
 VulkanImplementationWin32::GetRequiredDeviceExtensions() {
-  return {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
+  return {
+      VK_KHR_SWAPCHAIN_EXTENSION_NAME,
+  };
 }
 
 std::vector<const char*>

gpu/vulkan/win32/vulkan_implementation_win32.h

@@ -5,8 +5,6 @@
 #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"
@@ -16,7 +14,7 @@ namespace gpu {
 class COMPONENT_EXPORT(VULKAN_WIN32) VulkanImplementationWin32
     : public VulkanImplementation {
  public:
-  VulkanImplementationWin32() = default;
+  explicit VulkanImplementationWin32(bool use_swiftshader);
   ~VulkanImplementationWin32() override;
 
   // VulkanImplementation:
@@ -51,10 +49,6 @@ class COMPONENT_EXPORT(VULKAN_WIN32) VulkanImplementationWin32
  private:
   VulkanInstance vulkan_instance_;
 
-  PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR
-      vkGetPhysicalDeviceWin32PresentationSupportKHR_ = nullptr;
-  PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR_ = nullptr;
-
   DISALLOW_COPY_AND_ASSIGN(VulkanImplementationWin32);
 };