WSI: sed-generated changes to WSI code (not all that's needed).

Conflicts:
	demos/cube.c
	demos/tri.c
	demos/vulkaninfo.c
	icd/common/icd.h
	loader/loader.h

16 files changed, 150 insertions, 145 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 34bb6a97..f0e393ad 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -41,9 +41,10 @@
 #endif // _WIN32
 
 #include <vulkan/vulkan.h>
-#include <vulkan/vk_ext_khr_swapchain.h>
-#include <vulkan/vk_ext_khr_device_swapchain.h>
-#include <vulkan/vk_lunarg_debug_report.h>
+
+#include <vulkan/VK_KHR_surface.h>
+#include <vulkan/VK_KHR_swapchain.h>
+#include "vulkan/vk_lunarg_debug_report.h"
 
 #include <vulkan/vk_sdk_platform.h>
 #include "linmath.h"
@@ -338,9 +339,9 @@ struct demo {
     VkColorSpaceKHR color_space;
 
     PFN_vkGetPhysicalDeviceSurfaceSupportKHR fpGetPhysicalDeviceSurfaceSupportKHR;
-    PFN_vkGetSurfacePropertiesKHR fpGetSurfacePropertiesKHR;
-    PFN_vkGetSurfaceFormatsKHR fpGetSurfaceFormatsKHR;
-    PFN_vkGetSurfacePresentModesKHR fpGetSurfacePresentModesKHR;
+    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fpGetPhysicalDeviceSurfaceCapabilitiesKHR;
+    PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fpGetPhysicalDeviceSurfaceFormatsKHR;
+    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fpGetPhysicalDeviceSurfacePresentModesKHR;
     PFN_vkCreateSwapchainKHR fpCreateSwapchainKHR;
     PFN_vkDestroySwapchainKHR fpDestroySwapchainKHR;
     PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
@@ -600,7 +601,7 @@ static void demo_draw_build_cmd(struct demo *demo, VkCommandBuffer cmd_buf)
         .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
         .dstAccessMask = 0,
         .oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-        .newLayout = VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR,
+        .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
         .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
         .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
         .subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 }
@@ -679,7 +680,7 @@ static void demo_draw(struct demo *demo)
     // we need to set the image layout back to COLOR_ATTACHMENT_OPTIMAL
     demo_set_image_layout(demo, demo->buffers[demo->current_buffer].image,
                            VK_IMAGE_ASPECT_COLOR_BIT,
-                           VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR,
+                           VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
                            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
     demo_flush_init_cmd(demo);
 
@@ -688,7 +689,7 @@ static void demo_draw(struct demo *demo)
     // engine has fully released ownership to the application, and it is
     // okay to render to the image.
 
-// FIXME/TODO: DEAL WITH VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR
+// FIXME/TODO: DEAL WITH VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
     VkSubmitInfo submit_info = {
         .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
         .pNext = NULL,
@@ -736,21 +737,21 @@ static void demo_prepare_buffers(struct demo *demo)
     VkSwapchainKHR oldSwapchain = demo->swapchain;
 
     // Check the surface properties and formats
-    VkSurfacePropertiesKHR surfProperties;
-    err = demo->fpGetSurfacePropertiesKHR(demo->device,
+    VkSurfaceCapabilitiesKHR surfProperties;
+    err = demo->fpGetPhysicalDeviceSurfaceCapabilitiesKHR(demo->device,
         (const VkSurfaceDescriptionKHR *)&demo->surface_description,
         &surfProperties);
     assert(!err);
 
     uint32_t presentModeCount;
-    err = demo->fpGetSurfacePresentModesKHR(demo->device,
+    err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->device,
         (const VkSurfaceDescriptionKHR *)&demo->surface_description,
         &presentModeCount, NULL);
     assert(!err);
     VkPresentModeKHR *presentModes =
         (VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
     assert(presentModes);
-    err = demo->fpGetSurfacePresentModesKHR(demo->device,
+    err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->device,
         (const VkSurfaceDescriptionKHR *)&demo->surface_description,
         &presentModeCount, presentModes);
     assert(!err);
@@ -879,12 +880,12 @@ static void demo_prepare_buffers(struct demo *demo)
 
         demo->buffers[i].image = swapchainImages[i];
 
-        // Render loop will expect image to have been used before and in VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR
+        // Render loop will expect image to have been used before and in VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
         // layout and will change to COLOR_ATTACHMENT_OPTIMAL, so init the image to that state
         demo_set_image_layout(demo, demo->buffers[i].image,
                                VK_IMAGE_ASPECT_COLOR_BIT,
                                VK_IMAGE_LAYOUT_UNDEFINED,
-                               VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR);
+                               VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
 
         color_image_view.image = demo->buffers[i].image;
 
@@ -2167,9 +2168,9 @@ static void demo_init_vk(struct demo *demo)
     err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, instance_extensions);
     assert(!err);
     for (uint32_t i = 0; i < instance_extension_count; i++) {
-        if (!strcmp("VK_EXT_KHR_swapchain", instance_extensions[i].extensionName)) {
+        if (!strcmp(VK_KHR_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
             swapchainExtFound = 1;
-            extension_names[enabled_extension_count++] = "VK_EXT_KHR_swapchain";
+            extension_names[enabled_extension_count++] = VK_KHR_SURFACE_EXTENSION_NAME;
         }
         if (!strcmp(VK_DEBUG_REPORT_EXTENSION_NAME, instance_extensions[i].extensionName)) {
             if (demo->validate) {
@@ -2180,7 +2181,7 @@ static void demo_init_vk(struct demo *demo)
     }
     if (!swapchainExtFound) {
         ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the "
-                 "\"VK_EXT_KHR_swapchain\" extension.\n\nDo you have a compatible "
+                 VK_KHR_SURFACE_EXTENSION_NAME" extension.\n\nDo you have a compatible "
                  "Vulkan installable client driver (ICD) installed?\nPlease "
                  "look at the Getting Started guide for additional "
                  "information.\n",
@@ -2276,15 +2277,15 @@ static void demo_init_vk(struct demo *demo)
     assert(!err);
 
     for (uint32_t i = 0; i < device_extension_count; i++) {
-        if (!strcmp("VK_EXT_KHR_device_swapchain", device_extensions[i].extensionName)) {
+        if (!strcmp(VK_KHR_SWAPCHAIN_EXTENSION_NAME, device_extensions[i].extensionName)) {
             swapchainExtFound = 1;
-            extension_names[enabled_extension_count++] = "VK_EXT_KHR_device_swapchain";
+            extension_names[enabled_extension_count++] = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
         }
         assert(enabled_extension_count < 64);
     }
     if (!swapchainExtFound) {
         ERR_EXIT("vkEnumerateDeviceExtensionProperties failed to find the "
-                 "\"VK_EXT_KHR_device_swapchain\" extension.\n\nDo you have a compatible "
+                 VK_KHR_SWAPCHAIN_EXTENSION_NAME" extension.\n\nDo you have a compatible "
                  "Vulkan installable client driver (ICD) installed?\nPlease "
                  "look at the Getting Started guide for additional "
                  "information.\n",
@@ -2380,9 +2381,9 @@ static void demo_init_vk(struct demo *demo)
     free(device_layers);
 
     GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportKHR);
-    GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePropertiesKHR);
-    GET_DEVICE_PROC_ADDR(demo->device, GetSurfaceFormatsKHR);
-    GET_DEVICE_PROC_ADDR(demo->device, GetSurfacePresentModesKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, GetPhysicalDeviceSurfaceCapabilitiesKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, GetPhysicalDeviceSurfaceFormatsKHR);
+    GET_DEVICE_PROC_ADDR(demo->device, GetPhysicalDeviceSurfacePresentModesKHR);
     GET_DEVICE_PROC_ADDR(demo->device, CreateSwapchainKHR);
     GET_DEVICE_PROC_ADDR(demo->device, DestroySwapchainKHR);
     GET_DEVICE_PROC_ADDR(demo->device, GetSwapchainImagesKHR);
@@ -2469,13 +2470,13 @@ static void demo_init_vk_swapchain(struct demo *demo)
 
     // Get the list of VkFormat's that are supported:
     uint32_t formatCount;
-    err = demo->fpGetSurfaceFormatsKHR(demo->device,
+    err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->device,
                                     (VkSurfaceDescriptionKHR *) &demo->surface_description,
                                     &formatCount, NULL);
     assert(!err);
     VkSurfaceFormatKHR *surfFormats =
         (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
-    err = demo->fpGetSurfaceFormatsKHR(demo->device,
+    err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->device,
                                     (VkSurfaceDescriptionKHR *) &demo->surface_description,
                                     &formatCount, surfFormats);
     assert(!err);
diff --git a/demos/tri.c b/demos/tri.c
index bd3cc6f1..ea35ee6b 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -48,9 +48,10 @@
 #endif // _WIN32
 
 #include <vulkan/vulkan.h>
-#include <vulkan/vk_lunarg_debug_report.h>
-#include <vulkan/vk_ext_khr_swapchain.h>
-#include <vulkan/vk_ext_khr_device_swapchain.h>
+
+#include "vulkan/vk_lunarg_debug_report.h"
+#include <vulkan/VK_KHR_surface.h>
+#include <vulkan/VK_KHR_swapchain.h>
 
 #define DEMO_TEXTURE_COUNT 1
 #define VERTEX_BUFFER_BIND_ID 0
@@ -187,9 +188,9 @@ struct demo {
     VkColorSpaceKHR color_space;
 
     PFN_vkGetPhysicalDeviceSurfaceSupportKHR fpGetPhysicalDeviceSurfaceSupportKHR;
-    PFN_vkGetSurfacePropertiesKHR fpGetSurfacePropertiesKHR;
-    PFN_vkGetSurfaceFormatsKHR fpGetSurfaceFormatsKHR;
-    PFN_vkGetSurfacePresentModesKHR fpGetSurfacePresentModesKHR;
+    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fpGetPhysicalDeviceSurfaceCapabilitiesKHR;
+    PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fpGetPhysicalDeviceSurfaceFormatsKHR;
+    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fpGetPhysicalDeviceSurfacePresentModesKHR;
     PFN_vkCreateSwapchainKHR fpCreateSwapchainKHR;
     PFN_vkDestroySwapchainKHR fpDestroySwapchainKHR;
     PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
@@ -446,7 +447,7 @@ static void demo_draw_build_cmd(struct demo *demo)
         .srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
         .dstAccessMask = 0,
         .oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-        .newLayout = VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR,
+        .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
         .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
         .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
         .subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 }
@@ -500,7 +501,7 @@ static void demo_draw(struct demo *demo)
     // we need to set the image layout back to COLOR_ATTACHMENT_OPTIMAL
     demo_set_image_layout(demo, demo->buffers[demo->current_buffer].image,
                            VK_IMAGE_ASPECT_COLOR_BIT,
-                           VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR,
+                           VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
                            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
     demo_flush_init_cmd(demo);
 
@@ -509,7 +510,7 @@ static void demo_draw(struct demo *demo)
     // engine has fully released ownership to the application, and it is
     // okay to render to the image.
 
-// FIXME/TODO: DEAL WITH VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR
+// FIXME/TODO: DEAL WITH VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
     demo_draw_build_cmd(demo);
     VkFence nullFence = VK_NULL_HANDLE;
 
@@ -560,21 +561,21 @@ static void demo_prepare_buffers(struct demo *demo)
     VkSwapchainKHR oldSwapchain = demo->swapchain;
 
     // Check the surface proprties and formats
-    VkSurfacePropertiesKHR surfProperties;
-    err = demo->fpGetSurfacePropertiesKHR(demo->device,
+    VkSurfaceCapabilitiesKHR surfProperties;
+    err = demo->fpGetPhysicalDeviceSurfaceCapabilitiesKHR(demo->device,
         (const VkSurfaceDescriptionKHR *)&demo->surface_description,
         &surfProperties);
     assert(!err);
 
     uint32_t presentModeCount;
-    err = demo->fpGetSurfacePresentModesKHR(demo->device,
+    err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->device,
         (const VkSurfaceDescriptionKHR *)&demo->surface_description,
         &presentModeCount, NULL);
     assert(!err);
     VkPresentModeKHR *presentModes =
         (VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
     assert(presentModes);
-    err = demo->fpGetSurfacePresentModesKHR(demo->device,
+    err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->device,
         (const VkSurfaceDescriptionKHR *)&demo->surface_description,
         &presentModeCount, presentModes);
     assert(!err);
@@ -689,12 +690,12 @@ static void demo_prepare_buffers(struct demo *demo)
 
         demo->buffers[i].image = swapchainImages[i];
 
-        // Render loop will expect image to have been used before and in VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR
+        // Render loop will expect image to have been used before and in VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
         // layout and will change to COLOR_ATTACHMENT_OPTIMAL, so init the image to that state
         demo_set_image_layout(demo, demo->buffers[i].image,
                                VK_IMAGE_ASPECT_COLOR_BIT,
                                VK_IMAGE_LAYOUT_UNDEFINED,
-                               VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR);
+                               VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
 
         color_attachment_view.image = demo->buffers[i].image;
 
@@ -1763,9 +1764,9 @@ static void demo_init_vk(struct demo *demo)
     err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, instance_extensions);
     assert(!err);
     for (uint32_t i = 0; i < instance_extension_count; i++) {
-        if (!strcmp("VK_EXT_KHR_swapchain", instance_extensions[i].extensionName)) {
+        if (!strcmp(VK_KHR_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
             swapchainExtFound = 1;
-            extension_names[enabled_extension_count++] = "VK_EXT_KHR_swapchain";
+            extension_names[enabled_extension_count++] = VK_KHR_SURFACE_EXTENSION_NAME;
         }
         if (!strcmp(VK_DEBUG_REPORT_EXTENSION_NAME, instance_extensions[i].extensionName)) {
             if (demo->validate) {
@@ -1776,7 +1777,7 @@ static void demo_init_vk(struct demo *demo)
     }
     if (!swapchainExtFound) {
         ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the "
-                 "\"VK_EXT_KHR_swapchain\" extension.\n\nDo you have a compatible "
+                 VK_KHR_SURFACE_EXTENSION_NAME" extension.\n\nDo you have a compatible "
                  "Vulkan installable client driver (ICD) installed?\nPlease "
                  "look at the Getting Started guide for additional "
                  "information.\n",
@@ -1882,15 +1883,15 @@ static void demo_init_vk(struct demo *demo)
     assert(!err);
 
     for (uint32_t i = 0; i < device_extension_count; i++) {
-        if (!strcmp("VK_EXT_KHR_device_swapchain", device_extensions[i].extensionName)) {
+        if (!strcmp(VK_KHR_SWAPCHAIN_EXTENSION_NAME, device_extensions[i].extensionName)) {
             swapchainExtFound = 1;
-            extension_names[enabled_extension_count++] = "VK_EXT_KHR_device_swapchain";
+            extension_names[enabled_extension_count++] = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
         }
         assert(enabled_extension_count < 64);
     }
     if (!swapchainExtFound) {
         ERR_EXIT("vkEnumerateDeviceExtensionProperties failed to find the "
-                 "\"VK_EXT_KHR_device_swapchain\" extension.\n\nDo you have a compatible "
+                 VK_KHR_SWAPCHAIN_EXTENSION_NAME" extension.\n\nDo you have a compatible "
                  "Vulkan installable client driver (ICD) installed?\nPlease "
                  "look at the Getting Started guide for additional "
                  "information.\n",
@@ -1935,15 +1936,14 @@ static void demo_init_vk(struct demo *demo)
 
     // Having these GIPA queries of device extension entry points both
     // BEFORE and AFTER vkCreateDevice is a good test for the loader
-    GET_INSTANCE_PROC_ADDR(demo->inst, GetSurfacePropertiesKHR);
-    GET_INSTANCE_PROC_ADDR(demo->inst, GetSurfaceFormatsKHR);
-    GET_INSTANCE_PROC_ADDR(demo->inst, GetSurfacePresentModesKHR);
+    GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceCapabilitiesKHR);
+    GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceFormatsKHR);
+    GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfacePresentModesKHR);
 
     err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device);
     assert(!err);
 
     GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportKHR);
-
     GET_INSTANCE_PROC_ADDR(demo->inst, CreateSwapchainKHR);
     GET_INSTANCE_PROC_ADDR(demo->inst, DestroySwapchainKHR);
     GET_INSTANCE_PROC_ADDR(demo->inst, GetSwapchainImagesKHR);
@@ -2043,13 +2043,13 @@ static void demo_init_vk_swapchain(struct demo *demo)
 
     // Get the list of VkFormat's that are supported:
     uint32_t formatCount;
-    err = demo->fpGetSurfaceFormatsKHR(demo->device,
+    err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->device,
                                     (VkSurfaceDescriptionKHR *) &demo->surface_description,
                                     &formatCount, NULL);
     assert(!err);
     VkSurfaceFormatKHR *surfFormats =
         (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
-    err = demo->fpGetSurfaceFormatsKHR(demo->device,
+    err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->device,
                                     (VkSurfaceDescriptionKHR *) &demo->surface_description,
                                     &formatCount, surfFormats);
     assert(!err);
diff --git a/demos/vulkaninfo.c b/demos/vulkaninfo.c
index d56239bc..95a60d67 100644
--- a/demos/vulkaninfo.c
+++ b/demos/vulkaninfo.c
@@ -37,8 +37,9 @@
 #include <io.h>
 #endif
 
-#include <vulkan/vk_ext_khr_swapchain.h>
-#include <vulkan/vk_ext_khr_device_swapchain.h>
+
+#include "vulkan/VK_KHR_surface.h"
+#include "vulkan/VK_KHR_swapchain.h"
 
 #include <vulkan/vulkan.h>
 
@@ -414,7 +415,7 @@ static void app_dev_init(struct app_dev *dev, struct app_gpu *gpu)
     VkResult U_ASSERT_ONLY err;
     // Extensions to enable
     static const char *known_extensions[] = {
-        VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME,
+        VK_KHR_SWAPCHAIN_EXTENSION_NAME,
     };
 
     uint32_t count = 0;
@@ -556,7 +557,7 @@ static void app_create_instance(struct app_instance *inst)
     VkResult U_ASSERT_ONLY err;
     // Global Extensions to enable
     static char *known_extensions[] = {
-        "VK_EXT_KHR_swapchain",
+        VK_KHR_SURFACE_EXTENSION_NAME,
     };
 
     uint32_t global_extension_count = 0;
diff --git a/icd/common/icd.h b/icd/common/icd.h
index 6046710c..20726d93 100644
--- a/icd/common/icd.h
+++ b/icd/common/icd.h
@@ -30,11 +30,13 @@
 #ifndef ICD_H
 #define ICD_H
 
-#include "vulkan/vulkan.h"
-#include "vulkan/vk_platform.h"
-#include "vulkan/vk_lunarg_debug_report.h"
-#include "vulkan/vk_ext_khr_swapchain.h"
-#include "vulkan/vk_ext_khr_device_swapchain.h"
+
+#include <vulkan/vulkan.h>
+#include <vulkan/vk_platform.h>
+#include <vulkan/vk_lunarg_debug_report.h>
+#include "vulkan/VK_KHR_surface.h"
+#include "vulkan/VK_KHR_swapchain.h"
+
 #include "vulkan/vk_sdk_platform.h"
 
 #if defined(__GNUC__) && __GNUC__ >= 4
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 108e3ee2..f4e13917 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -44,12 +44,12 @@
 
 // The null driver supports all WSI extenstions ... for now ...
 static const char * const nulldrv_gpu_exts[NULLDRV_EXT_COUNT] = {
-	[NULLDRV_EXT_KHR_SWAPCHAIN] = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME,
+	[NULLDRV_EXT_KHR_SWAPCHAIN] = VK_KHR_SURFACE_EXTENSION_NAME,
 };
 static const VkExtensionProperties intel_gpu_exts[NULLDRV_EXT_COUNT] = {
     {
-        .extensionName = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME,
-        .specVersion = VK_EXT_KHR_SWAPCHAIN_REVISION,
+        .extensionName = VK_KHR_SURFACE_EXTENSION_NAME,
+        .specVersion = VK_KHR_SURFACE_REVISION,
     }
 };
 
@@ -811,17 +811,17 @@ ICD_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
     return VK_SUCCESS;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfacePropertiesKHR(
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
     VkDevice                                 device,
     const VkSurfaceDescriptionKHR*           pSurfaceDescription,
-    VkSurfacePropertiesKHR*                  pSurfaceProperties)
+    VkSurfaceCapabilitiesKHR*                pSurfaceProperties)
 {
     NULLDRV_LOG_FUNC;
 
     return VK_SUCCESS;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfaceFormatsKHR(
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
     VkDevice                                 device,
     const VkSurfaceDescriptionKHR*           pSurfaceDescription,
     uint32_t*                                pCount,
@@ -832,7 +832,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfaceFormatsKHR(
     return VK_SUCCESS;
 }
 
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfacePresentModesKHR(
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
     VkDevice                                 device,
     const VkSurfaceDescriptionKHR*           pSurfaceDescription,
     uint32_t*                                pCount,
diff --git a/icd/nulldrv/nulldrv.h b/icd/nulldrv/nulldrv.h
index 284f5e33..46711634 100644
--- a/icd/nulldrv/nulldrv.h
+++ b/icd/nulldrv/nulldrv.h
@@ -35,8 +35,8 @@
 #include <vulkan/vulkan.h>
 #include <vulkan/vk_lunarg_debug_report.h>
 #include <vulkan/vk_icd.h>
-#include "vulkan/vk_ext_khr_swapchain.h"
-#include "vulkan/vk_ext_khr_device_swapchain.h"
+#include "vulkan/VK_KHR_surface.h"
+#include "vulkan/VK_KHR_swapchain.h"
 
 #include "icd.h"
 
diff --git a/layers/apidump.h b/layers/apidump.h
index e5f4ff87..0cf6f3b1 100644
--- a/layers/apidump.h
+++ b/layers/apidump.h
@@ -68,9 +68,9 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     uint32_t i;
     VkLayerDispatchTable *pDisp  = device_dispatch_table(device);
     PFN_vkGetDeviceProcAddr gpa = pDisp->GetDeviceProcAddr;
-    pDisp->GetSurfacePropertiesKHR = (PFN_vkGetSurfacePropertiesKHR) gpa(device, "vkGetSurfacePropertiesKHR");
-    pDisp->GetSurfaceFormatsKHR = (PFN_vkGetSurfaceFormatsKHR) gpa(device, "vkGetSurfaceFormatsKHR");
-    pDisp->GetSurfacePresentModesKHR = (PFN_vkGetSurfacePresentModesKHR) gpa(device, "vkGetSurfacePresentModesKHR");
+    pDisp->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) gpa(device, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+    pDisp->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) gpa(device, "vkGetPhysicalDeviceSurfaceFormatsKHR");
+    pDisp->GetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR) gpa(device, "vkGetPhysicalDeviceSurfacePresentModesKHR");
     pDisp->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) gpa(device, "vkCreateSwapchainKHR");
     pDisp->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) gpa(device, "vkDestroySwapchainKHR");
     pDisp->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) gpa(device, "vkGetSwapchainImagesKHR");
@@ -79,7 +79,7 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
 
     deviceExtMap[pDisp].wsi_enabled = false;
     for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
             deviceExtMap[pDisp].wsi_enabled = true;
 
     }
@@ -93,7 +93,7 @@ static void createInstanceRegisterExtensions(const VkInstanceCreateInfo* pCreate
     pDisp->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceSupportKHR");
     instanceExtMap[pDisp].wsi_enabled = false;
     for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].wsi_enabled = true;
 
     }
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 31640bf2..e6bc5aae 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1081,9 +1081,9 @@ createDeviceRegisterExtensions(
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkLayerDispatchTable *pDisp = my_device_data->device_dispatch_table;
     PFN_vkGetDeviceProcAddr gpa = pDisp->GetDeviceProcAddr;
-    pDisp->GetSurfacePropertiesKHR = (PFN_vkGetSurfacePropertiesKHR) gpa(device, "vkGetSurfacePropertiesKHR");
-    pDisp->GetSurfaceFormatsKHR = (PFN_vkGetSurfaceFormatsKHR) gpa(device, "vkGetSurfaceFormatsKHR");
-    pDisp->GetSurfacePresentModesKHR = (PFN_vkGetSurfacePresentModesKHR) gpa(device, "vkGetSurfacePresentModesKHR");
+    pDisp->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) gpa(device, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+    pDisp->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) gpa(device, "vkGetPhysicalDeviceSurfaceFormatsKHR");
+    pDisp->GetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR) gpa(device, "vkGetPhysicalDeviceSurfacePresentModesKHR");
     pDisp->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) gpa(device, "vkCreateSwapchainKHR");
     pDisp->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) gpa(device, "vkDestroySwapchainKHR");
     pDisp->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) gpa(device, "vkGetSwapchainImagesKHR");
@@ -1091,7 +1091,7 @@ createDeviceRegisterExtensions(
     pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR");
     my_device_data->wsi_enabled = VK_FALSE;
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
             my_device_data->wsi_enabled = true;
     }
 }
diff --git a/layers/object_track.h b/layers/object_track.h
index f9991ba1..0b80fce1 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -190,9 +190,9 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkLayerDispatchTable *pDisp = get_dispatch_table(ObjectTracker_device_table_map, device);
     PFN_vkGetDeviceProcAddr gpa = pDisp->GetDeviceProcAddr;
-    pDisp->GetSurfacePropertiesKHR = (PFN_vkGetSurfacePropertiesKHR) gpa(device, "vkGetSurfacePropertiesKHR");
-    pDisp->GetSurfaceFormatsKHR = (PFN_vkGetSurfaceFormatsKHR) gpa(device, "vkGetSurfaceFormatsKHR");
-    pDisp->GetSurfacePresentModesKHR = (PFN_vkGetSurfacePresentModesKHR) gpa(device, "vkGetSurfacePresentModesKHR");
+    pDisp->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) gpa(device, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+    pDisp->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) gpa(device, "vkGetPhysicalDeviceSurfaceFormatsKHR");
+    pDisp->GetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR) gpa(device, "vkGetPhysicalDeviceSurfacePresentModesKHR");
     pDisp->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) gpa(device, "vkCreateSwapchainKHR");
     pDisp->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) gpa(device, "vkDestroySwapchainKHR");
     pDisp->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) gpa(device, "vkGetSwapchainImagesKHR");
@@ -200,7 +200,7 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR");
     my_device_data->wsi_enabled = false;
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
             my_device_data->wsi_enabled = true;
 
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], "OBJTRACK_EXTENSIONS") == 0)
@@ -216,7 +216,7 @@ static void createInstanceRegisterExtensions(const VkInstanceCreateInfo* pCreate
     pDisp->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceSupportKHR");
     instanceExtMap[pDisp].wsi_enabled = false;
     for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].wsi_enabled = true;
 
     }
