BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

1 files changed, 306 insertions, 304 deletions

diff --git a/chromium/gpu/vulkan/vulkan_function_pointers.h b/chromium/gpu/vulkan/vulkan_function_pointers.h
index cd696ce9963..9d9682c2976 100644
--- a/chromium/gpu/vulkan/vulkan_function_pointers.h
+++ b/chromium/gpu/vulkan/vulkan_function_pointers.h
@@ -44,6 +44,8 @@ namespace gpu {
 
 struct VulkanFunctionPointers;
 
+constexpr uint32_t kVulkanRequiredApiVersion = VK_API_VERSION_1_1;
+
 COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers* GetVulkanFunctionPointers();
 
 struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
@@ -72,10 +74,10 @@ struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
    public:
     using Fn = R(VKAPI_PTR*)(Args...);
 
-    explicit operator bool() { return !!fn_; }
+    explicit operator bool() const { return !!fn_; }
 
     NO_SANITIZE("cfi-icall")
-    R operator()(Args... args) { return fn_(args...); }
+    R operator()(Args... args) const { return fn_(args...); }
 
     Fn get() const { return fn_; }
 
@@ -91,201 +93,197 @@ struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
   };
 
   // Unassociated functions
-  VulkanFunction<PFN_vkEnumerateInstanceVersion> vkEnumerateInstanceVersionFn;
-  VulkanFunction<PFN_vkGetInstanceProcAddr> vkGetInstanceProcAddrFn;
+  VulkanFunction<PFN_vkGetInstanceProcAddr> vkGetInstanceProcAddr;
 
-  VulkanFunction<PFN_vkCreateInstance> vkCreateInstanceFn;
+  VulkanFunction<PFN_vkEnumerateInstanceVersion> vkEnumerateInstanceVersion;
+  VulkanFunction<PFN_vkCreateInstance> vkCreateInstance;
   VulkanFunction<PFN_vkEnumerateInstanceExtensionProperties>
-      vkEnumerateInstanceExtensionPropertiesFn;
+      vkEnumerateInstanceExtensionProperties;
   VulkanFunction<PFN_vkEnumerateInstanceLayerProperties>
-      vkEnumerateInstanceLayerPropertiesFn;
+      vkEnumerateInstanceLayerProperties;
 
   // Instance functions
-  VulkanFunction<PFN_vkCreateDevice> vkCreateDeviceFn;
-  VulkanFunction<PFN_vkDestroyInstance> vkDestroyInstanceFn;
+  VulkanFunction<PFN_vkCreateDevice> vkCreateDevice;
+  VulkanFunction<PFN_vkDestroyInstance> vkDestroyInstance;
   VulkanFunction<PFN_vkEnumerateDeviceExtensionProperties>
-      vkEnumerateDeviceExtensionPropertiesFn;
+      vkEnumerateDeviceExtensionProperties;
   VulkanFunction<PFN_vkEnumerateDeviceLayerProperties>
-      vkEnumerateDeviceLayerPropertiesFn;
-  VulkanFunction<PFN_vkEnumeratePhysicalDevices> vkEnumeratePhysicalDevicesFn;
-  VulkanFunction<PFN_vkGetDeviceProcAddr> vkGetDeviceProcAddrFn;
-  VulkanFunction<PFN_vkGetPhysicalDeviceFeatures> vkGetPhysicalDeviceFeaturesFn;
+      vkEnumerateDeviceLayerProperties;
+  VulkanFunction<PFN_vkEnumeratePhysicalDevices> vkEnumeratePhysicalDevices;
+  VulkanFunction<PFN_vkGetDeviceProcAddr> vkGetDeviceProcAddr;
+  VulkanFunction<PFN_vkGetPhysicalDeviceFeatures2> vkGetPhysicalDeviceFeatures2;
   VulkanFunction<PFN_vkGetPhysicalDeviceFormatProperties>
-      vkGetPhysicalDeviceFormatPropertiesFn;
+      vkGetPhysicalDeviceFormatProperties;
+  VulkanFunction<PFN_vkGetPhysicalDeviceImageFormatProperties2>
+      vkGetPhysicalDeviceImageFormatProperties2;
   VulkanFunction<PFN_vkGetPhysicalDeviceMemoryProperties>
-      vkGetPhysicalDeviceMemoryPropertiesFn;
+      vkGetPhysicalDeviceMemoryProperties;
+  VulkanFunction<PFN_vkGetPhysicalDeviceMemoryProperties2>
+      vkGetPhysicalDeviceMemoryProperties2;
   VulkanFunction<PFN_vkGetPhysicalDeviceProperties>
-      vkGetPhysicalDevicePropertiesFn;
+      vkGetPhysicalDeviceProperties;
   VulkanFunction<PFN_vkGetPhysicalDeviceQueueFamilyProperties>
-      vkGetPhysicalDeviceQueueFamilyPropertiesFn;
+      vkGetPhysicalDeviceQueueFamilyProperties;
 
 #if DCHECK_IS_ON()
   VulkanFunction<PFN_vkCreateDebugReportCallbackEXT>
-      vkCreateDebugReportCallbackEXTFn;
+      vkCreateDebugReportCallbackEXT;
   VulkanFunction<PFN_vkDestroyDebugReportCallbackEXT>
-      vkDestroyDebugReportCallbackEXTFn;
+      vkDestroyDebugReportCallbackEXT;
 #endif  // DCHECK_IS_ON()
 
-  VulkanFunction<PFN_vkDestroySurfaceKHR> vkDestroySurfaceKHRFn;
+  VulkanFunction<PFN_vkDestroySurfaceKHR> vkDestroySurfaceKHR;
   VulkanFunction<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>
-      vkGetPhysicalDeviceSurfaceCapabilitiesKHRFn;
+      vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
   VulkanFunction<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>
-      vkGetPhysicalDeviceSurfaceFormatsKHRFn;
+      vkGetPhysicalDeviceSurfaceFormatsKHR;
   VulkanFunction<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>
-      vkGetPhysicalDeviceSurfaceSupportKHRFn;
+      vkGetPhysicalDeviceSurfaceSupportKHR;
 
 #if defined(USE_VULKAN_XLIB)
-  VulkanFunction<PFN_vkCreateXlibSurfaceKHR> vkCreateXlibSurfaceKHRFn;
+  VulkanFunction<PFN_vkCreateXlibSurfaceKHR> vkCreateXlibSurfaceKHR;
   VulkanFunction<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>
-      vkGetPhysicalDeviceXlibPresentationSupportKHRFn;
+      vkGetPhysicalDeviceXlibPresentationSupportKHR;
 #endif  // defined(USE_VULKAN_XLIB)
 
 #if defined(OS_WIN)
-  VulkanFunction<PFN_vkCreateWin32SurfaceKHR> vkCreateWin32SurfaceKHRFn;
+  VulkanFunction<PFN_vkCreateWin32SurfaceKHR> vkCreateWin32SurfaceKHR;
   VulkanFunction<PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR>
-      vkGetPhysicalDeviceWin32PresentationSupportKHRFn;
+      vkGetPhysicalDeviceWin32PresentationSupportKHR;
 #endif  // defined(OS_WIN)
 
 #if defined(OS_ANDROID)
-  VulkanFunction<PFN_vkCreateAndroidSurfaceKHR> vkCreateAndroidSurfaceKHRFn;
+  VulkanFunction<PFN_vkCreateAndroidSurfaceKHR> vkCreateAndroidSurfaceKHR;
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_FUCHSIA)
   VulkanFunction<PFN_vkCreateImagePipeSurfaceFUCHSIA>
-      vkCreateImagePipeSurfaceFUCHSIAFn;
+      vkCreateImagePipeSurfaceFUCHSIA;
 #endif  // defined(OS_FUCHSIA)
 
-  VulkanFunction<PFN_vkGetPhysicalDeviceImageFormatProperties2>
-      vkGetPhysicalDeviceImageFormatProperties2Fn;
-
-  VulkanFunction<PFN_vkGetPhysicalDeviceFeatures2>
-      vkGetPhysicalDeviceFeatures2Fn;
-
   // Device functions
