Switch from VK_KHR_xlib_surface to VK_KHR_xcb_surface

Chrome is switching to use xcb, so we would like to use
VK_KHR_xcb_surface for vulkan as well.

Bug: 843346,1143750
Change-Id: I9e2e61ca774d04a05d89cd3425ca1bfa8c190fe5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2510437
Commit-Queue: Vasiliy Telezhnikov <vasilyt@chromium.org>
Auto-Submit: Peng Huang <penghuang@chromium.org>
Reviewed-by: Vasiliy Telezhnikov <vasilyt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#822973}

gpu/vulkan/BUILD.gn

@@ -16,11 +16,11 @@ buildflag_header("buildflags") {
 }
 
 if (enable_vulkan) {
-  use_vulkan_xlib = use_x11 || ozone_platform_x11
+  use_vulkan_xcb = use_x11 || ozone_platform_x11
   config("vulkan_config") {
     defines = [ "VK_NO_PROTOTYPES" ]
-    if (use_vulkan_xlib) {
-      defines += [ "USE_VULKAN_XLIB" ]
+    if (use_vulkan_xcb) {
+      defines += [ "USE_VULKAN_XCB" ]
     }
   }
 

gpu/vulkan/generate_bindings.py

@@ -72,11 +72,11 @@ VULKAN_INSTANCE_FUNCTIONS = [
     ]
   },
   {
-    'ifdef': 'defined(USE_VULKAN_XLIB)',
-    'extension': 'VK_KHR_XLIB_SURFACE_EXTENSION_NAME',
+    'ifdef': 'defined(USE_VULKAN_XCB)',
+    'extension': 'VK_KHR_XCB_SURFACE_EXTENSION_NAME',
     'functions': [
-      'vkCreateXlibSurfaceKHR',
-      'vkGetPhysicalDeviceXlibPresentationSupportKHR',
+      'vkCreateXcbSurfaceKHR',
+      'vkGetPhysicalDeviceXcbPresentationSupportKHR',
     ]
   },
   {
@@ -381,11 +381,10 @@ def GenerateHeaderFile(out_file):
 #include "gpu/vulkan/fuchsia/vulkan_fuchsia_ext.h"
 #endif
 
-#if defined(USE_VULKAN_XLIB)
-typedef struct _XDisplay Display;
-typedef unsigned long Window;
-typedef unsigned long VisualID;
-#include <vulkan/vulkan_xlib.h>
+#if defined(USE_VULKAN_XCB)
+#include <xcb/xcb.h>
+// <vulkan/vulkan_xcb.h> must be included after <xcb/xcb.h>
+#include <vulkan/vulkan_xcb.h>
 #endif
 
 #if defined(OS_WIN)

gpu/vulkan/vulkan_function_pointers.cc

@@ -260,28 +260,28 @@ bool VulkanFunctionPointers::BindInstanceFunctionPointers(
     }
   }
 
-#if defined(USE_VULKAN_XLIB)
+#if defined(USE_VULKAN_XCB)
   if (gfx::HasExtension(enabled_extensions,
-                        VK_KHR_XLIB_SURFACE_EXTENSION_NAME)) {
-    vkCreateXlibSurfaceKHR = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(
-        vkGetInstanceProcAddr(vk_instance, "vkCreateXlibSurfaceKHR"));
-    if (!vkCreateXlibSurfaceKHR) {
+                        VK_KHR_XCB_SURFACE_EXTENSION_NAME)) {
+    vkCreateXcbSurfaceKHR = reinterpret_cast<PFN_vkCreateXcbSurfaceKHR>(
+        vkGetInstanceProcAddr(vk_instance, "vkCreateXcbSurfaceKHR"));
+    if (!vkCreateXcbSurfaceKHR) {
       DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
-                    << "vkCreateXlibSurfaceKHR";
+                    << "vkCreateXcbSurfaceKHR";
       return false;
     }
 
-    vkGetPhysicalDeviceXlibPresentationSupportKHR =
-        reinterpret_cast<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>(
+    vkGetPhysicalDeviceXcbPresentationSupportKHR =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR>(
             vkGetInstanceProcAddr(
-                vk_instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
-    if (!vkGetPhysicalDeviceXlibPresentationSupportKHR) {
+                vk_instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR"));
+    if (!vkGetPhysicalDeviceXcbPresentationSupportKHR) {
       DLOG(WARNING) << "Failed to bind vulkan entrypoint: "
-                    << "vkGetPhysicalDeviceXlibPresentationSupportKHR";
+                    << "vkGetPhysicalDeviceXcbPresentationSupportKHR";
       return false;
     }
   }
-#endif  // defined(USE_VULKAN_XLIB)
+#endif  // defined(USE_VULKAN_XCB)
 
 #if defined(OS_WIN)
   if (gfx::HasExtension(enabled_extensions,

gpu/vulkan/vulkan_function_pointers.h

@@ -31,11 +31,10 @@
 #include "gpu/vulkan/fuchsia/vulkan_fuchsia_ext.h"
 #endif
 
-#if defined(USE_VULKAN_XLIB)
-typedef struct _XDisplay Display;
-typedef unsigned long Window;
-typedef unsigned long VisualID;
-#include <vulkan/vulkan_xlib.h>
+#if defined(USE_VULKAN_XCB)
+#include <xcb/xcb.h>
+// <vulkan/vulkan_xcb.h> must be included after <xcb/xcb.h>
+#include <vulkan/vulkan_xcb.h>
 #endif
 
 #if defined(OS_WIN)
@@ -142,11 +141,11 @@ struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
   VulkanFunction<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>
       vkGetPhysicalDeviceSurfaceSupportKHR;
 
-#if defined(USE_VULKAN_XLIB)
-  VulkanFunction<PFN_vkCreateXlibSurfaceKHR> vkCreateXlibSurfaceKHR;
-  VulkanFunction<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>
-      vkGetPhysicalDeviceXlibPresentationSupportKHR;
-#endif  // defined(USE_VULKAN_XLIB)
+#if defined(USE_VULKAN_XCB)
+  VulkanFunction<PFN_vkCreateXcbSurfaceKHR> vkCreateXcbSurfaceKHR;
+  VulkanFunction<PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR>
+      vkGetPhysicalDeviceXcbPresentationSupportKHR;
+#endif  // defined(USE_VULKAN_XCB)
 
 #if defined(OS_WIN)
   VulkanFunction<PFN_vkCreateWin32SurfaceKHR> vkCreateWin32SurfaceKHR;
@@ -459,25 +458,25 @@ vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
       physicalDevice, queueFamilyIndex, surface, pSupported);
 }
 
-#if defined(USE_VULKAN_XLIB)
+#if defined(USE_VULKAN_XCB)
 ALWAYS_INLINE VkResult
-vkCreateXlibSurfaceKHR(VkInstance instance,
-                       const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
-                       const VkAllocationCallbacks* pAllocator,
-                       VkSurfaceKHR* pSurface) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateXlibSurfaceKHR(
+vkCreateXcbSurfaceKHR(VkInstance instance,
+                      const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+                      const VkAllocationCallbacks* pAllocator,
+                      VkSurfaceKHR* pSurface) {
+  return gpu::GetVulkanFunctionPointers()->vkCreateXcbSurfaceKHR(
       instance, pCreateInfo, pAllocator, pSurface);
 }
 ALWAYS_INLINE VkBool32
-vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                              uint32_t queueFamilyIndex,
-                                              Display* dpy,
-                                              VisualID visualID) {
+vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                             uint32_t queueFamilyIndex,
+                                             xcb_connection_t* connection,
+                                             xcb_visualid_t visual_id) {
   return gpu::GetVulkanFunctionPointers()
-      ->vkGetPhysicalDeviceXlibPresentationSupportKHR(
-          physicalDevice, queueFamilyIndex, dpy, visualID);
+      ->vkGetPhysicalDeviceXcbPresentationSupportKHR(
+          physicalDevice, queueFamilyIndex, connection, visual_id);
 }
-#endif  // defined(USE_VULKAN_XLIB)
+#endif  // defined(USE_VULKAN_XCB)
 
 #if defined(OS_WIN)
 ALWAYS_INLINE VkResult

gpu/vulkan/vulkan_instance.cc

@@ -177,31 +177,6 @@ bool VulkanInstance::Initialize(
     return false;
   }
 
-  gfx::ExtensionSet enabled_extensions(
-      std::begin(vulkan_info_.enabled_instance_extensions),
-      std::end(vulkan_info_.enabled_instance_extensions));
-
-#if DCHECK_IS_ON()
-  // TODO(crbug.com/843346): Make validation work in combination with
-  // VK_KHR_xlib_surface or switch to VK_KHR_xcb_surface.
-  bool require_xlib_surface_extension =
-      gfx::HasExtension(enabled_extensions, "VK_KHR_xlib_surface");
-
-  // VK_LAYER_KHRONOS_validation 1.1.106 is required to support
-  // VK_KHR_xlib_surface.
-  constexpr base::StringPiece standard_validation(
-      "VK_LAYER_KHRONOS_validation");
-  for (const VkLayerProperties& layer_property : vulkan_info_.instance_layers) {
-    if (standard_validation != layer_property.layerName)
-      continue;
-    if (!require_xlib_surface_extension ||
-        layer_property.specVersion >= VK_MAKE_VERSION(1, 1, 106)) {
-      enabled_layer_names.push_back(standard_validation.data());
-    }
-    break;
-  }
-#endif  // DCHECK_IS_ON()
-
   VkInstanceCreateInfo instance_create_info = {
       VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,           // sType
       nullptr,                                          // pNext
@@ -220,6 +195,10 @@ bool VulkanInstance::Initialize(
     return false;
   }
 
+  gfx::ExtensionSet enabled_extensions(
+      std::begin(vulkan_info_.enabled_instance_extensions),
+      std::end(vulkan_info_.enabled_instance_extensions));
+
   if (!vulkan_function_pointers->BindInstanceFunctionPointers(
           vk_instance_, vulkan_info_.used_api_version, enabled_extensions)) {
     return false;

gpu/vulkan/x/vulkan_implementation_x11.cc

@@ -58,7 +58,7 @@ bool VulkanImplementationX11::InitializeVulkanInstance(bool using_surface) {
       VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME};
   if (using_surface_) {
     required_extensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
-    required_extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
+    required_extensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
   }
 
   VulkanFunctionPointers* vulkan_function_pointers =
@@ -103,9 +103,9 @@ bool VulkanImplementationX11::GetPhysicalDevicePresentationSupport(
   if (use_swiftshader())
     return true;
   auto* connection = x11::Connection::Get();
-  return vkGetPhysicalDeviceXlibPresentationSupportKHR(
-      device, queue_family_index, connection->GetXlibDisplay(),
-      static_cast<VisualID>(connection->default_root_visual().visual_id));
+  return vkGetPhysicalDeviceXcbPresentationSupportKHR(
+      device, queue_family_index, connection->XcbConnection(),
+      static_cast<xcb_visualid_t>(connection->default_root_visual().visual_id));
 }
 
 std::vector<const char*>

gpu/vulkan/x/vulkan_surface_x11.cc

@@ -69,16 +69,20 @@ std::unique_ptr<VulkanSurfaceX11> VulkanSurfaceX11::Create(
     LOG(ERROR) << "Failed to create or map window.";
     return nullptr;
   }
+  // Flush the connection, otherwise other Vulkan WSI calls may fail with some
+  // drivers.
+  connection->Flush();
 
   VkSurfaceKHR vk_surface;
-  VkXlibSurfaceCreateInfoKHR surface_create_info = {
-      VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR};
-  surface_create_info.dpy = connection->GetXlibDisplay();
-  surface_create_info.window = static_cast<uint32_t>(window);
-  VkResult result = vkCreateXlibSurfaceKHR(vk_instance, &surface_create_info,
-                                           nullptr, &vk_surface);
+  const VkXcbSurfaceCreateInfoKHR surface_create_info = {
+      .sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
+      .connection = connection->XcbConnection(),
+      .window = static_cast<xcb_window_t>(window),
+  };
+  VkResult result = vkCreateXcbSurfaceKHR(vk_instance, &surface_create_info,
+                                          nullptr, &vk_surface);
   if (VK_SUCCESS != result) {
-    DLOG(ERROR) << "vkCreateXlibSurfaceKHR() failed: " << result;
+    DLOG(ERROR) << "vkCreateXcbSurfaceKHR() failed: " << result;
     return nullptr;
   }
   return std::make_unique<VulkanSurfaceX11>(vk_instance, vk_surface,