@@ -270,8 +270,8 @@ objTypeToIndex(
 {
     uint32_t index = objType;
     if (objType > VK_OBJECT_TYPE_END_RANGE) {
-        // These come from vk_ext_khr_swapchain.h, rebase
-        index = (index -(VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NUMBER * -1000)) + VK_OBJECT_TYPE_END_RANGE;
+        // These come from VK_KHR_surface.h, rebase
+        index = (index -(VK_KHR_SWAPCHAIN_EXTENSION_NUMBER * -1000)) + VK_OBJECT_TYPE_END_RANGE;
     }
     return index;
 }
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 2c31b838..8a62f79a 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -46,9 +46,9 @@ static void createDeviceRegisterExtensions(VkPhysicalDevice physicalDevice, cons
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkLayerDispatchTable *pDisp  = my_data->device_dispatch_table;
     PFN_vkGetDeviceProcAddr gpa = pDisp->GetDeviceProcAddr;
-    pDisp->GetSurfacePropertiesKHR = (PFN_vkGetSurfacePropertiesKHR) gpa(device, "vkGetSurfacePropertiesKHR");
-    pDisp->GetSurfaceFormatsKHR = (PFN_vkGetSurfaceFormatsKHR) gpa(device, "vkGetSurfaceFormatsKHR");
-    pDisp->GetSurfacePresentModesKHR = (PFN_vkGetSurfacePresentModesKHR) gpa(device, "vkGetSurfacePresentModesKHR");
+    pDisp->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) gpa(device, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+    pDisp->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) gpa(device, "vkGetPhysicalDeviceSurfaceFormatsKHR");
+    pDisp->GetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR) gpa(device, "vkGetPhysicalDeviceSurfacePresentModesKHR");
     pDisp->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) gpa(device, "vkCreateSwapchainKHR");
     pDisp->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) gpa(device, "vkDestroySwapchainKHR");
     pDisp->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) gpa(device, "vkGetSwapchainImagesKHR");