-  VulkanFunction<PFN_vkAllocateCommandBuffers> vkAllocateCommandBuffersFn;
-  VulkanFunction<PFN_vkAllocateDescriptorSets> vkAllocateDescriptorSetsFn;
-  VulkanFunction<PFN_vkAllocateMemory> vkAllocateMemoryFn;
-  VulkanFunction<PFN_vkBeginCommandBuffer> vkBeginCommandBufferFn;
-  VulkanFunction<PFN_vkBindBufferMemory> vkBindBufferMemoryFn;
-  VulkanFunction<PFN_vkBindImageMemory> vkBindImageMemoryFn;
-  VulkanFunction<PFN_vkCmdBeginRenderPass> vkCmdBeginRenderPassFn;
-  VulkanFunction<PFN_vkCmdCopyBuffer> vkCmdCopyBufferFn;
-  VulkanFunction<PFN_vkCmdCopyBufferToImage> vkCmdCopyBufferToImageFn;
-  VulkanFunction<PFN_vkCmdEndRenderPass> vkCmdEndRenderPassFn;
-  VulkanFunction<PFN_vkCmdExecuteCommands> vkCmdExecuteCommandsFn;
-  VulkanFunction<PFN_vkCmdNextSubpass> vkCmdNextSubpassFn;
-  VulkanFunction<PFN_vkCmdPipelineBarrier> vkCmdPipelineBarrierFn;
-  VulkanFunction<PFN_vkCreateBuffer> vkCreateBufferFn;
-  VulkanFunction<PFN_vkCreateCommandPool> vkCreateCommandPoolFn;
-  VulkanFunction<PFN_vkCreateDescriptorPool> vkCreateDescriptorPoolFn;
-  VulkanFunction<PFN_vkCreateDescriptorSetLayout> vkCreateDescriptorSetLayoutFn;
-  VulkanFunction<PFN_vkCreateFence> vkCreateFenceFn;
-  VulkanFunction<PFN_vkCreateFramebuffer> vkCreateFramebufferFn;
-  VulkanFunction<PFN_vkCreateImage> vkCreateImageFn;
-  VulkanFunction<PFN_vkCreateImageView> vkCreateImageViewFn;
-  VulkanFunction<PFN_vkCreateRenderPass> vkCreateRenderPassFn;
-  VulkanFunction<PFN_vkCreateSampler> vkCreateSamplerFn;
-  VulkanFunction<PFN_vkCreateSemaphore> vkCreateSemaphoreFn;
-  VulkanFunction<PFN_vkCreateShaderModule> vkCreateShaderModuleFn;
-  VulkanFunction<PFN_vkDestroyBuffer> vkDestroyBufferFn;
-  VulkanFunction<PFN_vkDestroyCommandPool> vkDestroyCommandPoolFn;
-  VulkanFunction<PFN_vkDestroyDescriptorPool> vkDestroyDescriptorPoolFn;
-  VulkanFunction<PFN_vkDestroyDescriptorSetLayout>
-      vkDestroyDescriptorSetLayoutFn;
-  VulkanFunction<PFN_vkDestroyDevice> vkDestroyDeviceFn;
-  VulkanFunction<PFN_vkDestroyFence> vkDestroyFenceFn;
-  VulkanFunction<PFN_vkDestroyFramebuffer> vkDestroyFramebufferFn;
-  VulkanFunction<PFN_vkDestroyImage> vkDestroyImageFn;
-  VulkanFunction<PFN_vkDestroyImageView> vkDestroyImageViewFn;
-  VulkanFunction<PFN_vkDestroyRenderPass> vkDestroyRenderPassFn;
-  VulkanFunction<PFN_vkDestroySampler> vkDestroySamplerFn;
-  VulkanFunction<PFN_vkDestroySemaphore> vkDestroySemaphoreFn;
-  VulkanFunction<PFN_vkDestroyShaderModule> vkDestroyShaderModuleFn;
-  VulkanFunction<PFN_vkDeviceWaitIdle> vkDeviceWaitIdleFn;
-  VulkanFunction<PFN_vkFlushMappedMemoryRanges> vkFlushMappedMemoryRangesFn;
-  VulkanFunction<PFN_vkEndCommandBuffer> vkEndCommandBufferFn;
-  VulkanFunction<PFN_vkFreeCommandBuffers> vkFreeCommandBuffersFn;
-  VulkanFunction<PFN_vkFreeDescriptorSets> vkFreeDescriptorSetsFn;
-  VulkanFunction<PFN_vkFreeMemory> vkFreeMemoryFn;
+  VulkanFunction<PFN_vkAllocateCommandBuffers> vkAllocateCommandBuffers;
+  VulkanFunction<PFN_vkAllocateDescriptorSets> vkAllocateDescriptorSets;
+  VulkanFunction<PFN_vkAllocateMemory> vkAllocateMemory;
+  VulkanFunction<PFN_vkBeginCommandBuffer> vkBeginCommandBuffer;
+  VulkanFunction<PFN_vkBindBufferMemory> vkBindBufferMemory;
+  VulkanFunction<PFN_vkBindBufferMemory2> vkBindBufferMemory2;
+  VulkanFunction<PFN_vkBindImageMemory> vkBindImageMemory;
+  VulkanFunction<PFN_vkBindImageMemory2> vkBindImageMemory2;
+  VulkanFunction<PFN_vkCmdBeginRenderPass> vkCmdBeginRenderPass;
+  VulkanFunction<PFN_vkCmdCopyBuffer> vkCmdCopyBuffer;
+  VulkanFunction<PFN_vkCmdCopyBufferToImage> vkCmdCopyBufferToImage;
+  VulkanFunction<PFN_vkCmdEndRenderPass> vkCmdEndRenderPass;
+  VulkanFunction<PFN_vkCmdExecuteCommands> vkCmdExecuteCommands;
+  VulkanFunction<PFN_vkCmdNextSubpass> vkCmdNextSubpass;
+  VulkanFunction<PFN_vkCmdPipelineBarrier> vkCmdPipelineBarrier;
+  VulkanFunction<PFN_vkCreateBuffer> vkCreateBuffer;
+  VulkanFunction<PFN_vkCreateCommandPool> vkCreateCommandPool;
+  VulkanFunction<PFN_vkCreateDescriptorPool> vkCreateDescriptorPool;
+  VulkanFunction<PFN_vkCreateDescriptorSetLayout> vkCreateDescriptorSetLayout;
+  VulkanFunction<PFN_vkCreateFence> vkCreateFence;
+  VulkanFunction<PFN_vkCreateFramebuffer> vkCreateFramebuffer;
+  VulkanFunction<PFN_vkCreateImage> vkCreateImage;
+  VulkanFunction<PFN_vkCreateImageView> vkCreateImageView;
+  VulkanFunction<PFN_vkCreateRenderPass> vkCreateRenderPass;
+  VulkanFunction<PFN_vkCreateSampler> vkCreateSampler;
+  VulkanFunction<PFN_vkCreateSemaphore> vkCreateSemaphore;
+  VulkanFunction<PFN_vkCreateShaderModule> vkCreateShaderModule;
+  VulkanFunction<PFN_vkDestroyBuffer> vkDestroyBuffer;
+  VulkanFunction<PFN_vkDestroyCommandPool> vkDestroyCommandPool;
+  VulkanFunction<PFN_vkDestroyDescriptorPool> vkDestroyDescriptorPool;
+  VulkanFunction<PFN_vkDestroyDescriptorSetLayout> vkDestroyDescriptorSetLayout;
+  VulkanFunction<PFN_vkDestroyDevice> vkDestroyDevice;
+  VulkanFunction<PFN_vkDestroyFence> vkDestroyFence;
+  VulkanFunction<PFN_vkDestroyFramebuffer> vkDestroyFramebuffer;
+  VulkanFunction<PFN_vkDestroyImage> vkDestroyImage;
+  VulkanFunction<PFN_vkDestroyImageView> vkDestroyImageView;
+  VulkanFunction<PFN_vkDestroyRenderPass> vkDestroyRenderPass;
+  VulkanFunction<PFN_vkDestroySampler> vkDestroySampler;
+  VulkanFunction<PFN_vkDestroySemaphore> vkDestroySemaphore;
+  VulkanFunction<PFN_vkDestroyShaderModule> vkDestroyShaderModule;
+  VulkanFunction<PFN_vkDeviceWaitIdle> vkDeviceWaitIdle;
+  VulkanFunction<PFN_vkFlushMappedMemoryRanges> vkFlushMappedMemoryRanges;
+  VulkanFunction<PFN_vkEndCommandBuffer> vkEndCommandBuffer;
+  VulkanFunction<PFN_vkFreeCommandBuffers> vkFreeCommandBuffers;
+  VulkanFunction<PFN_vkFreeDescriptorSets> vkFreeDescriptorSets;
+  VulkanFunction<PFN_vkFreeMemory> vkFreeMemory;
   VulkanFunction<PFN_vkInvalidateMappedMemoryRanges>
-      vkInvalidateMappedMemoryRangesFn;
+      vkInvalidateMappedMemoryRanges;
   VulkanFunction<PFN_vkGetBufferMemoryRequirements>
-      vkGetBufferMemoryRequirementsFn;
-  VulkanFunction<PFN_vkGetDeviceQueue> vkGetDeviceQueueFn;
-  VulkanFunction<PFN_vkGetFenceStatus> vkGetFenceStatusFn;
-  VulkanFunction<PFN_vkGetImageMemoryRequirements>
-      vkGetImageMemoryRequirementsFn;
-  VulkanFunction<PFN_vkMapMemory> vkMapMemoryFn;
-  VulkanFunction<PFN_vkQueueSubmit> vkQueueSubmitFn;
-  VulkanFunction<PFN_vkQueueWaitIdle> vkQueueWaitIdleFn;
-  VulkanFunction<PFN_vkResetCommandBuffer> vkResetCommandBufferFn;
-  VulkanFunction<PFN_vkResetFences> vkResetFencesFn;
-  VulkanFunction<PFN_vkUnmapMemory> vkUnmapMemoryFn;
-  VulkanFunction<PFN_vkUpdateDescriptorSets> vkUpdateDescriptorSetsFn;
-  VulkanFunction<PFN_vkWaitForFences> vkWaitForFencesFn;
-
-  VulkanFunction<PFN_vkGetDeviceQueue2> vkGetDeviceQueue2Fn;
+      vkGetBufferMemoryRequirements;
   VulkanFunction<PFN_vkGetBufferMemoryRequirements2>
