gpu: vulkan: Allow initializing without VK_KHR_surface

Chrome OS does not have the VK_KHR_surface or VK_KHR_swapchain
extensions. Move them to implementation specific code to allow
initialization of vulkan on Chrome OS.

Bug: 851997
Test: vulkan ozone_demo on linux x11

Change-Id: I5355a1f7e6d5215b98aba2defc8e4d631f6a964e
Reviewed-on: https://chromium-review.googlesource.com/1104860
Commit-Queue: Michael Spang <spang@chromium.org>
Reviewed-by: Chris Blume <cblume@chromium.org>
Reviewed-by: Antoine Labour <piman@chromium.org>
Reviewed-by: Robert Kroeger <rjkroege@chromium.org>
Cr-Commit-Position: refs/heads/master@{#569416}

gpu/vulkan/generate_bindings.py

@@ -12,7 +12,6 @@ import sys
 from subprocess import call
 
 VULKAN_DEVICE_FUNCTIONS = [
-{ 'name': 'vkAcquireNextImageKHR' },
 { 'name': 'vkAllocateCommandBuffers' },
 { 'name': 'vkAllocateDescriptorSets' },
 { 'name': 'vkCreateCommandPool' },
@@ -25,7 +24,6 @@ VULKAN_DEVICE_FUNCTIONS = [
 { 'name': 'vkCreateSampler' },
 { 'name': 'vkCreateSemaphore' },
 { 'name': 'vkCreateShaderModule' },
-{ 'name': 'vkCreateSwapchainKHR' },
 { 'name': 'vkDestroyCommandPool' },
 { 'name': 'vkDestroyDescriptorPool' },
 { 'name': 'vkDestroyDescriptorSetLayout' },
@@ -37,19 +35,16 @@ VULKAN_DEVICE_FUNCTIONS = [
 { 'name': 'vkDestroySampler' },
 { 'name': 'vkDestroySemaphore' },
 { 'name': 'vkDestroyShaderModule' },
-{ 'name': 'vkDestroySwapchainKHR' },
 { 'name': 'vkFreeCommandBuffers' },
 { 'name': 'vkFreeDescriptorSets' },
 { 'name': 'vkGetDeviceQueue' },
 { 'name': 'vkGetFenceStatus' },
-{ 'name': 'vkGetSwapchainImagesKHR' },
 { 'name': 'vkResetFences' },
 { 'name': 'vkUpdateDescriptorSets' },
 { 'name': 'vkWaitForFences' },
 ]
 
 VULKAN_QUEUE_FUNCTIONS = [
-{ 'name': 'vkQueuePresentKHR' },
 { 'name': 'vkQueueSubmit' },
 { 'name': 'vkQueueWaitIdle' },
 ]
@@ -65,6 +60,14 @@ VULKAN_COMMAND_BUFFER_FUNCTIONS = [
 { 'name': 'vkResetCommandBuffer' },
 ]
 
+VULKAN_SWAPCHAIN_FUNCTIONS = [
+{ 'name': 'vkAcquireNextImageKHR' },
+{ 'name': 'vkCreateSwapchainKHR' },
+{ 'name': 'vkDestroySwapchainKHR' },
+{ 'name': 'vkGetSwapchainImagesKHR' },
+{ 'name': 'vkQueuePresentKHR' },
+]
+
 SELF_LOCATION = os.path.dirname(os.path.abspath(__file__))
 
 LICENSE_AND_HEADER = """\
@@ -81,7 +84,7 @@ LICENSE_AND_HEADER = """\
 """
 
 def GenerateHeaderFile(file, device_functions, queue_functions,
-                       command_buffer_functions):
+                       command_buffer_functions, swapchain_functions):
   """Generates gpu/vulkan/vulkan_function_pointers.h"""
 
   file.write(LICENSE_AND_HEADER +
@@ -105,8 +108,9 @@ struct VulkanFunctionPointers {
   VulkanFunctionPointers();
   ~VulkanFunctionPointers();
 
-  // This function assumes that vkGetDeviceProcAddr has been populated.
+  // These functions assume that vkGetDeviceProcAddr has been populated.
   bool BindDeviceFunctionPointers(VkDevice vk_device);
+  bool BindSwapchainFunctionPointers(VkDevice vk_device);
 
   base::NativeLibrary vulkan_loader_library_ = nullptr;
 
@@ -159,15 +163,19 @@ struct VulkanFunctionPointers {
   for func in command_buffer_functions:
     file.write('  PFN_' + func['name'] + ' ' + func['name'] + ' = nullptr;\n')
 
+  for func in swapchain_functions:
+    file.write('  PFN_' + func['name'] + ' ' + func['name'] + ' = nullptr;\n')
+
   file.write("""\
 };
 
 }  // namespace gpu
 
-#endif  // GPU_VULKAN_VULKAN_FUNCTION_POINTERS_H_""")
+#endif  // GPU_VULKAN_VULKAN_FUNCTION_POINTERS_H_
+""")
 
 def GenerateSourceFile(file, device_functions, queue_functions,
-                       command_buffer_functions):
+                       command_buffer_functions, swapchain_functions):
   """Generates gpu/vulkan/vulkan_function_pointers.cc"""
 
   file.write(LICENSE_AND_HEADER +
@@ -223,7 +231,23 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(VkDevice vk_device) {
   return true;
 }
 
-}  // namespace gpu""")
+bool VulkanFunctionPointers::BindSwapchainFunctionPointers(VkDevice vk_device) {
+""")
+
+  for func in swapchain_functions:
+    file.write('  ' + func['name'] + ' = reinterpret_cast<PFN_' + func['name'] +
+      '>(vkGetDeviceProcAddr(vk_device, "' + func['name'] + '"));\n')
+    file.write('  if (!' + func['name'] + ')\n')
+    file.write('    return false;\n\n')
+
+  file.write("""\
+
+
+  return true;
+}
+
+}  // namespace gpu
+""")
 
 def main(argv):
   """This is the main function."""
@@ -244,14 +268,16 @@ def main(argv):
   header_file = open(
       os.path.join(directory, 'vulkan_function_pointers.h'), 'wb')
   GenerateHeaderFile(header_file, VULKAN_DEVICE_FUNCTIONS,
-                     VULKAN_QUEUE_FUNCTIONS, VULKAN_COMMAND_BUFFER_FUNCTIONS)
+                     VULKAN_QUEUE_FUNCTIONS, VULKAN_COMMAND_BUFFER_FUNCTIONS,
+                     VULKAN_SWAPCHAIN_FUNCTIONS)
   header_file.close()
   ClangFormat(header_file.name)
 
   source_file = open(
       os.path.join(directory, 'vulkan_function_pointers.cc'), 'wb')
   GenerateSourceFile(source_file, VULKAN_DEVICE_FUNCTIONS,
-                     VULKAN_QUEUE_FUNCTIONS, VULKAN_COMMAND_BUFFER_FUNCTIONS)
+                     VULKAN_QUEUE_FUNCTIONS, VULKAN_COMMAND_BUFFER_FUNCTIONS,
+                     VULKAN_SWAPCHAIN_FUNCTIONS)
   source_file.close()
   ClangFormat(source_file.name)
 

gpu/vulkan/vulkan_device_queue.cc

@@ -23,6 +23,7 @@ VulkanDeviceQueue::~VulkanDeviceQueue() {
 
 bool VulkanDeviceQueue::Initialize(
     uint32_t options,
+    const std::vector<const char*>& required_extensions,
     const GetPresentationSupportCallback& get_presentation_support) {
   VulkanFunctionPointers* vulkan_function_pointers =
       gpu::GetVulkanFunctionPointers();
@@ -94,8 +95,6 @@ bool VulkanDeviceQueue::Initialize(
   queue_create_info.queueCount = 1;
   queue_create_info.pQueuePriorities = &queue_priority;
 
-  const char* device_extensions[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
-
   std::vector<const char*> enabled_layer_names;
 #if DCHECK_IS_ON()
   uint32_t num_device_layers = 0;
@@ -125,22 +124,33 @@ bool VulkanDeviceQueue::Initialize(
   }
 #endif
 
+  std::vector<const char*> enabled_extensions;
+  enabled_extensions.insert(std::end(enabled_extensions),
+                            std::begin(required_extensions),
+                            std::end(required_extensions));
+
   VkDeviceCreateInfo device_create_info = {};
   device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
   device_create_info.queueCreateInfoCount = 1;
   device_create_info.pQueueCreateInfos = &queue_create_info;
   device_create_info.enabledLayerCount = enabled_layer_names.size();
   device_create_info.ppEnabledLayerNames = enabled_layer_names.data();
-  device_create_info.enabledExtensionCount = arraysize(device_extensions);
-  device_create_info.ppEnabledExtensionNames = device_extensions;
+  device_create_info.enabledExtensionCount = enabled_extensions.size();
+  device_create_info.ppEnabledExtensionNames = enabled_extensions.data();
 
   result = vulkan_function_pointers->vkCreateDevice(
       vk_physical_device_, &device_create_info, nullptr, &vk_device_);
   if (VK_SUCCESS != result)
     return false;
 
+  enabled_extensions_ = gfx::ExtensionSet(std::begin(enabled_extensions),
+                                          std::end(enabled_extensions));
+
   vulkan_function_pointers->BindDeviceFunctionPointers(vk_device_);
 
+  if (gfx::HasExtension(enabled_extensions_, VK_KHR_SWAPCHAIN_EXTENSION_NAME))
+    vulkan_function_pointers->BindSwapchainFunctionPointers(vk_device_);
+
   vulkan_function_pointers->vkGetDeviceQueue(vk_device_, queue_index, 0,
                                              &vk_queue_);
 

gpu/vulkan/vulkan_device_queue.h

@@ -13,6 +13,7 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "gpu/vulkan/vulkan_export.h"
+#include "ui/gfx/extension_set.h"
 
 namespace gpu {
 
@@ -34,8 +35,13 @@ class VULKAN_EXPORT VulkanDeviceQueue {
                                    uint32_t queue_family_index)>;
   bool Initialize(
       uint32_t options,
+      const std::vector<const char*>& required_extensions,
       const GetPresentationSupportCallback& get_presentation_support);
 
+  const gfx::ExtensionSet& enabled_extensions() const {
+    return enabled_extensions_;
+  }
+
   void Destroy();
 
   VkPhysicalDevice GetVulkanPhysicalDevice() const {
@@ -61,6 +67,7 @@ class VULKAN_EXPORT VulkanDeviceQueue {
   std::unique_ptr<gpu::VulkanCommandPool> CreateCommandPool();
 
  private:
+  gfx::ExtensionSet enabled_extensions_;
   VkPhysicalDevice vk_physical_device_ = VK_NULL_HANDLE;
   VkDevice vk_device_ = VK_NULL_HANDLE;
   VkQueue vk_queue_ = VK_NULL_HANDLE;

gpu/vulkan/vulkan_function_pointers.cc

@@ -24,11 +24,6 @@ VulkanFunctionPointers::~VulkanFunctionPointers() = default;
 
 bool VulkanFunctionPointers::BindDeviceFunctionPointers(VkDevice vk_device) {
   // Device functions
-  vkAcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(
-      vkGetDeviceProcAddr(vk_device, "vkAcquireNextImageKHR"));
-  if (!vkAcquireNextImageKHR)
-    return false;
-
   vkAllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(
       vkGetDeviceProcAddr(vk_device, "vkAllocateCommandBuffers"));
   if (!vkAllocateCommandBuffers)
@@ -90,11 +85,6 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(VkDevice vk_device) {
   if (!vkCreateShaderModule)
     return false;
 
-  vkCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(
-      vkGetDeviceProcAddr(vk_device, "vkCreateSwapchainKHR"));
-  if (!vkCreateSwapchainKHR)
-    return false;
-
   vkDestroyCommandPool = reinterpret_cast<PFN_vkDestroyCommandPool>(
       vkGetDeviceProcAddr(vk_device, "vkDestroyCommandPool"));
   if (!vkDestroyCommandPool)
@@ -151,11 +141,6 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(VkDevice vk_device) {
   if (!vkDestroyShaderModule)
     return false;
 
-  vkDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(
-      vkGetDeviceProcAddr(vk_device, "vkDestroySwapchainKHR"));
-  if (!vkDestroySwapchainKHR)
-    return false;
-
   vkFreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(
       vkGetDeviceProcAddr(vk_device, "vkFreeCommandBuffers"));
   if (!vkFreeCommandBuffers)
@@ -176,11 +161,6 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(VkDevice vk_device) {
   if (!vkGetFenceStatus)
     return false;
 
-  vkGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(
-      vkGetDeviceProcAddr(vk_device, "vkGetSwapchainImagesKHR"));
-  if (!vkGetSwapchainImagesKHR)
-    return false;
-
   vkResetFences = reinterpret_cast<PFN_vkResetFences>(
       vkGetDeviceProcAddr(vk_device, "vkResetFences"));
   if (!vkResetFences)
@@ -197,11 +177,6 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(VkDevice vk_device) {
     return false;
 
   // Queue functions
-  vkQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(
-      vkGetDeviceProcAddr(vk_device, "vkQueuePresentKHR"));
-  if (!vkQueuePresentKHR)
-    return false;
-
   vkQueueSubmit = reinterpret_cast<PFN_vkQueueSubmit>(
       vkGetDeviceProcAddr(vk_device, "vkQueueSubmit"));
   if (!vkQueueSubmit)
@@ -256,4 +231,33 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers(VkDevice vk_device) {
   return true;
 }
 
-}  // namespace gpu
\ No newline at end of file
+bool VulkanFunctionPointers::BindSwapchainFunctionPointers(VkDevice vk_device) {
+  vkAcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(
+      vkGetDeviceProcAddr(vk_device, "vkAcquireNextImageKHR"));
+  if (!vkAcquireNextImageKHR)
+    return false;
+
+  vkCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(
+      vkGetDeviceProcAddr(vk_device, "vkCreateSwapchainKHR"));
+  if (!vkCreateSwapchainKHR)
+    return false;
+
+  vkDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(
+      vkGetDeviceProcAddr(vk_device, "vkDestroySwapchainKHR"));
+  if (!vkDestroySwapchainKHR)
+    return false;
+
+  vkGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(
+      vkGetDeviceProcAddr(vk_device, "vkGetSwapchainImagesKHR"));
+  if (!vkGetSwapchainImagesKHR)
+    return false;
+
+  vkQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(
+      vkGetDeviceProcAddr(vk_device, "vkQueuePresentKHR"));
+  if (!vkQueuePresentKHR)
+    return false;
+
+  return true;
+}
+
+}  // namespace gpu

gpu/vulkan/vulkan_function_pointers.h

@@ -26,8 +26,9 @@ struct VulkanFunctionPointers {
   VulkanFunctionPointers();
   ~VulkanFunctionPointers();
 
-  // This function assumes that vkGetDeviceProcAddr has been populated.
+  // These functions assume that vkGetDeviceProcAddr has been populated.
   bool BindDeviceFunctionPointers(VkDevice vk_device);
+  bool BindSwapchainFunctionPointers(VkDevice vk_device);
 
   base::NativeLibrary vulkan_loader_library_ = nullptr;
 
@@ -59,7 +60,6 @@ struct VulkanFunctionPointers {
       vkGetPhysicalDeviceSurfaceCapabilitiesKHR = nullptr;
 
   // Device functions
-  PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = nullptr;
   PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = nullptr;
   PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = nullptr;
   PFN_vkCreateCommandPool vkCreateCommandPool = nullptr;
@@ -72,7 +72,6 @@ struct VulkanFunctionPointers {
   PFN_vkCreateSampler vkCreateSampler = nullptr;
   PFN_vkCreateSemaphore vkCreateSemaphore = nullptr;
   PFN_vkCreateShaderModule vkCreateShaderModule = nullptr;
-  PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = nullptr;
   PFN_vkDestroyCommandPool vkDestroyCommandPool = nullptr;
   PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = nullptr;
   PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = nullptr;
@@ -84,18 +83,15 @@ struct VulkanFunctionPointers {
   PFN_vkDestroySampler vkDestroySampler = nullptr;
   PFN_vkDestroySemaphore vkDestroySemaphore = nullptr;
   PFN_vkDestroyShaderModule vkDestroyShaderModule = nullptr;
-  PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = nullptr;
   PFN_vkFreeCommandBuffers vkFreeCommandBuffers = nullptr;
   PFN_vkFreeDescriptorSets vkFreeDescriptorSets = nullptr;
   PFN_vkGetDeviceQueue vkGetDeviceQueue = nullptr;
   PFN_vkGetFenceStatus vkGetFenceStatus = nullptr;
-  PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = nullptr;
   PFN_vkResetFences vkResetFences = nullptr;
   PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = nullptr;
   PFN_vkWaitForFences vkWaitForFences = nullptr;
 
   // Queue functions
-  PFN_vkQueuePresentKHR vkQueuePresentKHR = nullptr;
   PFN_vkQueueSubmit vkQueueSubmit = nullptr;
   PFN_vkQueueWaitIdle vkQueueWaitIdle = nullptr;
 
@@ -108,8 +104,13 @@ struct VulkanFunctionPointers {
   PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = nullptr;
   PFN_vkEndCommandBuffer vkEndCommandBuffer = nullptr;
   PFN_vkResetCommandBuffer vkResetCommandBuffer = nullptr;
+  PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = nullptr;
+  PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = nullptr;
+  PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = nullptr;
+  PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = nullptr;
+  PFN_vkQueuePresentKHR vkQueuePresentKHR = nullptr;
 };
 
 }  // namespace gpu
 
-#endif  // GPU_VULKAN_VULKAN_FUNCTION_POINTERS_H_
\ No newline at end of file
+#endif  // GPU_VULKAN_VULKAN_FUNCTION_POINTERS_H_

gpu/vulkan/vulkan_implementation.cc

@@ -21,7 +21,10 @@ std::unique_ptr<VulkanDeviceQueue> CreateVulkanDeviceQueue(
   auto callback = base::BindRepeating(
       &VulkanImplementation::GetPhysicalDevicePresentationSupport,
       base::Unretained(vulkan_implementation));
-  if (!device_queue->Initialize(option, callback)) {
+  std::vector<const char*> required_extensions =
+      vulkan_implementation->GetRequiredDeviceExtensions();
+  if (!device_queue->Initialize(option, std::move(required_extensions),
+                                callback)) {
     device_queue->Destroy();
     return nullptr;
   }

gpu/vulkan/vulkan_implementation.h

@@ -37,6 +37,8 @@ class VULKAN_EXPORT VulkanImplementation {
       const std::vector<VkQueueFamilyProperties>& queue_family_properties,
       uint32_t queue_family_index) = 0;
 
+  virtual std::vector<const char*> GetRequiredDeviceExtensions() = 0;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(VulkanImplementation);
 };

gpu/vulkan/vulkan_implementation_android.cc

@@ -16,8 +16,8 @@ VulkanImplementationAndroid::VulkanImplementationAndroid() {}
 VulkanImplementationAndroid::~VulkanImplementationAndroid() {}
 
 bool VulkanImplementationAndroid::InitializeVulkanInstance() {
-  std::vector<const char*> required_extensions;
-  required_extensions.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
+  std::vector<const char*> required_extensions = {
+      VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_ANDROID_SURFACE_EXTENSION_NAME};
 
   VulkanFunctionPointers* vulkan_function_pointers =
       gpu::GetVulkanFunctionPointers();
@@ -78,4 +78,9 @@ bool VulkanImplementationAndroid::GetPhysicalDevicePresentationSupport(
   return true;
 }
 
+std::vector<const char*>
+VulkanImplementationAndroid::GetRequiredDeviceExtensions() {
+  return {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
+}
+
 }  // namespace gpu

gpu/vulkan/vulkan_implementation_android.h

@@ -28,6 +28,7 @@ class VULKAN_EXPORT VulkanImplementationAndroid : public VulkanImplementation {
       VkPhysicalDevice device,
       const std::vector<VkQueueFamilyProperties>& queue_family_properties,
       uint32_t queue_family_index) override;
+  std::vector<const char*> GetRequiredDeviceExtensions() override;
 
  private:
   VulkanInstance vulkan_instance_;

gpu/vulkan/vulkan_instance.cc

@@ -88,11 +88,10 @@ bool VulkanInstance::Initialize(
   app_info.pApplicationName = "Chromium";
   app_info.apiVersion = VK_MAKE_VERSION(1, 0, 2);
 
-  std::vector<const char*> enabled_ext_names;
-  enabled_ext_names.push_back(VK_KHR_SURFACE_EXTENSION_NAME);
-  enabled_ext_names.insert(std::end(enabled_ext_names),
-                           std::begin(required_extensions),
-                           std::end(required_extensions));
+  std::vector<const char*> enabled_extensions;
+  enabled_extensions.insert(std::end(enabled_extensions),
+                            std::begin(required_extensions),
+                            std::end(required_extensions));
 
   uint32_t num_instance_exts = 0;
   result = vulkan_function_pointers->vkEnumerateInstanceExtensionProperties(
@@ -116,7 +115,7 @@ bool VulkanInstance::Initialize(
     if (strcmp(ext_property.extensionName,
                VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) {
       debug_report_enabled_ = true;
-      enabled_ext_names.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
+      enabled_extensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
     }
   }
 
@@ -158,8 +157,8 @@ bool VulkanInstance::Initialize(
   instance_create_info.pApplicationInfo = &app_info;
   instance_create_info.enabledLayerCount = enabled_layer_names.size();
   instance_create_info.ppEnabledLayerNames = enabled_layer_names.data();
-  instance_create_info.enabledExtensionCount = enabled_ext_names.size();
-  instance_create_info.ppEnabledExtensionNames = enabled_ext_names.data();
+  instance_create_info.enabledExtensionCount = enabled_extensions.size();
+  instance_create_info.ppEnabledExtensionNames = enabled_extensions.data();
 
   result = vulkan_function_pointers->vkCreateInstance(&instance_create_info,
                                                       nullptr, &vk_instance_);
@@ -168,6 +167,9 @@ bool VulkanInstance::Initialize(
     return false;
   }
 
+  enabled_extensions_ = gfx::ExtensionSet(std::begin(enabled_extensions),
+                                          std::end(enabled_extensions));
+
 #if DCHECK_IS_ON()
   // Register our error logging function.
   if (debug_report_enabled_) {
@@ -215,13 +217,6 @@ bool VulkanInstance::Initialize(
   if (!vulkan_function_pointers->vkDestroyInstance)
     return false;
 
-  vulkan_function_pointers->vkDestroySurfaceKHR =
-      reinterpret_cast<PFN_vkDestroySurfaceKHR>(
-          vulkan_function_pointers->vkGetInstanceProcAddr(
-              vk_instance_, "vkDestroySurfaceKHR"));
-  if (!vulkan_function_pointers->vkDestroySurfaceKHR)
-    return false;
-
   vulkan_function_pointers->vkEnumerateDeviceLayerProperties =
       reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(
           vulkan_function_pointers->vkGetInstanceProcAddr(
@@ -250,26 +245,35 @@ bool VulkanInstance::Initialize(
   if (!vulkan_function_pointers->vkGetPhysicalDeviceQueueFamilyProperties)
     return false;
 
-  vulkan_function_pointers->vkGetPhysicalDeviceSurfaceCapabilitiesKHR =
-      reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(
-          vulkan_function_pointers->vkGetInstanceProcAddr(
-              vk_instance_, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
-  if (!vulkan_function_pointers->vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
-    return false;
+  if (gfx::HasExtension(enabled_extensions_, VK_KHR_SURFACE_EXTENSION_NAME)) {
+    vulkan_function_pointers->vkDestroySurfaceKHR =
+        reinterpret_cast<PFN_vkDestroySurfaceKHR>(
+            vulkan_function_pointers->vkGetInstanceProcAddr(
+                vk_instance_, "vkDestroySurfaceKHR"));
+    if (!vulkan_function_pointers->vkDestroySurfaceKHR)
+      return false;
 
-  vulkan_function_pointers->vkGetPhysicalDeviceSurfaceFormatsKHR =
-      reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(
-          vulkan_function_pointers->vkGetInstanceProcAddr(
-              vk_instance_, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
-  if (!vulkan_function_pointers->vkGetPhysicalDeviceSurfaceFormatsKHR)
-    return false;
+    vulkan_function_pointers->vkGetPhysicalDeviceSurfaceCapabilitiesKHR =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(
+            vulkan_function_pointers->vkGetInstanceProcAddr(
+                vk_instance_, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
+    if (!vulkan_function_pointers->vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
+      return false;
 
-  vulkan_function_pointers->vkGetPhysicalDeviceSurfaceSupportKHR =
-      reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(
-          vulkan_function_pointers->vkGetInstanceProcAddr(
-              vk_instance_, "vkGetPhysicalDeviceSurfaceSupportKHR"));
-  if (!vulkan_function_pointers->vkGetPhysicalDeviceSurfaceSupportKHR)
-    return false;
+    vulkan_function_pointers->vkGetPhysicalDeviceSurfaceFormatsKHR =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(
+            vulkan_function_pointers->vkGetInstanceProcAddr(
+                vk_instance_, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
+    if (!vulkan_function_pointers->vkGetPhysicalDeviceSurfaceFormatsKHR)
+      return false;
+
+    vulkan_function_pointers->vkGetPhysicalDeviceSurfaceSupportKHR =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(
+            vulkan_function_pointers->vkGetInstanceProcAddr(
+                vk_instance_, "vkGetPhysicalDeviceSurfaceSupportKHR"));
+    if (!vulkan_function_pointers->vkGetPhysicalDeviceSurfaceSupportKHR)
+      return false;
+  }
 
   return true;
 }

gpu/vulkan/vulkan_instance.h

@@ -11,6 +11,7 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "gpu/vulkan/vulkan_export.h"
+#include "ui/gfx/extension_set.h"
 
 namespace gpu {
 
@@ -24,10 +25,15 @@ class VULKAN_EXPORT VulkanInstance {
 
   void Destroy();
 
+  const gfx::ExtensionSet& enabled_extensions() const {
+    return enabled_extensions_;
+  }
+
   VkInstance vk_instance() { return vk_instance_; }
 
  private:
   VkInstance vk_instance_ = VK_NULL_HANDLE;
+  gfx::ExtensionSet enabled_extensions_;
   bool debug_report_enabled_ = false;
 #if DCHECK_IS_ON()
   VkDebugReportCallbackEXT error_callback_ = VK_NULL_HANDLE;

gpu/vulkan/x/vulkan_implementation_x11.cc

@@ -21,8 +21,8 @@ VulkanImplementationX11::VulkanImplementationX11(XDisplay* x_display)
 VulkanImplementationX11::~VulkanImplementationX11() {}
 
 bool VulkanImplementationX11::InitializeVulkanInstance() {
-  std::vector<const char*> required_extensions;
-  required_extensions.push_back(VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
+  std::vector<const char*> required_extensions = {
+      VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XLIB_SURFACE_EXTENSION_NAME};
 
   VulkanFunctionPointers* vulkan_function_pointers =
       gpu::GetVulkanFunctionPointers();
@@ -91,4 +91,9 @@ bool VulkanImplementationX11::GetPhysicalDevicePresentationSupport(
           DefaultVisual(x_display_, DefaultScreen(x_display_))));
 }
 
+std::vector<const char*>
+VulkanImplementationX11::GetRequiredDeviceExtensions() {
+  return {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
+}
+
 }  // namespace gpu

gpu/vulkan/x/vulkan_implementation_x11.h

@@ -30,6 +30,7 @@ class COMPONENT_EXPORT(VULKAN_X11) VulkanImplementationX11
       VkPhysicalDevice device,
       const std::vector<VkQueueFamilyProperties>& queue_family_properties,
       uint32_t queue_family_index) override;
+  std::vector<const char*> GetRequiredDeviceExtensions() override;
 
  private:
   XDisplay* const x_display_;