@@ -77,7 +77,7 @@ static void createDeviceRegisterExtensions(VkPhysicalDevice physicalDevice, cons
     // No need to check if the extension was advertised by
     // vkEnumerateDeviceExtensionProperties(), since the loader handles that.
     for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
 
             my_data->deviceMap[device].deviceSwapchainExtensionEnabled = true;
         }
@@ -92,7 +92,7 @@ static void createInstanceRegisterExtensions(const VkInstanceCreateInfo* pCreate
     PFN_vkGetInstanceProcAddr gpa = pDisp->GetInstanceProcAddr;
     pDisp->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceSupportKHR");
 
-    // Remember this instance, and whether the VK_EXT_KHR_swapchain extension
+    // Remember this instance, and whether the VK_KHR_surface extension
     // was enabled for it:
     my_data->instanceMap[instance].instance = instance;
     my_data->instanceMap[instance].swapchainExtensionEnabled = false;
@@ -101,7 +101,7 @@ static void createInstanceRegisterExtensions(const VkInstanceCreateInfo* pCreate
     // VkInstance.  No need to check if the extension was advertised by
     // vkEnumerateInstanceExtensionProperties(), since the loader handles that.
     for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0) {
 
             my_data->instanceMap[instance].swapchainExtensionEnabled = true;
         }
@@ -396,7 +396,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupport
                               "VkInstance",
                               SWAPCHAIN_EXT_NOT_ENABLED_BUT_USED,
                               "%s() called even though the %s extension was not enabled for this VkInstance.",
-                              __FUNCTION__, VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME);
+                              __FUNCTION__, VK_KHR_SURFACE_EXTENSION_NAME);
     }
 
     if (VK_FALSE == skipCall) {
@@ -419,7 +419,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupport
     return VK_ERROR_VALIDATION_FAILED;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfacePropertiesKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, VkSurfacePropertiesKHR* pSurfaceProperties)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, VkSurfaceCapabilitiesKHR* pSurfaceProperties)
 {
     VkResult result = VK_SUCCESS;
     VkBool32 skipCall = VK_FALSE;
@@ -436,12 +436,12 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfacePropertiesKHR(VkDevic
         skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                               SWAPCHAIN_EXT_NOT_ENABLED_BUT_USED,
                               "%s() called even though the %s extension was not enabled for this VkDevice.",
-                              __FUNCTION__, VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME);
+                              __FUNCTION__, VK_KHR_SWAPCHAIN_EXTENSION_NAME);
     }
 
     if (VK_FALSE == skipCall) {
         // Call down the call chain:
-        result = my_data->device_dispatch_table->GetSurfacePropertiesKHR(
+        result = my_data->device_dispatch_table->GetPhysicalDeviceSurfaceCapabilitiesKHR(
                 device, pSurfaceDescription, pSurfaceProperties);
 
         if ((result == VK_SUCCESS) && pDevice) {
@@ -454,7 +454,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfacePropertiesKHR(VkDevic
     return VK_ERROR_VALIDATION_FAILED;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfaceFormatsKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats)
 {
     VkResult result = VK_SUCCESS;
     VkBool32 skipCall = VK_FALSE;
@@ -471,12 +471,12 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfaceFormatsKHR(VkDevice d
         skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                               SWAPCHAIN_EXT_NOT_ENABLED_BUT_USED,
                               "%s() called even though the %s extension was not enabled for this VkDevice.",
-                              __FUNCTION__, VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME);
+                              __FUNCTION__, VK_KHR_SWAPCHAIN_EXTENSION_NAME);
     }
 
     if (VK_FALSE == skipCall) {
         // Call down the call chain:
-        result = my_data->device_dispatch_table->GetSurfaceFormatsKHR(
+        result = my_data->device_dispatch_table->GetPhysicalDeviceSurfaceFormatsKHR(
                 device, pSurfaceDescription, pCount, pSurfaceFormats);
 
         if ((result == VK_SUCCESS) && pDevice && pSurfaceFormats && pCount &&
@@ -498,7 +498,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfaceFormatsKHR(VkDevice d
     return VK_ERROR_VALIDATION_FAILED;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfacePresentModesKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkPresentModeKHR* pPresentModes)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkPresentModeKHR* pPresentModes)
 {
     VkResult result = VK_SUCCESS;
     VkBool32 skipCall = VK_FALSE;
@@ -515,12 +515,12 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSurfacePresentModesKHR(VkDev
         skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                               SWAPCHAIN_EXT_NOT_ENABLED_BUT_USED,
                               "%s() called even though the %s extension was not enabled for this VkDevice.",
-                              __FUNCTION__, VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME);
+                              __FUNCTION__, VK_KHR_SWAPCHAIN_EXTENSION_NAME);
     }
 
     if (VK_FALSE == skipCall) {
         // Call down the call chain:
-        result = my_data->device_dispatch_table->GetSurfacePresentModesKHR(
+        result = my_data->device_dispatch_table->GetPhysicalDeviceSurfacePresentModesKHR(
                 device, pSurfaceDescription, pCount, pPresentModes);
 
         if ((result == VK_SUCCESS) && pDevice && pPresentModes && pCount &&
@@ -567,7 +567,7 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
         return LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                          SWAPCHAIN_EXT_NOT_ENABLED_BUT_USED,
                          "%s() called even though the %s extension was not enabled for this VkDevice.",
-                         fn, VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME );
+                         fn, VK_KHR_SWAPCHAIN_EXTENSION_NAME );
     }
 
     // Validate pCreateInfo with the results for previous queries:
@@ -575,12 +575,12 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
         skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                               SWAPCHAIN_CREATE_SWAP_WITHOUT_QUERY,
                               "%s() called before calling "
-                              "vkGetSurfacePropertiesKHR().",
+                              "vkGetPhysicalDeviceSurfaceCapabilitiesKHR().",
                               fn);
     } else {
         // Validate pCreateInfo->minImageCount against
-        // VkSurfacePropertiesKHR::{min|max}ImageCount:
-        VkSurfacePropertiesKHR *pProps = &pDevice->surfaceProperties;
+        // VkSurfaceCapabilitiesKHR::{min|max}ImageCount:
+        VkSurfaceCapabilitiesKHR *pProps = &pDevice->surfaceProperties;
         if ((pCreateInfo->minImageCount < pProps->minImageCount) ||
             ((pProps->maxImageCount > 0) &&
              (pCreateInfo->minImageCount > pProps->maxImageCount))) {
@@ -588,7 +588,7 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
                                   SWAPCHAIN_CREATE_SWAP_BAD_MIN_IMG_COUNT,
                                   "%s() called with pCreateInfo->minImageCount "
                                   "= %d, which is outside the bounds returned "
-                                  "by vkGetSurfacePropertiesKHR() (i.e. "
+                                  "by vkGetPhysicalDeviceSurfaceCapabilitiesKHR() (i.e. "
                                   "minImageCount = %d, maxImageCount = %d).",
                                   fn,
                                   pCreateInfo->minImageCount,
@@ -596,7 +596,7 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
                                   pProps->maxImageCount);
         }
         // Validate pCreateInfo->imageExtent against
-        // VkSurfacePropertiesKHR::{current|min|max}ImageExtent:
+        // VkSurfaceCapabilitiesKHR::{current|min|max}ImageExtent:
         if ((pProps->currentExtent.width == -1) &&
             ((pCreateInfo->imageExtent.width < pProps->minImageExtent.width) ||
              (pCreateInfo->imageExtent.width > pProps->maxImageExtent.width) ||
@@ -606,7 +606,7 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
                                   SWAPCHAIN_CREATE_SWAP_OUT_OF_BOUNDS_EXTENTS,
                                   "%s() called with pCreateInfo->imageExtent = "
                                   "(%d,%d), which is outside the bounds "
-                                  "returned by vkGetSurfacePropertiesKHR(): "
+                                  "returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR(): "
                                   "currentExtent = (%d,%d), minImageExtent = "
                                   "(%d,%d), maxImageExtent = (%d,%d).",
                                   fn,
@@ -627,7 +627,7 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
                                   "%s() called with pCreateInfo->imageExtent = "
                                   "(%d,%d), which is not equal to the "
                                   "currentExtent = (%d,%d) returned by "
-                                  "vkGetSurfacePropertiesKHR().",
+                                  "vkGetPhysicalDeviceSurfaceCapabilitiesKHR().",
                                   fn,
                                   pCreateInfo->imageExtent.width,
                                   pCreateInfo->imageExtent.height,
@@ -635,7 +635,7 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
                                   pProps->currentExtent.height);
         }
         // Validate pCreateInfo->preTransform against
-        // VkSurfacePropertiesKHR::supportedTransforms:
+        // VkSurfaceCapabilitiesKHR::supportedTransforms:
         if (!((1 << pCreateInfo->preTransform) & pProps->supportedTransforms)) {
             // This is an error situation; one for which we'd like to give
             // the developer a helpful, multi-line error message.  Build it
@@ -669,7 +669,7 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
                                              errorString.c_str());
         }
         // Validate pCreateInfo->imageArraySize against