-      vkGetBufferMemoryRequirements2Fn;
+      vkGetBufferMemoryRequirements2;
+  VulkanFunction<PFN_vkGetDeviceQueue> vkGetDeviceQueue;
+  VulkanFunction<PFN_vkGetDeviceQueue2> vkGetDeviceQueue2;
+  VulkanFunction<PFN_vkGetFenceStatus> vkGetFenceStatus;
+  VulkanFunction<PFN_vkGetImageMemoryRequirements> vkGetImageMemoryRequirements;
   VulkanFunction<PFN_vkGetImageMemoryRequirements2>
-      vkGetImageMemoryRequirements2Fn;
+      vkGetImageMemoryRequirements2;
+  VulkanFunction<PFN_vkMapMemory> vkMapMemory;
+  VulkanFunction<PFN_vkQueueSubmit> vkQueueSubmit;
+  VulkanFunction<PFN_vkQueueWaitIdle> vkQueueWaitIdle;
+  VulkanFunction<PFN_vkResetCommandBuffer> vkResetCommandBuffer;
+  VulkanFunction<PFN_vkResetFences> vkResetFences;
+  VulkanFunction<PFN_vkUnmapMemory> vkUnmapMemory;
+  VulkanFunction<PFN_vkUpdateDescriptorSets> vkUpdateDescriptorSets;
+  VulkanFunction<PFN_vkWaitForFences> vkWaitForFences;
 
 #if defined(OS_ANDROID)
   VulkanFunction<PFN_vkGetAndroidHardwareBufferPropertiesANDROID>
-      vkGetAndroidHardwareBufferPropertiesANDROIDFn;
+      vkGetAndroidHardwareBufferPropertiesANDROID;
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
-  VulkanFunction<PFN_vkGetSemaphoreFdKHR> vkGetSemaphoreFdKHRFn;
-  VulkanFunction<PFN_vkImportSemaphoreFdKHR> vkImportSemaphoreFdKHRFn;
+  VulkanFunction<PFN_vkGetSemaphoreFdKHR> vkGetSemaphoreFdKHR;
+  VulkanFunction<PFN_vkImportSemaphoreFdKHR> vkImportSemaphoreFdKHR;
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
 #if defined(OS_WIN)
-  VulkanFunction<PFN_vkGetSemaphoreWin32HandleKHR>
-      vkGetSemaphoreWin32HandleKHRFn;
+  VulkanFunction<PFN_vkGetSemaphoreWin32HandleKHR> vkGetSemaphoreWin32HandleKHR;
   VulkanFunction<PFN_vkImportSemaphoreWin32HandleKHR>
-      vkImportSemaphoreWin32HandleKHRFn;
+      vkImportSemaphoreWin32HandleKHR;
 #endif  // defined(OS_WIN)
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
-  VulkanFunction<PFN_vkGetMemoryFdKHR> vkGetMemoryFdKHRFn;
-  VulkanFunction<PFN_vkGetMemoryFdPropertiesKHR> vkGetMemoryFdPropertiesKHRFn;
+  VulkanFunction<PFN_vkGetMemoryFdKHR> vkGetMemoryFdKHR;
+  VulkanFunction<PFN_vkGetMemoryFdPropertiesKHR> vkGetMemoryFdPropertiesKHR;
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
 #if defined(OS_WIN)
-  VulkanFunction<PFN_vkGetMemoryWin32HandleKHR> vkGetMemoryWin32HandleKHRFn;
+  VulkanFunction<PFN_vkGetMemoryWin32HandleKHR> vkGetMemoryWin32HandleKHR;
   VulkanFunction<PFN_vkGetMemoryWin32HandlePropertiesKHR>
-      vkGetMemoryWin32HandlePropertiesKHRFn;
+      vkGetMemoryWin32HandlePropertiesKHR;
 #endif  // defined(OS_WIN)
 
 #if defined(OS_FUCHSIA)
   VulkanFunction<PFN_vkImportSemaphoreZirconHandleFUCHSIA>
-      vkImportSemaphoreZirconHandleFUCHSIAFn;
+      vkImportSemaphoreZirconHandleFUCHSIA;
   VulkanFunction<PFN_vkGetSemaphoreZirconHandleFUCHSIA>
-      vkGetSemaphoreZirconHandleFUCHSIAFn;
+      vkGetSemaphoreZirconHandleFUCHSIA;
 #endif  // defined(OS_FUCHSIA)
 
 #if defined(OS_FUCHSIA)
   VulkanFunction<PFN_vkGetMemoryZirconHandleFUCHSIA>
-      vkGetMemoryZirconHandleFUCHSIAFn;
+      vkGetMemoryZirconHandleFUCHSIA;
 #endif  // defined(OS_FUCHSIA)
 
 #if defined(OS_FUCHSIA)
   VulkanFunction<PFN_vkCreateBufferCollectionFUCHSIA>
-      vkCreateBufferCollectionFUCHSIAFn;
+      vkCreateBufferCollectionFUCHSIA;
   VulkanFunction<PFN_vkSetBufferCollectionConstraintsFUCHSIA>
-      vkSetBufferCollectionConstraintsFUCHSIAFn;
+      vkSetBufferCollectionConstraintsFUCHSIA;
   VulkanFunction<PFN_vkGetBufferCollectionPropertiesFUCHSIA>
-      vkGetBufferCollectionPropertiesFUCHSIAFn;
+      vkGetBufferCollectionPropertiesFUCHSIA;
   VulkanFunction<PFN_vkDestroyBufferCollectionFUCHSIA>
-      vkDestroyBufferCollectionFUCHSIAFn;
+      vkDestroyBufferCollectionFUCHSIA;
 #endif  // defined(OS_FUCHSIA)
 
-  VulkanFunction<PFN_vkAcquireNextImageKHR> vkAcquireNextImageKHRFn;
-  VulkanFunction<PFN_vkCreateSwapchainKHR> vkCreateSwapchainKHRFn;
-  VulkanFunction<PFN_vkDestroySwapchainKHR> vkDestroySwapchainKHRFn;
-  VulkanFunction<PFN_vkGetSwapchainImagesKHR> vkGetSwapchainImagesKHRFn;
-  VulkanFunction<PFN_vkQueuePresentKHR> vkQueuePresentKHRFn;
+  VulkanFunction<PFN_vkAcquireNextImageKHR> vkAcquireNextImageKHR;
+  VulkanFunction<PFN_vkCreateSwapchainKHR> vkCreateSwapchainKHR;
+  VulkanFunction<PFN_vkDestroySwapchainKHR> vkDestroySwapchainKHR;
+  VulkanFunction<PFN_vkGetSwapchainImagesKHR> vkGetSwapchainImagesKHR;
+  VulkanFunction<PFN_vkQueuePresentKHR> vkQueuePresentKHR;
 };
 
 }  // namespace gpu
@@ -293,18 +291,18 @@ struct COMPONENT_EXPORT(VULKAN) VulkanFunctionPointers {
 // Unassociated functions
 ALWAYS_INLINE PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance,
                                                        const char* pName) {
-  return gpu::GetVulkanFunctionPointers()->vkGetInstanceProcAddrFn(instance,
-                                                                   pName);
+  return gpu::GetVulkanFunctionPointers()->vkGetInstanceProcAddr(instance,
+                                                                 pName);
 }
+
 ALWAYS_INLINE VkResult vkEnumerateInstanceVersion(uint32_t* pApiVersion) {
-  return gpu::GetVulkanFunctionPointers()->vkEnumerateInstanceVersionFn(
+  return gpu::GetVulkanFunctionPointers()->vkEnumerateInstanceVersion(
       pApiVersion);
 }
-
 ALWAYS_INLINE VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
                                         const VkAllocationCallbacks* pAllocator,
                                         VkInstance* pInstance) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateInstanceFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateInstance(
       pCreateInfo, pAllocator, pInstance);
 }
 ALWAYS_INLINE VkResult