-        // VkSurfacePropertiesKHR::maxImageArraySize:
+        // VkSurfaceCapabilitiesKHR::maxImageArraySize:
         if (pCreateInfo->imageArraySize <= pProps->maxImageArraySize) {
             skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                                   SWAPCHAIN_CREATE_SWAP_BAD_IMG_ARRAY_SIZE,
@@ -681,7 +681,7 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
                                   pProps->maxImageArraySize);
         }
         // Validate pCreateInfo->imageUsageFlags against
-        // VkSurfacePropertiesKHR::supportedUsageFlags:
+        // VkSurfaceCapabilitiesKHR::supportedUsageFlags:
         if (pCreateInfo->imageUsageFlags &&
             (pCreateInfo->imageUsageFlags !=
              (pCreateInfo->imageUsageFlags & pProps->supportedUsageFlags))) {
@@ -699,7 +699,7 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
         skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                               SWAPCHAIN_CREATE_SWAP_WITHOUT_QUERY,
                               "%s() called before calling "
-                              "vkGetSurfaceFormatsKHR().",
+                              "vkGetPhysicalDeviceSurfaceFormatsKHR().",
                               fn);
     } else {
         // Validate pCreateInfo->imageFormat against
@@ -757,11 +757,11 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
         skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                               SWAPCHAIN_CREATE_SWAP_WITHOUT_QUERY,
                               "%s() called before calling "
-                              "vkGetSurfacePresentModesKHR().",
+                              "vkGetPhysicalDeviceSurfacePresentModesKHR().",
                               fn);
     } else {
         // Validate pCreateInfo->presentMode against
-        // vkGetSurfacePresentModesKHR():
+        // vkGetPhysicalDeviceSurfacePresentModesKHR():
         bool foundMatch = false;
         for (uint32_t i = 0 ; i < pDevice->presentModeCount ; i++) {
             if (pDevice->pPresentModes[i] == pCreateInfo->presentMode) {
@@ -832,7 +832,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDestroySwapchainKHR(VkDevice de
         skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                               SWAPCHAIN_EXT_NOT_ENABLED_BUT_USED,
                               "%s() called even though the %s extension was not enabled for this VkDevice.",
-                              __FUNCTION__, VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME);
+                              __FUNCTION__, VK_KHR_SWAPCHAIN_EXTENSION_NAME);
     }
 
     // Regardless of skipCall value, do some internal cleanup:
@@ -884,7 +884,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice
         skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                               SWAPCHAIN_EXT_NOT_ENABLED_BUT_USED,
                               "%s() called even though the %s extension was not enabled for this VkDevice.",
-                              __FUNCTION__, VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME);
+                              __FUNCTION__, VK_KHR_SWAPCHAIN_EXTENSION_NAME);
     }
     SwpSwapchain *pSwapchain = &my_data->swapchainMap[swapchain];
     if (!pSwapchain) {
@@ -938,7 +938,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice de
         skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                               SWAPCHAIN_EXT_NOT_ENABLED_BUT_USED,
                               "%s() called even though the %s extension was not enabled for this VkDevice.",
-                              __FUNCTION__, VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME);
+                              __FUNCTION__, VK_KHR_SWAPCHAIN_EXTENSION_NAME);
     }
     // Validate that a valid VkSwapchainKHR was used:
     SwpSwapchain *pSwapchain = &my_data->swapchainMap[swapchain];