@@ -312,13 +310,13 @@ vkEnumerateInstanceExtensionProperties(const char* pLayerName,
                                        uint32_t* pPropertyCount,
                                        VkExtensionProperties* pProperties) {
   return gpu::GetVulkanFunctionPointers()
-      ->vkEnumerateInstanceExtensionPropertiesFn(pLayerName, pPropertyCount,
-                                                 pProperties);
+      ->vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount,
+                                               pProperties);
 }
 ALWAYS_INLINE VkResult
 vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
                                    VkLayerProperties* pProperties) {
-  return gpu::GetVulkanFunctionPointers()->vkEnumerateInstanceLayerPropertiesFn(
+  return gpu::GetVulkanFunctionPointers()->vkEnumerateInstanceLayerProperties(
       pPropertyCount, pProperties);
 }
 
@@ -327,66 +325,77 @@ ALWAYS_INLINE VkResult vkCreateDevice(VkPhysicalDevice physicalDevice,
                                       const VkDeviceCreateInfo* pCreateInfo,
                                       const VkAllocationCallbacks* pAllocator,
                                       VkDevice* pDevice) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateDeviceFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateDevice(
       physicalDevice, pCreateInfo, pAllocator, pDevice);
 }
 ALWAYS_INLINE void vkDestroyInstance(VkInstance instance,
                                      const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyInstanceFn(instance,
-                                                               pAllocator);
+  return gpu::GetVulkanFunctionPointers()->vkDestroyInstance(instance,
+                                                             pAllocator);
 }
 ALWAYS_INLINE VkResult
 vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
                                      const char* pLayerName,
                                      uint32_t* pPropertyCount,
                                      VkExtensionProperties* pProperties) {
-  return gpu::GetVulkanFunctionPointers()
-      ->vkEnumerateDeviceExtensionPropertiesFn(physicalDevice, pLayerName,
-                                               pPropertyCount, pProperties);
+  return gpu::GetVulkanFunctionPointers()->vkEnumerateDeviceExtensionProperties(
+      physicalDevice, pLayerName, pPropertyCount, pProperties);
 }
 ALWAYS_INLINE VkResult
 vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
                                  uint32_t* pPropertyCount,
                                  VkLayerProperties* pProperties) {
-  return gpu::GetVulkanFunctionPointers()->vkEnumerateDeviceLayerPropertiesFn(
+  return gpu::GetVulkanFunctionPointers()->vkEnumerateDeviceLayerProperties(
       physicalDevice, pPropertyCount, pProperties);
 }
 ALWAYS_INLINE VkResult
 vkEnumeratePhysicalDevices(VkInstance instance,
                            uint32_t* pPhysicalDeviceCount,
                            VkPhysicalDevice* pPhysicalDevices) {
-  return gpu::GetVulkanFunctionPointers()->vkEnumeratePhysicalDevicesFn(
+  return gpu::GetVulkanFunctionPointers()->vkEnumeratePhysicalDevices(
       instance, pPhysicalDeviceCount, pPhysicalDevices);
 }
 ALWAYS_INLINE PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device,
                                                      const char* pName) {
-  return gpu::GetVulkanFunctionPointers()->vkGetDeviceProcAddrFn(device, pName);
+  return gpu::GetVulkanFunctionPointers()->vkGetDeviceProcAddr(device, pName);
 }
-ALWAYS_INLINE void vkGetPhysicalDeviceFeatures(
+ALWAYS_INLINE void vkGetPhysicalDeviceFeatures2(
     VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceFeatures* pFeatures) {
-  return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFeaturesFn(
+    VkPhysicalDeviceFeatures2* pFeatures) {
+  return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFeatures2(
       physicalDevice, pFeatures);
 }
 ALWAYS_INLINE void vkGetPhysicalDeviceFormatProperties(
     VkPhysicalDevice physicalDevice,
     VkFormat format,
     VkFormatProperties* pFormatProperties) {
+  return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFormatProperties(
+      physicalDevice, format, pFormatProperties);
+}
+ALWAYS_INLINE VkResult vkGetPhysicalDeviceImageFormatProperties2(
+    VkPhysicalDevice physicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
+    VkImageFormatProperties2* pImageFormatProperties) {
   return gpu::GetVulkanFunctionPointers()
-      ->vkGetPhysicalDeviceFormatPropertiesFn(physicalDevice, format,
-                                              pFormatProperties);
+      ->vkGetPhysicalDeviceImageFormatProperties2(
+          physicalDevice, pImageFormatInfo, pImageFormatProperties);
 }
 ALWAYS_INLINE void vkGetPhysicalDeviceMemoryProperties(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
-  return gpu::GetVulkanFunctionPointers()
-      ->vkGetPhysicalDeviceMemoryPropertiesFn(physicalDevice,
-                                              pMemoryProperties);
+  return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceMemoryProperties(
+      physicalDevice, pMemoryProperties);
+}
+ALWAYS_INLINE void vkGetPhysicalDeviceMemoryProperties2(
+    VkPhysicalDevice physicalDevice,
+    VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
+  return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceMemoryProperties2(
+      physicalDevice, pMemoryProperties);
 }
 ALWAYS_INLINE void vkGetPhysicalDeviceProperties(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceProperties* pProperties) {
-  return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDevicePropertiesFn(
+  return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceProperties(
       physicalDevice, pProperties);
 }
 ALWAYS_INLINE void vkGetPhysicalDeviceQueueFamilyProperties(
@@ -394,7 +403,7 @@ ALWAYS_INLINE void vkGetPhysicalDeviceQueueFamilyProperties(
     uint32_t* pQueueFamilyPropertyCount,
     VkQueueFamilyProperties* pQueueFamilyProperties) {
   return gpu::GetVulkanFunctionPointers()
-      ->vkGetPhysicalDeviceQueueFamilyPropertiesFn(
+      ->vkGetPhysicalDeviceQueueFamilyProperties(
           physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 }
 
@@ -404,14 +413,14 @@ ALWAYS_INLINE VkResult vkCreateDebugReportCallbackEXT(
     const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
     const VkAllocationCallbacks* pAllocator,
     VkDebugReportCallbackEXT* pCallback) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateDebugReportCallbackEXTFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateDebugReportCallbackEXT(
       instance, pCreateInfo, pAllocator, pCallback);
 }
 ALWAYS_INLINE void vkDestroyDebugReportCallbackEXT(
     VkInstance instance,
     VkDebugReportCallbackEXT callback,
     const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyDebugReportCallbackEXTFn(
+  return gpu::GetVulkanFunctionPointers()->vkDestroyDebugReportCallbackEXT(
       instance, callback, pAllocator);
 }
 #endif  // DCHECK_IS_ON()
@@ -420,7 +429,7 @@ ALWAYS_INLINE void vkDestroySurfaceKHR(
     VkInstance instance,
     VkSurfaceKHR surface,
     const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroySurfaceKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkDestroySurfaceKHR(
       instance, surface, pAllocator);
 }
 ALWAYS_INLINE VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
@@ -428,26 +437,24 @@ ALWAYS_INLINE VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
     VkSurfaceKHR surface,
     VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) {
   return gpu::GetVulkanFunctionPointers()
-      ->vkGetPhysicalDeviceSurfaceCapabilitiesKHRFn(physicalDevice, surface,
-                                                    pSurfaceCapabilities);
+      ->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface,
+                                                  pSurfaceCapabilities);
 }
 ALWAYS_INLINE VkResult
 vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
                                      VkSurfaceKHR surface,
                                      uint32_t* pSurfaceFormatCount,
                                      VkSurfaceFormatKHR* pSurfaceFormats) {
-  return gpu::GetVulkanFunctionPointers()
-      ->vkGetPhysicalDeviceSurfaceFormatsKHRFn(
-          physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
+  return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceSurfaceFormatsKHR(
+      physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
 }
 ALWAYS_INLINE VkResult
 vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
                                      uint32_t queueFamilyIndex,
                                      VkSurfaceKHR surface,
                                      VkBool32* pSupported) {
-  return gpu::GetVulkanFunctionPointers()
-      ->vkGetPhysicalDeviceSurfaceSupportKHRFn(physicalDevice, queueFamilyIndex,
-                                               surface, pSupported);
+  return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceSurfaceSupportKHR(
+      physicalDevice, queueFamilyIndex, surface, pSupported);
 }
 
 #if defined(USE_VULKAN_XLIB)
@@ -456,7 +463,7 @@ vkCreateXlibSurfaceKHR(VkInstance instance,
                        const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
                        const VkAllocationCallbacks* pAllocator,
                        VkSurfaceKHR* pSurface) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateXlibSurfaceKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateXlibSurfaceKHR(
       instance, pCreateInfo, pAllocator, pSurface);
 }
 ALWAYS_INLINE VkBool32
@@ -465,7 +472,7 @@ vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
                                               Display* dpy,
                                               VisualID visualID) {
   return gpu::GetVulkanFunctionPointers()
-      ->vkGetPhysicalDeviceXlibPresentationSupportKHRFn(
+      ->vkGetPhysicalDeviceXlibPresentationSupportKHR(
           physicalDevice, queueFamilyIndex, dpy, visualID);
 }
 #endif  // defined(USE_VULKAN_XLIB)
@@ -476,15 +483,15 @@ vkCreateWin32SurfaceKHR(VkInstance instance,
                         const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
                         const VkAllocationCallbacks* pAllocator,
                         VkSurfaceKHR* pSurface) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateWin32SurfaceKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateWin32SurfaceKHR(
       instance, pCreateInfo, pAllocator, pSurface);
 }
 ALWAYS_INLINE VkBool32
 vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
                                                uint32_t queueFamilyIndex) {
   return gpu::GetVulkanFunctionPointers()
-      ->vkGetPhysicalDeviceWin32PresentationSupportKHRFn(physicalDevice,
-                                                         queueFamilyIndex);
+      ->vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice,
+                                                       queueFamilyIndex);
 }
 #endif  // defined(OS_WIN)
 
@@ -494,7 +501,7 @@ vkCreateAndroidSurfaceKHR(VkInstance instance,
                           const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
                           const VkAllocationCallbacks* pAllocator,
                           VkSurfaceKHR* pSurface) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateAndroidSurfaceKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateAndroidSurfaceKHR(
       instance, pCreateInfo, pAllocator, pSurface);
 }
 #endif  // defined(OS_ANDROID)