@@ -1012,7 +1012,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue,
                                       pSwapchain->pDevice, "VkDevice",
                                       SWAPCHAIN_EXT_NOT_ENABLED_BUT_USED,
                                       "%s() called even though the %s extension was not enabled for this VkDevice.",
-                                      __FUNCTION__, VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME);
+                                      __FUNCTION__, VK_KHR_SWAPCHAIN_EXTENSION_NAME);
             }
             if (index >= pSwapchain->imageCount) {
                 skipCall |= LOG_ERROR(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
@@ -1145,12 +1145,12 @@ VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkD
     if (my_data->deviceMap.size() != 0 &&
         my_data->deviceMap[device].deviceSwapchainExtensionEnabled)
     {
-        if (!strcmp("vkGetSurfacePropertiesKHR", funcName))
-            return reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfacePropertiesKHR);
-        if (!strcmp("vkGetSurfaceFormatsKHR", funcName))
-            return reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfaceFormatsKHR);
-        if (!strcmp("vkGetSurfacePresentModesKHR", funcName))
-            return reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfacePresentModesKHR);
+        if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", funcName))
+            return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
+        if (!strcmp("vkGetPhysicalDeviceSurfaceFormatsKHR", funcName))
+            return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceFormatsKHR);
+        if (!strcmp("vkGetPhysicalDeviceSurfacePresentModesKHR", funcName))
+            return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfacePresentModesKHR);
         if (!strcmp("vkCreateSwapchainKHR", funcName))
             return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR);
         if (!strcmp("vkDestroySwapchainKHR", funcName))
diff --git a/layers/swapchain.h b/layers/swapchain.h
index da918ca0..a3608a98 100644
--- a/layers/swapchain.h
+++ b/layers/swapchain.h
@@ -62,7 +62,7 @@ typedef enum _SWAPCHAIN_ERROR
     SWAPCHAIN_INVALID_HANDLE,                   // Handle used that isn't currently valid
     SWAPCHAIN_EXT_NOT_ENABLED_BUT_USED,         // Did not enable WSI extension, but called WSI function 
     SWAPCHAIN_DEL_DEVICE_BEFORE_SWAPCHAINS,     // Called vkDestroyDevice() before vkDestroySwapchainKHR()
-    SWAPCHAIN_CREATE_SWAP_WITHOUT_QUERY,        // Called vkCreateSwapchainKHR() without calling a query (e.g. vkGetSurfacePropertiesKHR())
+    SWAPCHAIN_CREATE_SWAP_WITHOUT_QUERY,        // Called vkCreateSwapchainKHR() without calling a query (e.g. vkGetPhysicalDeviceSurfaceCapabilitiesKHR())
     SWAPCHAIN_CREATE_SWAP_BAD_MIN_IMG_COUNT,    // Called vkCreateSwapchainKHR() with out-of-bounds minImageCount
     SWAPCHAIN_CREATE_SWAP_OUT_OF_BOUNDS_EXTENTS,// Called vkCreateSwapchainKHR() with out-of-bounds imageExtent
     SWAPCHAIN_CREATE_SWAP_EXTENTS_NO_MATCH_WIN, // Called vkCreateSwapchainKHR() with imageExtent that doesn't match window's extent