@@ -505,40 +512,24 @@ ALWAYS_INLINE VkResult vkCreateImagePipeSurfaceFUCHSIA(
     const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo,
     const VkAllocationCallbacks* pAllocator,
     VkSurfaceKHR* pSurface) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateImagePipeSurfaceFUCHSIAFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateImagePipeSurfaceFUCHSIA(
       instance, pCreateInfo, pAllocator, pSurface);
 }
 #endif  // defined(OS_FUCHSIA)
 
-ALWAYS_INLINE VkResult vkGetPhysicalDeviceImageFormatProperties2(
-    VkPhysicalDevice physicalDevice,
-    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
-    VkImageFormatProperties2* pImageFormatProperties) {
-  return gpu::GetVulkanFunctionPointers()
-      ->vkGetPhysicalDeviceImageFormatProperties2Fn(
-          physicalDevice, pImageFormatInfo, pImageFormatProperties);
-}
-
-ALWAYS_INLINE void vkGetPhysicalDeviceFeatures2(
-    VkPhysicalDevice physicalDevice,
-    VkPhysicalDeviceFeatures2* pFeatures) {
-  return gpu::GetVulkanFunctionPointers()->vkGetPhysicalDeviceFeatures2Fn(
-      physicalDevice, pFeatures);
-}
-
 // Device functions
 ALWAYS_INLINE VkResult
 vkAllocateCommandBuffers(VkDevice device,
                          const VkCommandBufferAllocateInfo* pAllocateInfo,
                          VkCommandBuffer* pCommandBuffers) {
-  return gpu::GetVulkanFunctionPointers()->vkAllocateCommandBuffersFn(
+  return gpu::GetVulkanFunctionPointers()->vkAllocateCommandBuffers(
       device, pAllocateInfo, pCommandBuffers);
 }
 ALWAYS_INLINE VkResult
 vkAllocateDescriptorSets(VkDevice device,
                          const VkDescriptorSetAllocateInfo* pAllocateInfo,
                          VkDescriptorSet* pDescriptorSets) {
-  return gpu::GetVulkanFunctionPointers()->vkAllocateDescriptorSetsFn(
+  return gpu::GetVulkanFunctionPointers()->vkAllocateDescriptorSets(
       device, pAllocateInfo, pDescriptorSets);
 }
 ALWAYS_INLINE VkResult
@@ -546,34 +537,48 @@ vkAllocateMemory(VkDevice device,
                  const VkMemoryAllocateInfo* pAllocateInfo,
                  const VkAllocationCallbacks* pAllocator,
                  VkDeviceMemory* pMemory) {
-  return gpu::GetVulkanFunctionPointers()->vkAllocateMemoryFn(
+  return gpu::GetVulkanFunctionPointers()->vkAllocateMemory(
       device, pAllocateInfo, pAllocator, pMemory);
 }
 ALWAYS_INLINE VkResult
 vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
                      const VkCommandBufferBeginInfo* pBeginInfo) {
-  return gpu::GetVulkanFunctionPointers()->vkBeginCommandBufferFn(commandBuffer,
-                                                                  pBeginInfo);
+  return gpu::GetVulkanFunctionPointers()->vkBeginCommandBuffer(commandBuffer,
+                                                                pBeginInfo);
 }
 ALWAYS_INLINE VkResult vkBindBufferMemory(VkDevice device,
                                           VkBuffer buffer,
                                           VkDeviceMemory memory,
                                           VkDeviceSize memoryOffset) {
-  return gpu::GetVulkanFunctionPointers()->vkBindBufferMemoryFn(
+  return gpu::GetVulkanFunctionPointers()->vkBindBufferMemory(
       device, buffer, memory, memoryOffset);
 }
+ALWAYS_INLINE VkResult
+vkBindBufferMemory2(VkDevice device,
+                    uint32_t bindInfoCount,
+                    const VkBindBufferMemoryInfo* pBindInfos) {
+  return gpu::GetVulkanFunctionPointers()->vkBindBufferMemory2(
+      device, bindInfoCount, pBindInfos);
+}
 ALWAYS_INLINE VkResult vkBindImageMemory(VkDevice device,
                                          VkImage image,
                                          VkDeviceMemory memory,
                                          VkDeviceSize memoryOffset) {
-  return gpu::GetVulkanFunctionPointers()->vkBindImageMemoryFn(
+  return gpu::GetVulkanFunctionPointers()->vkBindImageMemory(
       device, image, memory, memoryOffset);
 }
+ALWAYS_INLINE VkResult
+vkBindImageMemory2(VkDevice device,
+                   uint32_t bindInfoCount,
+                   const VkBindImageMemoryInfo* pBindInfos) {
+  return gpu::GetVulkanFunctionPointers()->vkBindImageMemory2(
+      device, bindInfoCount, pBindInfos);
+}
 ALWAYS_INLINE void vkCmdBeginRenderPass(
     VkCommandBuffer commandBuffer,
     const VkRenderPassBeginInfo* pRenderPassBegin,
     VkSubpassContents contents) {
-  return gpu::GetVulkanFunctionPointers()->vkCmdBeginRenderPassFn(
+  return gpu::GetVulkanFunctionPointers()->vkCmdBeginRenderPass(
       commandBuffer, pRenderPassBegin, contents);
 }
 ALWAYS_INLINE void vkCmdCopyBuffer(VkCommandBuffer commandBuffer,
@@ -581,7 +586,7 @@ ALWAYS_INLINE void vkCmdCopyBuffer(VkCommandBuffer commandBuffer,
                                    VkBuffer dstBuffer,
                                    uint32_t regionCount,
                                    const VkBufferCopy* pRegions) {
-  return gpu::GetVulkanFunctionPointers()->vkCmdCopyBufferFn(
+  return gpu::GetVulkanFunctionPointers()->vkCmdCopyBuffer(
       commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
 }
 ALWAYS_INLINE void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,
@@ -590,24 +595,24 @@ ALWAYS_INLINE void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer,
                                           VkImageLayout dstImageLayout,
                                           uint32_t regionCount,
                                           const VkBufferImageCopy* pRegions) {
-  return gpu::GetVulkanFunctionPointers()->vkCmdCopyBufferToImageFn(
+  return gpu::GetVulkanFunctionPointers()->vkCmdCopyBufferToImage(
       commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount,
       pRegions);
 }
 ALWAYS_INLINE void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
-  return gpu::GetVulkanFunctionPointers()->vkCmdEndRenderPassFn(commandBuffer);
+  return gpu::GetVulkanFunctionPointers()->vkCmdEndRenderPass(commandBuffer);
 }
 ALWAYS_INLINE void vkCmdExecuteCommands(
     VkCommandBuffer commandBuffer,
     uint32_t commandBufferCount,
     const VkCommandBuffer* pCommandBuffers) {
-  return gpu::GetVulkanFunctionPointers()->vkCmdExecuteCommandsFn(
+  return gpu::GetVulkanFunctionPointers()->vkCmdExecuteCommands(
       commandBuffer, commandBufferCount, pCommandBuffers);
 }
 ALWAYS_INLINE void vkCmdNextSubpass(VkCommandBuffer commandBuffer,
                                     VkSubpassContents contents) {
-  return gpu::GetVulkanFunctionPointers()->vkCmdNextSubpassFn(commandBuffer,
-                                                              contents);
+  return gpu::GetVulkanFunctionPointers()->vkCmdNextSubpass(commandBuffer,
+                                                            contents);
 }
 ALWAYS_INLINE void vkCmdPipelineBarrier(
     VkCommandBuffer commandBuffer,
@@ -620,7 +625,7 @@ ALWAYS_INLINE void vkCmdPipelineBarrier(
     const VkBufferMemoryBarrier* pBufferMemoryBarriers,
     uint32_t imageMemoryBarrierCount,
     const VkImageMemoryBarrier* pImageMemoryBarriers) {
-  return gpu::GetVulkanFunctionPointers()->vkCmdPipelineBarrierFn(
+  return gpu::GetVulkanFunctionPointers()->vkCmdPipelineBarrier(
       commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
       memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
       pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
@@ -629,15 +634,15 @@ ALWAYS_INLINE VkResult vkCreateBuffer(VkDevice device,
                                       const VkBufferCreateInfo* pCreateInfo,
                                       const VkAllocationCallbacks* pAllocator,
                                       VkBuffer* pBuffer) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateBufferFn(
-      device, pCreateInfo, pAllocator, pBuffer);
+  return gpu::GetVulkanFunctionPointers()->vkCreateBuffer(device, pCreateInfo,
+                                                          pAllocator, pBuffer);
 }
 ALWAYS_INLINE VkResult
 vkCreateCommandPool(VkDevice device,
                     const VkCommandPoolCreateInfo* pCreateInfo,
                     const VkAllocationCallbacks* pAllocator,
                     VkCommandPool* pCommandPool) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateCommandPoolFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateCommandPool(
       device, pCreateInfo, pAllocator, pCommandPool);
 }
 ALWAYS_INLINE VkResult
@@ -645,7 +650,7 @@ vkCreateDescriptorPool(VkDevice device,
                        const VkDescriptorPoolCreateInfo* pCreateInfo,
                        const VkAllocationCallbacks* pAllocator,
                        VkDescriptorPool* pDescriptorPool) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateDescriptorPoolFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateDescriptorPool(
       device, pCreateInfo, pAllocator, pDescriptorPool);
 }
 ALWAYS_INLINE VkResult
@@ -653,37 +658,37 @@ vkCreateDescriptorSetLayout(VkDevice device,
                             const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
                             const VkAllocationCallbacks* pAllocator,
                             VkDescriptorSetLayout* pSetLayout) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateDescriptorSetLayoutFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateDescriptorSetLayout(
       device, pCreateInfo, pAllocator, pSetLayout);
 }
 ALWAYS_INLINE VkResult vkCreateFence(VkDevice device,
                                      const VkFenceCreateInfo* pCreateInfo,
                                      const VkAllocationCallbacks* pAllocator,
                                      VkFence* pFence) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateFenceFn(device, pCreateInfo,
-                                                           pAllocator, pFence);
+  return gpu::GetVulkanFunctionPointers()->vkCreateFence(device, pCreateInfo,
+                                                         pAllocator, pFence);
 }
 ALWAYS_INLINE VkResult
 vkCreateFramebuffer(VkDevice device,
                     const VkFramebufferCreateInfo* pCreateInfo,
                     const VkAllocationCallbacks* pAllocator,
                     VkFramebuffer* pFramebuffer) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateFramebufferFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateFramebuffer(
       device, pCreateInfo, pAllocator, pFramebuffer);
 }
 ALWAYS_INLINE VkResult vkCreateImage(VkDevice device,
                                      const VkImageCreateInfo* pCreateInfo,
                                      const VkAllocationCallbacks* pAllocator,
                                      VkImage* pImage) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateImageFn(device, pCreateInfo,
-                                                           pAllocator, pImage);
+  return gpu::GetVulkanFunctionPointers()->vkCreateImage(device, pCreateInfo,
+                                                         pAllocator, pImage);
 }
 ALWAYS_INLINE VkResult
 vkCreateImageView(VkDevice device,
                   const VkImageViewCreateInfo* pCreateInfo,
                   const VkAllocationCallbacks* pAllocator,
                   VkImageView* pView) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateImageViewFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateImageView(
       device, pCreateInfo, pAllocator, pView);
 }
 ALWAYS_INLINE VkResult
@@ -691,14 +696,14 @@ vkCreateRenderPass(VkDevice device,
                    const VkRenderPassCreateInfo* pCreateInfo,
                    const VkAllocationCallbacks* pAllocator,
                    VkRenderPass* pRenderPass) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateRenderPassFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateRenderPass(
       device, pCreateInfo, pAllocator, pRenderPass);
 }
 ALWAYS_INLINE VkResult vkCreateSampler(VkDevice device,
                                        const VkSamplerCreateInfo* pCreateInfo,
                                        const VkAllocationCallbacks* pAllocator,
                                        VkSampler* pSampler) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateSamplerFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateSampler(
       device, pCreateInfo, pAllocator, pSampler);
 }
 ALWAYS_INLINE VkResult
@@ -706,7 +711,7 @@ vkCreateSemaphore(VkDevice device,
                   const VkSemaphoreCreateInfo* pCreateInfo,
                   const VkAllocationCallbacks* pAllocator,
                   VkSemaphore* pSemaphore) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateSemaphoreFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateSemaphore(
       device, pCreateInfo, pAllocator, pSemaphore);
 }
 ALWAYS_INLINE VkResult
@@ -714,111 +719,110 @@ vkCreateShaderModule(VkDevice device,
                      const VkShaderModuleCreateInfo* pCreateInfo,
                      const VkAllocationCallbacks* pAllocator,
                      VkShaderModule* pShaderModule) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateShaderModuleFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateShaderModule(
       device, pCreateInfo, pAllocator, pShaderModule);
 }
 ALWAYS_INLINE void vkDestroyBuffer(VkDevice device,
                                    VkBuffer buffer,
                                    const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyBufferFn(device, buffer,
-                                                             pAllocator);
+  return gpu::GetVulkanFunctionPointers()->vkDestroyBuffer(device, buffer,
+                                                           pAllocator);
 }
 ALWAYS_INLINE void vkDestroyCommandPool(
     VkDevice device,
     VkCommandPool commandPool,
     const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyCommandPoolFn(
+  return gpu::GetVulkanFunctionPointers()->vkDestroyCommandPool(
       device, commandPool, pAllocator);
 }
 ALWAYS_INLINE void vkDestroyDescriptorPool(
     VkDevice device,
     VkDescriptorPool descriptorPool,
     const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyDescriptorPoolFn(
+  return gpu::GetVulkanFunctionPointers()->vkDestroyDescriptorPool(
       device, descriptorPool, pAllocator);
 }
 ALWAYS_INLINE void vkDestroyDescriptorSetLayout(
     VkDevice device,
     VkDescriptorSetLayout descriptorSetLayout,
     const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyDescriptorSetLayoutFn(
+  return gpu::GetVulkanFunctionPointers()->vkDestroyDescriptorSetLayout(
       device, descriptorSetLayout, pAllocator);
 }
 ALWAYS_INLINE void vkDestroyDevice(VkDevice device,
                                    const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyDeviceFn(device,
-                                                             pAllocator);
+  return gpu::GetVulkanFunctionPointers()->vkDestroyDevice(device, pAllocator);
 }
 ALWAYS_INLINE void vkDestroyFence(VkDevice device,
                                   VkFence fence,
                                   const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyFenceFn(device, fence,
-                                                            pAllocator);
+  return gpu::GetVulkanFunctionPointers()->vkDestroyFence(device, fence,
+                                                          pAllocator);
 }
 ALWAYS_INLINE void vkDestroyFramebuffer(
     VkDevice device,
     VkFramebuffer framebuffer,
     const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyFramebufferFn(
+  return gpu::GetVulkanFunctionPointers()->vkDestroyFramebuffer(
       device, framebuffer, pAllocator);
 }
 ALWAYS_INLINE void vkDestroyImage(VkDevice device,
                                   VkImage image,
                                   const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyImageFn(device, image,
-                                                            pAllocator);
+  return gpu::GetVulkanFunctionPointers()->vkDestroyImage(device, image,
+                                                          pAllocator);
 }
 ALWAYS_INLINE void vkDestroyImageView(VkDevice device,
                                       VkImageView imageView,
                                       const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyImageViewFn(
-      device, imageView, pAllocator);
+  return gpu::GetVulkanFunctionPointers()->vkDestroyImageView(device, imageView,
+                                                              pAllocator);
 }
 ALWAYS_INLINE void vkDestroyRenderPass(
     VkDevice device,
     VkRenderPass renderPass,
     const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyRenderPassFn(
+  return gpu::GetVulkanFunctionPointers()->vkDestroyRenderPass(
       device, renderPass, pAllocator);
 }
 ALWAYS_INLINE void vkDestroySampler(VkDevice device,
                                     VkSampler sampler,
                                     const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroySamplerFn(device, sampler,
-                                                              pAllocator);
+  return gpu::GetVulkanFunctionPointers()->vkDestroySampler(device, sampler,
+                                                            pAllocator);
 }
 ALWAYS_INLINE void vkDestroySemaphore(VkDevice device,
                                       VkSemaphore semaphore,
                                       const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroySemaphoreFn(
-      device, semaphore, pAllocator);
+  return gpu::GetVulkanFunctionPointers()->vkDestroySemaphore(device, semaphore,
+                                                              pAllocator);
 }
 ALWAYS_INLINE void vkDestroyShaderModule(
     VkDevice device,
     VkShaderModule shaderModule,
     const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroyShaderModuleFn(
+  return gpu::GetVulkanFunctionPointers()->vkDestroyShaderModule(
       device, shaderModule, pAllocator);
 }
 ALWAYS_INLINE VkResult vkDeviceWaitIdle(VkDevice device) {
-  return gpu::GetVulkanFunctionPointers()->vkDeviceWaitIdleFn(device);
+  return gpu::GetVulkanFunctionPointers()->vkDeviceWaitIdle(device);
 }
 ALWAYS_INLINE VkResult
 vkFlushMappedMemoryRanges(VkDevice device,
                           uint32_t memoryRangeCount,
                           const VkMappedMemoryRange* pMemoryRanges) {
-  return gpu::GetVulkanFunctionPointers()->vkFlushMappedMemoryRangesFn(
+  return gpu::GetVulkanFunctionPointers()->vkFlushMappedMemoryRanges(
       device, memoryRangeCount, pMemoryRanges);
 }
 ALWAYS_INLINE VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
-  return gpu::GetVulkanFunctionPointers()->vkEndCommandBufferFn(commandBuffer);
+  return gpu::GetVulkanFunctionPointers()->vkEndCommandBuffer(commandBuffer);
 }
 ALWAYS_INLINE void vkFreeCommandBuffers(
     VkDevice device,
     VkCommandPool commandPool,
     uint32_t commandBufferCount,
     const VkCommandBuffer* pCommandBuffers) {
-  return gpu::GetVulkanFunctionPointers()->vkFreeCommandBuffersFn(
+  return gpu::GetVulkanFunctionPointers()->vkFreeCommandBuffers(
       device, commandPool, commandBufferCount, pCommandBuffers);
 }
 ALWAYS_INLINE VkResult
@@ -826,78 +830,98 @@ vkFreeDescriptorSets(VkDevice device,
                      VkDescriptorPool descriptorPool,
                      uint32_t descriptorSetCount,
                      const VkDescriptorSet* pDescriptorSets) {
-  return gpu::GetVulkanFunctionPointers()->vkFreeDescriptorSetsFn(
+  return gpu::GetVulkanFunctionPointers()->vkFreeDescriptorSets(
       device, descriptorPool, descriptorSetCount, pDescriptorSets);
 }
 ALWAYS_INLINE void vkFreeMemory(VkDevice device,
                                 VkDeviceMemory memory,
                                 const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkFreeMemoryFn(device, memory,
-                                                          pAllocator);
+  return gpu::GetVulkanFunctionPointers()->vkFreeMemory(device, memory,
+                                                        pAllocator);
 }
 ALWAYS_INLINE VkResult
 vkInvalidateMappedMemoryRanges(VkDevice device,
                                uint32_t memoryRangeCount,
                                const VkMappedMemoryRange* pMemoryRanges) {
-  return gpu::GetVulkanFunctionPointers()->vkInvalidateMappedMemoryRangesFn(
+  return gpu::GetVulkanFunctionPointers()->vkInvalidateMappedMemoryRanges(
       device, memoryRangeCount, pMemoryRanges);
 }
 ALWAYS_INLINE void vkGetBufferMemoryRequirements(
     VkDevice device,
     VkBuffer buffer,
     VkMemoryRequirements* pMemoryRequirements) {
-  return gpu::GetVulkanFunctionPointers()->vkGetBufferMemoryRequirementsFn(
+  return gpu::GetVulkanFunctionPointers()->vkGetBufferMemoryRequirements(
       device, buffer, pMemoryRequirements);
 }
+ALWAYS_INLINE void vkGetBufferMemoryRequirements2(
+    VkDevice device,
+    const VkBufferMemoryRequirementsInfo2* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements) {
+  return gpu::GetVulkanFunctionPointers()->vkGetBufferMemoryRequirements2(
+      device, pInfo, pMemoryRequirements);
+}
 ALWAYS_INLINE void vkGetDeviceQueue(VkDevice device,
                                     uint32_t queueFamilyIndex,
                                     uint32_t queueIndex,
                                     VkQueue* pQueue) {
-  return gpu::GetVulkanFunctionPointers()->vkGetDeviceQueueFn(
+  return gpu::GetVulkanFunctionPointers()->vkGetDeviceQueue(
       device, queueFamilyIndex, queueIndex, pQueue);
 }
+ALWAYS_INLINE void vkGetDeviceQueue2(VkDevice device,
+                                     const VkDeviceQueueInfo2* pQueueInfo,
+                                     VkQueue* pQueue) {
+  return gpu::GetVulkanFunctionPointers()->vkGetDeviceQueue2(device, pQueueInfo,
+                                                             pQueue);
+}
 ALWAYS_INLINE VkResult vkGetFenceStatus(VkDevice device, VkFence fence) {
-  return gpu::GetVulkanFunctionPointers()->vkGetFenceStatusFn(device, fence);
+  return gpu::GetVulkanFunctionPointers()->vkGetFenceStatus(device, fence);
 }
 ALWAYS_INLINE void vkGetImageMemoryRequirements(
     VkDevice device,
     VkImage image,
     VkMemoryRequirements* pMemoryRequirements) {
-  return gpu::GetVulkanFunctionPointers()->vkGetImageMemoryRequirementsFn(
+  return gpu::GetVulkanFunctionPointers()->vkGetImageMemoryRequirements(
       device, image, pMemoryRequirements);
 }
+ALWAYS_INLINE void vkGetImageMemoryRequirements2(
+    VkDevice device,
+    const VkImageMemoryRequirementsInfo2* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements) {
+  return gpu::GetVulkanFunctionPointers()->vkGetImageMemoryRequirements2(
+      device, pInfo, pMemoryRequirements);
+}
 ALWAYS_INLINE VkResult vkMapMemory(VkDevice device,
                                    VkDeviceMemory memory,
                                    VkDeviceSize offset,
                                    VkDeviceSize size,
                                    VkMemoryMapFlags flags,
                                    void** ppData) {
-  return gpu::GetVulkanFunctionPointers()->vkMapMemoryFn(device, memory, offset,
-                                                         size, flags, ppData);
+  return gpu::GetVulkanFunctionPointers()->vkMapMemory(device, memory, offset,
+                                                       size, flags, ppData);
 }
 ALWAYS_INLINE VkResult vkQueueSubmit(VkQueue queue,
                                      uint32_t submitCount,
                                      const VkSubmitInfo* pSubmits,
                                      VkFence fence) {
-  return gpu::GetVulkanFunctionPointers()->vkQueueSubmitFn(queue, submitCount,
-                                                           pSubmits, fence);
+  return gpu::GetVulkanFunctionPointers()->vkQueueSubmit(queue, submitCount,
+                                                         pSubmits, fence);
 }
 ALWAYS_INLINE VkResult vkQueueWaitIdle(VkQueue queue) {
-  return gpu::GetVulkanFunctionPointers()->vkQueueWaitIdleFn(queue);
+  return gpu::GetVulkanFunctionPointers()->vkQueueWaitIdle(queue);
 }
 ALWAYS_INLINE VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer,
                                             VkCommandBufferResetFlags flags) {
-  return gpu::GetVulkanFunctionPointers()->vkResetCommandBufferFn(commandBuffer,
-                                                                  flags);
+  return gpu::GetVulkanFunctionPointers()->vkResetCommandBuffer(commandBuffer,
+                                                                flags);
 }
 ALWAYS_INLINE VkResult vkResetFences(VkDevice device,
                                      uint32_t fenceCount,
                                      const VkFence* pFences) {
-  return gpu::GetVulkanFunctionPointers()->vkResetFencesFn(device, fenceCount,
-                                                           pFences);
+  return gpu::GetVulkanFunctionPointers()->vkResetFences(device, fenceCount,
+                                                         pFences);
 }
 ALWAYS_INLINE void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
-  return gpu::GetVulkanFunctionPointers()->vkUnmapMemoryFn(device, memory);
+  return gpu::GetVulkanFunctionPointers()->vkUnmapMemory(device, memory);
 }
 ALWAYS_INLINE void vkUpdateDescriptorSets(
     VkDevice device,
@@ -905,7 +929,7 @@ ALWAYS_INLINE void vkUpdateDescriptorSets(
     const VkWriteDescriptorSet* pDescriptorWrites,
     uint32_t descriptorCopyCount,
     const VkCopyDescriptorSet* pDescriptorCopies) {
-  return gpu::GetVulkanFunctionPointers()->vkUpdateDescriptorSetsFn(
+  return gpu::GetVulkanFunctionPointers()->vkUpdateDescriptorSets(
       device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
       pDescriptorCopies);
 }
@@ -914,39 +938,18 @@ ALWAYS_INLINE VkResult vkWaitForFences(VkDevice device,
                                        const VkFence* pFences,
                                        VkBool32 waitAll,
                                        uint64_t timeout) {
-  return gpu::GetVulkanFunctionPointers()->vkWaitForFencesFn(
+  return gpu::GetVulkanFunctionPointers()->vkWaitForFences(
       device, fenceCount, pFences, waitAll, timeout);
 }
 
-ALWAYS_INLINE void vkGetDeviceQueue2(VkDevice device,
-                                     const VkDeviceQueueInfo2* pQueueInfo,
-                                     VkQueue* pQueue) {
-  return gpu::GetVulkanFunctionPointers()->vkGetDeviceQueue2Fn(
-      device, pQueueInfo, pQueue);
-}
-ALWAYS_INLINE void vkGetBufferMemoryRequirements2(
-    VkDevice device,
-    const VkBufferMemoryRequirementsInfo2* pInfo,
-    VkMemoryRequirements2* pMemoryRequirements) {
-  return gpu::GetVulkanFunctionPointers()->vkGetBufferMemoryRequirements2Fn(
-      device, pInfo, pMemoryRequirements);
-}
-ALWAYS_INLINE void vkGetImageMemoryRequirements2(
-    VkDevice device,
-    const VkImageMemoryRequirementsInfo2* pInfo,
-    VkMemoryRequirements2* pMemoryRequirements) {
-  return gpu::GetVulkanFunctionPointers()->vkGetImageMemoryRequirements2Fn(
-      device, pInfo, pMemoryRequirements);
-}
-
 #if defined(OS_ANDROID)
 ALWAYS_INLINE VkResult vkGetAndroidHardwareBufferPropertiesANDROID(
     VkDevice device,
     const struct AHardwareBuffer* buffer,
     VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
   return gpu::GetVulkanFunctionPointers()
-      ->vkGetAndroidHardwareBufferPropertiesANDROIDFn(device, buffer,
-                                                      pProperties);
+      ->vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer,
+                                                    pProperties);
 }
 #endif  // defined(OS_ANDROID)
 
@@ -955,13 +958,13 @@ ALWAYS_INLINE VkResult
 vkGetSemaphoreFdKHR(VkDevice device,
                     const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
                     int* pFd) {
-  return gpu::GetVulkanFunctionPointers()->vkGetSemaphoreFdKHRFn(
-      device, pGetFdInfo, pFd);
+  return gpu::GetVulkanFunctionPointers()->vkGetSemaphoreFdKHR(device,
+                                                               pGetFdInfo, pFd);
 }
 ALWAYS_INLINE VkResult vkImportSemaphoreFdKHR(
     VkDevice device,
     const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
-  return gpu::GetVulkanFunctionPointers()->vkImportSemaphoreFdKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkImportSemaphoreFdKHR(
       device, pImportSemaphoreFdInfo);
 }
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
@@ -971,14 +974,14 @@ ALWAYS_INLINE VkResult vkGetSemaphoreWin32HandleKHR(
     VkDevice device,
     const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
     HANDLE* pHandle) {
-  return gpu::GetVulkanFunctionPointers()->vkGetSemaphoreWin32HandleKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkGetSemaphoreWin32HandleKHR(
       device, pGetWin32HandleInfo, pHandle);
 }
 ALWAYS_INLINE VkResult
 vkImportSemaphoreWin32HandleKHR(VkDevice device,
                                 const VkImportSemaphoreWin32HandleInfoKHR*
                                     pImportSemaphoreWin32HandleInfo) {
-  return gpu::GetVulkanFunctionPointers()->vkImportSemaphoreWin32HandleKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkImportSemaphoreWin32HandleKHR(
       device, pImportSemaphoreWin32HandleInfo);
 }
 #endif  // defined(OS_WIN)
@@ -987,15 +990,15 @@ vkImportSemaphoreWin32HandleKHR(VkDevice device,
 ALWAYS_INLINE VkResult vkGetMemoryFdKHR(VkDevice device,
                                         const VkMemoryGetFdInfoKHR* pGetFdInfo,
                                         int* pFd) {
-  return gpu::GetVulkanFunctionPointers()->vkGetMemoryFdKHRFn(device,
-                                                              pGetFdInfo, pFd);
+  return gpu::GetVulkanFunctionPointers()->vkGetMemoryFdKHR(device, pGetFdInfo,
+                                                            pFd);
 }
 ALWAYS_INLINE VkResult
 vkGetMemoryFdPropertiesKHR(VkDevice device,
                            VkExternalMemoryHandleTypeFlagBits handleType,
                            int fd,
                            VkMemoryFdPropertiesKHR* pMemoryFdProperties) {
-  return gpu::GetVulkanFunctionPointers()->vkGetMemoryFdPropertiesKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkGetMemoryFdPropertiesKHR(
       device, handleType, fd, pMemoryFdProperties);
 }
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
@@ -1005,7 +1008,7 @@ ALWAYS_INLINE VkResult vkGetMemoryWin32HandleKHR(
     VkDevice device,
     const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
     HANDLE* pHandle) {
-  return gpu::GetVulkanFunctionPointers()->vkGetMemoryWin32HandleKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkGetMemoryWin32HandleKHR(
       device, pGetWin32HandleInfo, pHandle);
 }
 ALWAYS_INLINE VkResult vkGetMemoryWin32HandlePropertiesKHR(
@@ -1013,33 +1016,32 @@ ALWAYS_INLINE VkResult vkGetMemoryWin32HandlePropertiesKHR(
     VkExternalMemoryHandleTypeFlagBits handleType,
     HANDLE handle,
     VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) {
-  return gpu::GetVulkanFunctionPointers()
-      ->vkGetMemoryWin32HandlePropertiesKHRFn(device, handleType, handle,
-                                              pMemoryWin32HandleProperties);
+  return gpu::GetVulkanFunctionPointers()->vkGetMemoryWin32HandlePropertiesKHR(
+      device, handleType, handle, pMemoryWin32HandleProperties);
 }
 #endif  // defined(OS_WIN)
 
 #if defined(OS_FUCHSIA)
 #define vkImportSemaphoreZirconHandleFUCHSIA \
-  gpu::GetVulkanFunctionPointers()->vkImportSemaphoreZirconHandleFUCHSIAFn
+  gpu::GetVulkanFunctionPointers()->vkImportSemaphoreZirconHandleFUCHSIA
 #define vkGetSemaphoreZirconHandleFUCHSIA \
-  gpu::GetVulkanFunctionPointers()->vkGetSemaphoreZirconHandleFUCHSIAFn
+  gpu::GetVulkanFunctionPointers()->vkGetSemaphoreZirconHandleFUCHSIA
 #endif  // defined(OS_FUCHSIA)
 
 #if defined(OS_FUCHSIA)
 #define vkGetMemoryZirconHandleFUCHSIA \
-  gpu::GetVulkanFunctionPointers()->vkGetMemoryZirconHandleFUCHSIAFn
+  gpu::GetVulkanFunctionPointers()->vkGetMemoryZirconHandleFUCHSIA
 #endif  // defined(OS_FUCHSIA)
 
 #if defined(OS_FUCHSIA)
 #define vkCreateBufferCollectionFUCHSIA \
-  gpu::GetVulkanFunctionPointers()->vkCreateBufferCollectionFUCHSIAFn
+  gpu::GetVulkanFunctionPointers()->vkCreateBufferCollectionFUCHSIA
 #define vkSetBufferCollectionConstraintsFUCHSIA \
-  gpu::GetVulkanFunctionPointers()->vkSetBufferCollectionConstraintsFUCHSIAFn
+  gpu::GetVulkanFunctionPointers()->vkSetBufferCollectionConstraintsFUCHSIA
 #define vkGetBufferCollectionPropertiesFUCHSIA \
-  gpu::GetVulkanFunctionPointers()->vkGetBufferCollectionPropertiesFUCHSIAFn
+  gpu::GetVulkanFunctionPointers()->vkGetBufferCollectionPropertiesFUCHSIA
 #define vkDestroyBufferCollectionFUCHSIA \
-  gpu::GetVulkanFunctionPointers()->vkDestroyBufferCollectionFUCHSIAFn
+  gpu::GetVulkanFunctionPointers()->vkDestroyBufferCollectionFUCHSIA
 #endif  // defined(OS_FUCHSIA)
 
 ALWAYS_INLINE VkResult vkAcquireNextImageKHR(VkDevice device,
@@ -1048,7 +1050,7 @@ ALWAYS_INLINE VkResult vkAcquireNextImageKHR(VkDevice device,
                                              VkSemaphore semaphore,
                                              VkFence fence,
                                              uint32_t* pImageIndex) {
-  return gpu::GetVulkanFunctionPointers()->vkAcquireNextImageKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkAcquireNextImageKHR(
       device, swapchain, timeout, semaphore, fence, pImageIndex);
 }
 ALWAYS_INLINE VkResult
@@ -1056,27 +1058,27 @@ vkCreateSwapchainKHR(VkDevice device,
                      const VkSwapchainCreateInfoKHR* pCreateInfo,
                      const VkAllocationCallbacks* pAllocator,
                      VkSwapchainKHR* pSwapchain) {
-  return gpu::GetVulkanFunctionPointers()->vkCreateSwapchainKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkCreateSwapchainKHR(
       device, pCreateInfo, pAllocator, pSwapchain);
 }
 ALWAYS_INLINE void vkDestroySwapchainKHR(
     VkDevice device,
     VkSwapchainKHR swapchain,
     const VkAllocationCallbacks* pAllocator) {
-  return gpu::GetVulkanFunctionPointers()->vkDestroySwapchainKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkDestroySwapchainKHR(
       device, swapchain, pAllocator);
 }
 ALWAYS_INLINE VkResult vkGetSwapchainImagesKHR(VkDevice device,
                                                VkSwapchainKHR swapchain,
                                                uint32_t* pSwapchainImageCount,
                                                VkImage* pSwapchainImages) {
-  return gpu::GetVulkanFunctionPointers()->vkGetSwapchainImagesKHRFn(
+  return gpu::GetVulkanFunctionPointers()->vkGetSwapchainImagesKHR(
       device, swapchain, pSwapchainImageCount, pSwapchainImages);
 }
 ALWAYS_INLINE VkResult vkQueuePresentKHR(VkQueue queue,
                                          const VkPresentInfoKHR* pPresentInfo) {
-  return gpu::GetVulkanFunctionPointers()->vkQueuePresentKHRFn(queue,
-                                                               pPresentInfo);
+  return gpu::GetVulkanFunctionPointers()->vkQueuePresentKHR(queue,
+                                                             pPresentInfo);
 }
 
 #endif  // GPU_VULKAN_VULKAN_FUNCTION_POINTERS_H_
\ No newline at end of file