@@ -126,7 +126,7 @@ struct _SwpInstance {
     // remembered:
     unordered_map<const void*, SwpPhysicalDevice*> physicalDevices;
 
-    // Set to true if "VK_EXT_KHR_swapchain" was enabled for this VkInstance:
+    // Set to true if VK_KHR_SURFACE_EXTENSION_NAME was enabled for this VkInstance:
     bool swapchainExtensionEnabled;
 
     // TODO: Add additional booleans for platform-specific extensions:
@@ -155,24 +155,24 @@ struct _SwpDevice {
     // Corresponding VkPhysicalDevice (and info) to this VkDevice:
     SwpPhysicalDevice *pPhysicalDevice;
 
-    // Set to true if "VK_EXT_KHR_device_swapchain" was enabled:
+    // Set to true if VK_KHR_SWAPCHAIN_EXTENSION_NAME was enabled:
     bool deviceSwapchainExtensionEnabled;
 
 // TODO: Record/use this info per-surface, not per-device, once a
 // non-dispatchable surface object is added to WSI:
-    // Results of vkGetSurfacePropertiesKHR():
+    // Results of vkGetPhysicalDeviceSurfaceCapabilitiesKHR():
     bool gotSurfaceProperties;
-    VkSurfacePropertiesKHR surfaceProperties;
+    VkSurfaceCapabilitiesKHR surfaceProperties;
 
 // TODO: Record/use this info per-surface, not per-device, once a
 // non-dispatchable surface object is added to WSI:
-    // Count and VkSurfaceFormatKHR's returned by vkGetSurfaceFormatsKHR():
+    // Count and VkSurfaceFormatKHR's returned by vkGetPhysicalDeviceSurfaceFormatsKHR():
     uint32_t surfaceFormatCount;
     VkSurfaceFormatKHR* pSurfaceFormats;
 
 // TODO: Record/use this info per-surface, not per-device, once a
 // non-dispatchable surface object is added to WSI:
-    // Count and VkPresentModeKHR's returned by vkGetSurfacePresentModesKHR():
+    // Count and VkPresentModeKHR's returned by vkGetPhysicalDeviceSurfacePresentModesKHR():
     uint32_t presentModeCount;
     VkPresentModeKHR* pPresentModes;
 
diff --git a/layers/vk_validation_layer_details.md b/layers/vk_validation_layer_details.md
index e6588d4a..3b271750 100644
--- a/layers/vk_validation_layer_details.md
+++ b/layers/vk_validation_layer_details.md
@@ -334,10 +334,10 @@ For the second category of errors, DeviceLimits stores its own internal record o
 
 | Check | Overview | ENUM SWAPCHAIN_* | Relevant API | Testname | Notes/TODO |
 | ----- | -------- | ---------------- | ------------ | -------- | ---------- |
-| Valid handle | If an invalid handle is used, this error will be flagged | INVALID_HANDLE | vkDestroyInstance vkEnumeratePhysicalDevices vkCreateDevice vkDestroyDevice vkGetPhysicalDeviceSurfaceSupportKHR vkGetSurfacePropertiesKHR vkGetSurfaceFormatsKHR vkGetSurfacePresentModesKHR vkCreateSwapchainKHR vkDestroySwapchainKHR vkGetSwapchainImagesKHR vkAcquireNextImageKHR vkQueuePresentKHR | NA | None |
-| Extension enabled before use | Validates that a WSI extension is enabled before its functions are used | EXT_NOT_ENABLED_BUT_USED |  vkGetPhysicalDeviceSurfaceSupportKHR vkGetSurfacePropertiesKHR vkGetSurfaceFormatsKHR vkGetSurfacePresentModesKHR vkCreateSwapchainKHR vkDestroySwapchainKHR vkGetSwapchainImagesKHR vkAcquireNextImageKHR vkQueuePresentKHR | NA | None |
+| Valid handle | If an invalid handle is used, this error will be flagged | INVALID_HANDLE | vkDestroyInstance vkEnumeratePhysicalDevices vkCreateDevice vkDestroyDevice vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfacePresentModesKHR vkCreateSwapchainKHR vkDestroySwapchainKHR vkGetSwapchainImagesKHR vkAcquireNextImageKHR vkQueuePresentKHR | NA | None |
+| Extension enabled before use | Validates that a WSI extension is enabled before its functions are used | EXT_NOT_ENABLED_BUT_USED |  vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfacePresentModesKHR vkCreateSwapchainKHR vkDestroySwapchainKHR vkGetSwapchainImagesKHR vkAcquireNextImageKHR vkQueuePresentKHR | NA | None |
 | Swapchains destroyed before devices | Validates that  vkDestroySwapchainKHR() is called for all swapchains associated with a device before vkDestroyDevice() is called | DEL_DEVICE_BEFORE_SWAPCHAINS | vkDestroyDevice | NA | None |
-| Queries occur before swapchain creation | Validates that vkGetSurfacePropertiesKHR(), vkGetSurfaceFormatsKHR() and vkGetSurfacePresentModesKHR() are called before vkCreateSwapchainKHR() | CREATE_SWAP_WITHOUT_QUERY | vkCreateSwapchainKHR | NA | None |
+| Queries occur before swapchain creation | Validates that vkGetPhysicalDeviceSurfaceCapabilitiesKHR(), vkGetPhysicalDeviceSurfaceFormatsKHR() and vkGetPhysicalDeviceSurfacePresentModesKHR() are called before vkCreateSwapchainKHR() | CREATE_SWAP_WITHOUT_QUERY | vkCreateSwapchainKHR | NA | None |
 | vkCreateSwapchainKHR(pCreateInfo->minImageCount) | Validates vkCreateSwapchainKHR(pCreateInfo->minImageCount) | CREATE_SWAP_BAD_MIN_IMG_COUNT | vkCreateSwapchainKHR | NA | None |
 | vkCreateSwapchainKHR(pCreateInfo->imageExtent) | Validates vkCreateSwapchainKHR(pCreateInfo->imageExtent) when window has no fixed size | CREATE_SWAP_OUT_OF_BOUNDS_EXTENTS | vkCreateSwapchainKHR | NA | None |
 | vkCreateSwapchainKHR(pCreateInfo->imageExtent) | Validates vkCreateSwapchainKHR(pCreateInfo->imageExtent) when window has a fixed size | CREATE_SWAP_EXTENTS_NO_MATCH_WIN | vkCreateSwapchainKHR | NA | None |
diff --git a/loader/loader.h b/loader/loader.h
index 40dcbd50..60e7d131 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -34,8 +34,9 @@
 
 #include <vulkan/vulkan.h>
 #include <vk_loader_platform.h>
+
 #include <vulkan/vk_lunarg_debug_report.h>
-#include <vulkan/vk_ext_khr_swapchain.h>
+#include <vulkan/VK_KHR_surface.h>
 #include <vulkan/vk_layer.h>
 #include <vulkan/vk_icd.h>
 #include <assert.h>
diff --git a/loader/table_ops.h b/loader/table_ops.h
index e468b0d9..d7f5bfd8 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -175,9 +175,9 @@ static inline void loader_init_device_dispatch_table(struct loader_dev_dispatch_
     table->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) gpa(dev, "vkAcquireNextImageKHR");
     table->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) gpa(dev, "vkCreateSwapchainKHR");
     table->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) gpa(dev, "vkDestroySwapchainKHR");
-    table->GetSurfacePropertiesKHR = (PFN_vkGetSurfacePropertiesKHR) gpa(dev, "vkGetSurfacePropertiesKHR");
-    table->GetSurfaceFormatsKHR = (PFN_vkGetSurfaceFormatsKHR) gpa(dev, "vkGetSurfaceFormatsKHR");
-    table->GetSurfacePresentModesKHR = (PFN_vkGetSurfacePresentModesKHR) gpa(dev, "vkGetSurfacePresentModesKHR");
+    table->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) gpa(dev, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+    table->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) gpa(dev, "vkGetPhysicalDeviceSurfaceFormatsKHR");
+    table->GetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR) gpa(dev, "vkGetPhysicalDeviceSurfacePresentModesKHR");
     table->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) gpa(dev, "vkGetSwapchainImagesKHR");
     table->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(dev, "vkQueuePresentKHR");
 }
diff --git a/loader/wsi_swapchain.c b/loader/wsi_swapchain.c
index 9070657a..d35b2979 100644
--- a/loader/wsi_swapchain.c
+++ b/loader/wsi_swapchain.c
@@ -33,8 +33,8 @@
 #include "wsi_swapchain.h"
 
 static const VkExtensionProperties wsi_swapchain_extension_info = {
-        .extensionName = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME,
-        .specVersion = VK_EXT_KHR_SWAPCHAIN_REVISION,
+        .extensionName = VK_KHR_SURFACE_EXTENSION_NAME,
+        .specVersion = VK_KHR_SURFACE_REVISION,
 };
 
 void wsi_swapchain_add_instance_extensions(
@@ -51,7 +51,7 @@ void wsi_swapchain_create_instance(
     ptr_instance->wsi_swapchain_enabled = false;
 
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
+        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_swapchain_enabled = true;
             return;
         }
diff --git a/loader/wsi_swapchain.h b/loader/wsi_swapchain.h
index 416d659f..a225bc89 100644
--- a/loader/wsi_swapchain.h
+++ b/loader/wsi_swapchain.h
@@ -26,7 +26,7 @@
 
 #include "vk_loader_platform.h"
 #include "loader.h"
-#include "vulkan/vk_ext_khr_swapchain.h"
+#include "vulkan/VK_KHR_surface.h"
 
 bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance,
                                  const char* name, void **addr);