layers: Update GetImageState helper function

Change-Id: Ie79232fabe8410c1b709e3d65c25db90dbbf7884

4 files changed, 67 insertions, 74 deletions

diff --git a/layers/buffer_validation.cpp b/layers/buffer_validation.cpp
index 82fd9ff09..f0d989e13 100644
--- a/layers/buffer_validation.cpp
+++ b/layers/buffer_validation.cpp
@@ -199,7 +199,7 @@ bool CoreChecks::FindGlobalLayout(layer_data *device_data, ImageSubresourcePair
 bool CoreChecks::FindLayouts(layer_data *device_data, VkImage image, std::vector<VkImageLayout> &layouts) {
     auto sub_data = (*GetImageSubresourceMap(device_data)).find(image);
     if (sub_data == (*GetImageSubresourceMap(device_data)).end()) return false;
-    auto image_state = GetImageState(device_data, image);
+    auto image_state = GetImageState(image);
     if (!image_state) return false;
     bool ignoreGlobal = false;
     // TODO: Make this robust for >1 aspect mask. Now it will just say ignore potential errors in this case.
@@ -332,7 +332,7 @@ void CoreChecks::SetImageViewLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_
                                     const VkImageLayout &layout) {
     assert(view_state);
 
-    IMAGE_STATE *image_state = GetImageState(device_data, view_state->create_info.image);
+    IMAGE_STATE *image_state = GetImageState(view_state->create_info.image);
     VkImageSubresourceRange sub_range = view_state->create_info.subresourceRange;
 
     // When changing the layout of a 3D image subresource via a 2D or 2D_ARRRAY image view, all depth slices of
@@ -357,7 +357,7 @@ bool CoreChecks::ValidateRenderPassLayoutAgainstFramebufferImageUsage(layer_data
                                                                       uint32_t attachment_index, const char *variable_name) {
     bool skip = false;
     const auto report_data = GetReportData(device_data);
-    auto image_state = GetImageState(device_data, image);
+    auto image_state = GetImageState(image);
     const char *vuid;
     const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
 
@@ -792,7 +792,7 @@ bool CoreChecks::ValidateBarriersToImages(layer_data *device_data, GLOBAL_CB_NOD
             }
         }
 
-        auto image_state = GetImageState(device_data, img_barrier->image);
+        auto image_state = GetImageState(img_barrier->image);
         if (image_state) {
             VkImageUsageFlags usage_flags = image_state->createInfo.usage;
             skip |= ValidateBarrierLayoutToImageUsage(device_data, img_barrier, false, usage_flags, func_name);
@@ -811,7 +811,7 @@ bool CoreChecks::ValidateBarriersToImages(layer_data *device_data, GLOBAL_CB_NOD
             }
         }
 
-        VkImageCreateInfo *image_create_info = &(GetImageState(device_data, img_barrier->image)->createInfo);
+        VkImageCreateInfo *image_create_info = &(GetImageState(img_barrier->image)->createInfo);
         // For a Depth/Stencil image both aspects MUST be set
         if (FormatIsDepthAndStencil(image_create_info->format)) {
             auto const aspect_mask = img_barrier->subresourceRange.aspectMask;
@@ -1067,7 +1067,7 @@ void CoreChecks::TransitionImageLayouts(layer_data *device_data, GLOBAL_CB_NODE
             continue;
         }
 
-        VkImageCreateInfo *image_create_info = &(GetImageState(device_data, mem_barrier->image)->createInfo);
+        VkImageCreateInfo *image_create_info = &(GetImageState(mem_barrier->image)->createInfo);
         uint32_t level_count = ResolveRemainingLevels(&mem_barrier->subresourceRange, image_create_info->mipLevels);
         uint32_t layer_count = ResolveRemainingLayers(&mem_barrier->subresourceRange, image_create_info->arrayLayers);
 
@@ -1290,7 +1290,7 @@ void CoreChecks::RecordCreateImageANDROID(const VkImageCreateInfo *create_info,
 
 bool CoreChecks::ValidateCreateImageViewANDROID(layer_data *device_data, const VkImageViewCreateInfo *create_info) {
     bool skip = false;
-    IMAGE_STATE *image_state = GetImageState(device_data, create_info->image);
+    IMAGE_STATE *image_state = GetImageState(create_info->image);
 
     if (image_state->has_ahb_format) {
         if (VK_FORMAT_UNDEFINED != create_info->format) {
@@ -1338,7 +1338,7 @@ bool CoreChecks::ValidateCreateImageViewANDROID(layer_data *device_data, const V
 bool CoreChecks::ValidateGetImageSubresourceLayoutANDROID(layer_data *device_data, const VkImage image) {
     bool skip = false;
 
-    IMAGE_STATE *image_state = GetImageState(device_data, image);
+    IMAGE_STATE *image_state = GetImageState(image);
     if (image_state->imported_ahb && (0 == image_state->GetBoundMemory().size())) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
                         "VUID-vkGetImageSubresourceLayout-image-01895",
@@ -1509,7 +1509,7 @@ void CoreChecks::PostCallRecordCreateImage(VkDevice device, const VkImageCreateI
 
 bool CoreChecks::PreCallValidateDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
-    IMAGE_STATE *image_state = GetImageState(device_data, image);
+    IMAGE_STATE *image_state = GetImageState(image);
     const VK_OBJECT obj_struct = {HandleToUint64(image), kVulkanObjectTypeImage};
     bool skip = false;
     if (image_state) {
@@ -1521,7 +1521,7 @@ bool CoreChecks::PreCallValidateDestroyImage(VkDevice device, VkImage image, con
 void CoreChecks::PreCallRecordDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!image) return;
-    IMAGE_STATE *image_state = GetImageState(device_data, image);
+    IMAGE_STATE *image_state = GetImageState(image);
     VK_OBJECT obj_struct = {HandleToUint64(image), kVulkanObjectTypeImage};
     InvalidateCommandBuffers(device_data, image_state->cb_bindings, obj_struct);
     // Clean up memory mapping, bindings and range references for image
@@ -1665,7 +1665,7 @@ bool CoreChecks::VerifyClearImageLayout(layer_data *device_data, GLOBAL_CB_NODE
 
 void CoreChecks::RecordClearImageLayout(layer_data *device_data, GLOBAL_CB_NODE *cb_node, VkImage image,
                                         VkImageSubresourceRange range, VkImageLayout dest_image_layout) {
-    VkImageCreateInfo *image_create_info = &(GetImageState(device_data, image)->createInfo);
+    VkImageCreateInfo *image_create_info = &(GetImageState(image)->createInfo);
     uint32_t level_count = ResolveRemainingLevels(&range, image_create_info->mipLevels);
     uint32_t layer_count = ResolveRemainingLayers(&range, image_create_info->arrayLayers);
 
@@ -1690,7 +1690,7 @@ bool CoreChecks::PreCallValidateCmdClearColorImage(VkCommandBuffer commandBuffer
     bool skip = false;
     // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto image_state = GetImageState(device_data, image);
+    auto image_state = GetImageState(image);
     if (cb_node && image_state) {
         skip |= ValidateMemoryIsBoundToImage(device_data, image_state, "vkCmdClearColorImage()",
                                              "VUID-vkCmdClearColorImage-image-00003");
@@ -1719,7 +1719,7 @@ void CoreChecks::PreCallRecordCmdClearColorImage(VkCommandBuffer commandBuffer,
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
 
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto image_state = GetImageState(device_data, image);
+    auto image_state = GetImageState(image);
     if (cb_node && image_state) {
         AddCommandBufferBindingImage(device_data, cb_node, image_state);
         for (uint32_t i = 0; i < rangeCount; ++i) {
@@ -1736,7 +1736,7 @@ bool CoreChecks::PreCallValidateCmdClearDepthStencilImage(VkCommandBuffer comman
 
     // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto image_state = GetImageState(device_data, image);
+    auto image_state = GetImageState(image);
     if (cb_node && image_state) {
         skip |= ValidateMemoryIsBoundToImage(device_data, image_state, "vkCmdClearDepthStencilImage()",
                                              "VUID-vkCmdClearDepthStencilImage-image-00010");
@@ -1787,7 +1787,7 @@ void CoreChecks::PreCallRecordCmdClearDepthStencilImage(VkCommandBuffer commandB
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
 
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto image_state = GetImageState(device_data, image);
+    auto image_state = GetImageState(image);
     if (cb_node && image_state) {
         AddCommandBufferBindingImage(device_data, cb_node, image_state);
         for (uint32_t i = 0; i < rangeCount; ++i) {
@@ -2455,8 +2455,8 @@ bool CoreChecks::PreCallValidateCmdCopyImage(VkCommandBuffer commandBuffer, VkIm
                                              const VkImageCopy *pRegions) {
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto src_image_state = GetImageState(device_data, srcImage);
-    auto dst_image_state = GetImageState(device_data, dstImage);
+    auto src_image_state = GetImageState(srcImage);
+    auto dst_image_state = GetImageState(dstImage);
     bool skip = false;
 
     skip = ValidateImageCopyData(device_data, report_data, regionCount, pRegions, src_image_state, dst_image_state);
@@ -2732,8 +2732,8 @@ void CoreChecks::PreCallRecordCmdCopyImage(VkCommandBuffer commandBuffer, VkImag
                                            const VkImageCopy *pRegions) {
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto src_image_state = GetImageState(device_data, srcImage);
-    auto dst_image_state = GetImageState(device_data, dstImage);
+    auto src_image_state = GetImageState(srcImage);
+    auto dst_image_state = GetImageState(dstImage);
 
     // Make sure that all image slices are updated to correct layout
     for (uint32_t i = 0; i < regionCount; ++i) {
@@ -2924,8 +2924,8 @@ bool CoreChecks::PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer, V
                                                 const VkImageResolve *pRegions) {
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto src_image_state = GetImageState(device_data, srcImage);
-    auto dst_image_state = GetImageState(device_data, dstImage);
+    auto src_image_state = GetImageState(srcImage);
+    auto dst_image_state = GetImageState(dstImage);
 
     bool skip = false;
     if (cb_node && src_image_state && dst_image_state) {
@@ -3022,8 +3022,8 @@ void CoreChecks::PreCallRecordCmdResolveImage(VkCommandBuffer commandBuffer, VkI
                                               const VkImageResolve *pRegions) {
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto src_image_state = GetImageState(device_data, srcImage);
-    auto dst_image_state = GetImageState(device_data, dstImage);
+    auto src_image_state = GetImageState(srcImage);
+    auto dst_image_state = GetImageState(dstImage);
 
     // Update bindings between images and cmd buffer
     AddCommandBufferBindingImage(device_data, cb_node, src_image_state);
@@ -3035,8 +3035,8 @@ bool CoreChecks::PreCallValidateCmdBlitImage(VkCommandBuffer commandBuffer, VkIm
                                              const VkImageBlit *pRegions, VkFilter filter) {
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto src_image_state = GetImageState(device_data, srcImage);
-    auto dst_image_state = GetImageState(device_data, dstImage);
+    auto src_image_state = GetImageState(srcImage);
+    auto dst_image_state = GetImageState(dstImage);
 
     bool skip = false;
     if (cb_node) {
@@ -3356,8 +3356,8 @@ void CoreChecks::PreCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImag
                                            const VkImageBlit *pRegions, VkFilter filter) {
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto src_image_state = GetImageState(device_data, srcImage);
-    auto dst_image_state = GetImageState(device_data, dstImage);
+    auto src_image_state = GetImageState(srcImage);
+    auto dst_image_state = GetImageState(dstImage);
 
     // Make sure that all image slices are updated to correct layout
     for (uint32_t i = 0; i < regionCount; ++i) {
@@ -4187,7 +4187,7 @@ bool CoreChecks::PreCallValidateCreateImageView(VkDevice device, const VkImageVi
                                                 const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     bool skip = false;
-    IMAGE_STATE *image_state = GetImageState(device_data, pCreateInfo->image);
+    IMAGE_STATE *image_state = GetImageState(pCreateInfo->image);
     if (image_state) {
         skip |= ValidateImageUsageFlags(
             device_data, image_state,
@@ -4426,7 +4426,7 @@ void CoreChecks::PostCallRecordCreateImageView(VkDevice device, const VkImageVie
     auto image_view_map = GetImageViewMap(device_data);
     (*image_view_map)[*pView] = std::unique_ptr<IMAGE_VIEW_STATE>(new IMAGE_VIEW_STATE(*pView, pCreateInfo));
 
-    auto image_state = GetImageState(device_data, pCreateInfo->image);
+    auto image_state = GetImageState(pCreateInfo->image);
     auto &sub_res_range = (*image_view_map)[*pView].get()->create_info.subresourceRange;
     sub_res_range.levelCount = ResolveRemainingLevels(&sub_res_range, image_state->createInfo.mipLevels);
     sub_res_range.layerCount = ResolveRemainingLayers(&sub_res_range, image_state->createInfo.arrayLayers);
@@ -4879,7 +4879,7 @@ bool CoreChecks::PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuff
                                                      VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto src_image_state = GetImageState(device_data, srcImage);
+    auto src_image_state = GetImageState(srcImage);
     auto dst_buffer_state = GetBufferState(dstBuffer);
 
     bool skip = ValidateBufferImageCopyData(report_data, regionCount, pRegions, src_image_state, "vkCmdCopyImageToBuffer");
@@ -4951,7 +4951,7 @@ void CoreChecks::PreCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer
                                                    VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     auto cb_node = GetCBNode(device_data, commandBuffer);
-    auto src_image_state = GetImageState(device_data, srcImage);
+    auto src_image_state = GetImageState(srcImage);
     auto dst_buffer_state = GetBufferState(dstBuffer);
 
     // Make sure that all image slices are updated to correct layout
@@ -4969,7 +4969,7 @@ bool CoreChecks::PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuff
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     auto cb_node = GetCBNode(device_data, commandBuffer);
     auto src_buffer_state = GetBufferState(srcBuffer);
-    auto dst_image_state = GetImageState(device_data, dstImage);
+    auto dst_image_state = GetImageState(dstImage);
 
     bool skip = ValidateBufferImageCopyData(report_data, regionCount, pRegions, dst_image_state, "vkCmdCopyBufferToImage");
 
@@ -5037,7 +5037,7 @@ void CoreChecks::PreCallRecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer
     layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     auto cb_node = GetCBNode(device_data, commandBuffer);
     auto src_buffer_state = GetBufferState(srcBuffer);
-    auto dst_image_state = GetImageState(device_data, dstImage);
+    auto dst_image_state = GetImageState(dstImage);
 
     // Make sure that all image slices are updated to correct layout
     for (uint32_t i = 0; i < regionCount; ++i) {
@@ -5063,7 +5063,7 @@ bool CoreChecks::PreCallValidateGetImageSubresourceLayout(VkDevice device, VkIma
                         "vkGetImageSubresourceLayout(): VkImageSubresource.aspectMask must have exactly 1 bit set.");
     }
 
-    IMAGE_STATE *image_entry = GetImageState(device_data, image);
+    IMAGE_STATE *image_entry = GetImageState(image);
     if (!image_entry) {
         return skip;
     }
diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp
index ef7534632..177641742 100644
--- a/layers/core_validation.cpp
+++ b/layers/core_validation.cpp
@@ -169,9 +169,9 @@ SAMPLER_STATE *CoreChecks::GetSamplerState(const layer_data *dev_data, VkSampler
     return sampler_it->second.get();
 }
 // Return image state ptr for specified image or else NULL
-IMAGE_STATE *CoreChecks::GetImageState(const layer_data *dev_data, VkImage image) {
-    auto img_it = dev_data->imageMap.find(image);
-    if (img_it == dev_data->imageMap.end()) {
+IMAGE_STATE *CoreChecks::GetImageState(VkImage image) {
+    auto img_it = imageMap.find(image);
+    if (img_it == imageMap.end()) {
         return nullptr;
     }
     return img_it->second.get();
@@ -265,7 +265,7 @@ SURFACE_STATE *CoreChecks::GetSurfaceState(VkSurfaceKHR surface) {
 BINDABLE *CoreChecks::GetObjectMemBinding(layer_data *dev_data, uint64_t handle, VulkanObjectType type) {
     switch (type) {
         case kVulkanObjectTypeImage:
-            return GetImageState(dev_data, VkImage(handle));
+            return GetImageState(VkImage(handle));
         case kVulkanObjectTypeBuffer:
             return GetBufferState(VkBuffer(handle));
         default:
@@ -346,7 +346,7 @@ void CoreChecks::AddCommandBufferBindingImageView(const layer_data *dev_data, GL
     // First add bindings for imageView
     view_state->cb_bindings.insert(cb_node);
     cb_node->object_bindings.insert({HandleToUint64(view_state->image_view), kVulkanObjectTypeImageView});
-    auto image_state = GetImageState(dev_data, view_state->create_info.image);
+    auto image_state = GetImageState(view_state->create_info.image);
     // Add bindings for image within imageView
     if (image_state) {
         AddCommandBufferBindingImage(dev_data, cb_node, image_state);
@@ -2035,7 +2035,7 @@ BASE_NODE *CoreChecks::GetStateStructPtrFromObject(layer_data *dev_data, VK_OBJE
             break;
         }
         case kVulkanObjectTypeImage: {
-            base_ptr = GetImageState(dev_data, reinterpret_cast<VkImage &>(object_struct.handle));
+            base_ptr = GetImageState(reinterpret_cast<VkImage &>(object_struct.handle));
             break;
         }
         case kVulkanObjectTypeImageView: {
@@ -2909,7 +2909,7 @@ bool CoreChecks::ValidateQueueFamilyIndices(layer_data *dev_data, GLOBAL_CB_NODE
         // Ensure that any bound images or buffers created with SHARING_MODE_CONCURRENT have access to the current queue family
         for (auto object : pCB->object_bindings) {
             if (object.type == kVulkanObjectTypeImage) {
-                auto image_state = GetImageState(dev_data, reinterpret_cast<VkImage &>(object.handle));
+                auto image_state = GetImageState(reinterpret_cast<VkImage &>(object.handle));
                 if (image_state && image_state->createInfo.sharingMode == VK_SHARING_MODE_CONCURRENT) {
                     skip |= ValidImageBufferQueue(dev_data, pCB, &object, queue, image_state->createInfo.queueFamilyIndexCount,
                                                   image_state->createInfo.pQueueFamilyIndices);
@@ -3334,7 +3334,7 @@ bool CoreChecks::PreCallValidateGetMemoryAndroidHardwareBuffer(VkDevice device,
     // If the pNext chain of the VkMemoryAllocateInfo used to allocate memory included a VkMemoryDedicatedAllocateInfo
     // with non-NULL image member, then that image must already be bound to memory.
     if (mem_info->is_dedicated && (VK_NULL_HANDLE != mem_info->dedicated_image)) {
-        auto image_state = GetImageState(device_data, mem_info->dedicated_image);
+        auto image_state = GetImageState(mem_info->dedicated_image);
         if ((nullptr == image_state) || (0 == (image_state->GetBoundMemory().count(pInfo->memory)))) {
             skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
                             HandleToUint64(device), "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883",
@@ -3489,7 +3489,7 @@ bool CoreChecks::ValidateAllocateMemoryANDROID(layer_data *dev_data, const VkMem
                     ahb_format_props.externalFormat, ahb_desc.usage);
             }
         } else {  // Checks specific to import with a dedicated allocation requirement
-            VkImageCreateInfo *ici = &(GetImageState(dev_data, mem_ded_alloc_info->image)->createInfo);
+            VkImageCreateInfo *ici = &(GetImageState(mem_ded_alloc_info->image)->createInfo);
 
             // The Android hardware buffer's usage must include at least one of AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT or
             // AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE
@@ -3606,7 +3606,7 @@ bool CoreChecks::ValidateGetImageMemoryRequirements2ANDROID(layer_data *dev_data
     bool skip = false;
     const debug_report_data *report_data = GetReportData(dev_data);
 
-    IMAGE_STATE *image_state = GetImageState(dev_data, image);
+    IMAGE_STATE *image_state = GetImageState(image);
     if (image_state->imported_ahb && (0 == image_state->GetBoundMemory().size())) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
                         "VUID-VkImageMemoryRequirementsInfo2-image-01897",
@@ -3770,7 +3770,7 @@ void CoreChecks::PreCallRecordFreeMemory(VkDevice device, VkDeviceMemory mem, co
         BINDABLE *bindable_state = nullptr;
         switch (obj.type) {
             case kVulkanObjectTypeImage:
-                bindable_state = GetImageState(device_data, reinterpret_cast<VkImage &>(obj.handle));
+                bindable_state = GetImageState(reinterpret_cast<VkImage &>(obj.handle));
                 break;
             case kVulkanObjectTypeBuffer:
                 bindable_state = GetBufferState(reinterpret_cast<VkBuffer &>(obj.handle));
@@ -4544,7 +4544,7 @@ bool CoreChecks::PreCallValidateGetImageMemoryRequirements2KHR(VkDevice device,
 
 void CoreChecks::RecordGetImageMemoryRequiementsState(layer_data *device_data, VkImage image,
                                                       VkMemoryRequirements *pMemoryRequirements) {
-    IMAGE_STATE *image_state = GetImageState(device_data, image);
+    IMAGE_STATE *image_state = GetImageState(image);
     if (image_state) {
         image_state->requirements = *pMemoryRequirements;
         image_state->memory_requirements_checked = true;
@@ -4580,9 +4580,7 @@ static void RecordGetImageSparseMemoryRequirementsState(IMAGE_STATE *image_state
 void CoreChecks::PostCallRecordGetImageSparseMemoryRequirements(VkDevice device, VkImage image,
                                                                 uint32_t *pSparseMemoryRequirementCount,
                                                                 VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
-    layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
-
-    auto image_state = GetImageState(device_data, image);
+    auto image_state = GetImageState(image);
     image_state->get_sparse_reqs_called = true;
     if (!pSparseMemoryRequirements) return;
     for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++) {
@@ -4594,9 +4592,7 @@ void CoreChecks::PostCallRecordGetImageSparseMemoryRequirements2(VkDevice device
                                                                  const VkImageSparseMemoryRequirementsInfo2KHR *pInfo,
                                                                  uint32_t *pSparseMemoryRequirementCount,
                                                                  VkSparseImageMemoryRequirements2KHR *pSparseMemoryRequirements) {
-    layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
-
-    auto image_state = GetImageState(device_data, pInfo->image);
+    auto image_state = GetImageState(pInfo->image);
     image_state->get_sparse_reqs_called = true;
     if (!pSparseMemoryRequirements) return;
     for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++) {
@@ -4608,9 +4604,7 @@ void CoreChecks::PostCallRecordGetImageSparseMemoryRequirements2(VkDevice device
 void CoreChecks::PostCallRecordGetImageSparseMemoryRequirements2KHR(
     VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR *pInfo, uint32_t *pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements2KHR *pSparseMemoryRequirements) {
-    layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
-
-    auto image_state = GetImageState(device_data, pInfo->image);
+    auto image_state = GetImageState(pInfo->image);
     image_state->get_sparse_reqs_called = true;
     if (!pSparseMemoryRequirements) return;
     for (uint32_t i = 0; i < *pSparseMemoryRequirementCount; i++) {
@@ -6607,8 +6601,7 @@ bool CoreChecks::PreCallValidateCmdBindShadingRateImageNV(VkCommandBuffer comman
                 "vkCmdBindShadingRateImageNV: If imageView is not VK_NULL_HANDLE, it must have a format of VK_FORMAT_R8_UINT.");
         }
 
-        const VkImageCreateInfo *ici =
-            view_state ? &GetImageState(device_data, view_state->create_info.image)->createInfo : nullptr;
+        const VkImageCreateInfo *ici = view_state ? &GetImageState(view_state->create_info.image)->createInfo : nullptr;
         if (ici && !(ici->usage & VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV)) {
             skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
                             HandleToUint64(imageView), "VUID-vkCmdBindShadingRateImageNV-imageView-02061",
@@ -6617,7 +6610,7 @@ bool CoreChecks::PreCallValidateCmdBindShadingRateImageNV(VkCommandBuffer comman
         }
 
         if (view_state) {
-            auto image_state = GetImageState(device_data, view_state->create_info.image);
+            auto image_state = GetImageState(view_state->create_info.image);
             bool hit_error = false;
 
             // XXX TODO: While the VUID says "each subresource", only the base mip level is
@@ -8365,7 +8358,7 @@ bool CoreChecks::ValidateBarriers(layer_data *device_data, const char *funcName,
                             mem_barrier->dstAccessMask, dst_stage_mask);
         }
 
-        auto image_data = GetImageState(device_data, mem_barrier->image);
+        auto image_data = GetImageState(mem_barrier->image);
         skip |= ValidateBarrierQueueFamilies(device_data, funcName, cb_state, mem_barrier, image_data);
 
         if (mem_barrier->newLayout == VK_IMAGE_LAYOUT_UNDEFINED || mem_barrier->newLayout == VK_IMAGE_LAYOUT_PREINITIALIZED) {
@@ -8973,7 +8966,7 @@ bool CoreChecks::MatchUsage(layer_data *dev_data, uint32_t count, const VkAttach
                 const VkImageView *image_view = &fbci->pAttachments[attachments[attach].attachment];
                 auto view_state = GetImageViewState(dev_data, *image_view);
                 if (view_state) {
-                    const VkImageCreateInfo *ici = &GetImageState(dev_data, view_state->create_info.image)->createInfo;
+                    const VkImageCreateInfo *ici = &GetImageState(view_state->create_info.image)->createInfo;
                     if (ici != nullptr) {
                         if ((ici->usage & usage_flag) == 0) {
                             skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
@@ -9027,7 +9020,7 @@ bool CoreChecks::ValidateFramebufferCreateInfo(layer_data *dev_data, const VkFra
                                 i, string_VkFormat(ivci.format), string_VkFormat(rpci->pAttachments[i].format),
                                 dev_data->report_data->FormatHandle(pCreateInfo->renderPass).c_str());
                 }
-                const VkImageCreateInfo *ici = &GetImageState(dev_data, ivci.image)->createInfo;
+                const VkImageCreateInfo *ici = &GetImageState(ivci.image)->createInfo;
                 if (ici->samples != rpci->pAttachments[i].samples) {
                     skip |= log_msg(
                         dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
@@ -9294,8 +9287,8 @@ bool CoreChecks::ValidateDependencies(layer_data *dev_data, FRAMEBUFFER_STATE co
                 overlapping_attachments[j].push_back(i);
                 continue;
             }
-            auto image_data_i = GetImageState(dev_data, view_ci_i.image);
-            auto image_data_j = GetImageState(dev_data, view_ci_j.image);
+            auto image_data_i = GetImageState(view_ci_i.image);
+            auto image_data_j = GetImageState(view_ci_j.image);
             if (!image_data_i || !image_data_j) {
                 continue;
             }
@@ -10987,7 +10980,7 @@ bool CoreChecks::PreCallValidateGetDeviceMemoryCommitment(VkDevice device, VkDev
 bool CoreChecks::ValidateBindImageMemory(layer_data *device_data, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset,
                                          const char *api_name) {
     bool skip = false;
-    IMAGE_STATE *image_state = GetImageState(device_data, image);
+    IMAGE_STATE *image_state = GetImageState(image);
     if (image_state) {
         // Track objects tied to memory
         uint64_t image_handle = HandleToUint64(image);
@@ -11060,7 +11053,7 @@ bool CoreChecks::PreCallValidateBindImageMemory(VkDevice device, VkImage image,
 }
 
 void CoreChecks::UpdateBindImageMemoryState(layer_data *device_data, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset) {
-    IMAGE_STATE *image_state = GetImageState(device_data, image);
+    IMAGE_STATE *image_state = GetImageState(image);
     if (image_state) {
         // Track bound memory range information
         auto mem_info = GetMemObjInfo(device_data, mem);
@@ -11221,7 +11214,7 @@ bool CoreChecks::PreCallValidateQueueBindSparse(VkQueue queue, uint32_t bindInfo
         // If we're binding sparse image memory make sure reqs were queried and note if metadata is required and bound
         for (uint32_t i = 0; i < bindInfo.imageBindCount; ++i) {
             const auto &image_bind = bindInfo.pImageBinds[i];
-            auto image_state = GetImageState(device_data, image_bind.image);
+            auto image_state = GetImageState(image_bind.image);
             if (!image_state)
                 continue;  // Param/Object validation should report image_bind.image handles being invalid, so just skip here.
             sparse_images.insert(image_state);
@@ -11246,7 +11239,7 @@ bool CoreChecks::PreCallValidateQueueBindSparse(VkQueue queue, uint32_t bindInfo
         }
         for (uint32_t i = 0; i < bindInfo.imageOpaqueBindCount; ++i) {
             const auto &image_opaque_bind = bindInfo.pImageOpaqueBinds[i];
-            auto image_state = GetImageState(device_data, bindInfo.pImageOpaqueBinds[i].image);
+            auto image_state = GetImageState(bindInfo.pImageOpaqueBinds[i].image);
             if (!image_state)
                 continue;  // Param/Object validation should report image_bind.image handles being invalid, so just skip here.
             sparse_images.insert(image_state);
@@ -12057,7 +12050,7 @@ bool CoreChecks::PreCallValidateQueuePresentKHR(VkQueue queue, const VkPresentIn
                             pPresentInfo->pImageIndices[i], (uint32_t)swapchain_data->images.size());
             } else {
                 auto image = swapchain_data->images[pPresentInfo->pImageIndices[i]];
-                auto image_state = GetImageState(device_data, image);
+                auto image_state = GetImageState(image);
 
                 if (image_state->shared_presentable) {
                     image_state->layout_locked = true;
@@ -12185,7 +12178,7 @@ void CoreChecks::PostCallRecordQueuePresentKHR(VkQueue queue, const VkPresentInf
         auto swapchain_data = GetSwapchainNode(device_data, pPresentInfo->pSwapchains[i]);
         if (swapchain_data && (swapchain_data->images.size() > pPresentInfo->pImageIndices[i])) {
             auto image = swapchain_data->images[pPresentInfo->pImageIndices[i]];
-            auto image_state = GetImageState(device_data, image);
+            auto image_state = GetImageState(image);
             if (image_state) {
                 image_state->acquired = false;
             }
@@ -12262,7 +12255,7 @@ bool CoreChecks::ValidateAcquireNextImage(layer_data *device_data, VkDevice devi
     auto physical_device_state = GetPhysicalDeviceState();
     if (physical_device_state->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState != UNCALLED) {
         uint64_t acquired_images = std::count_if(swapchain_data->images.begin(), swapchain_data->images.end(),
-                                                 [=](VkImage image) { return GetImageState(device_data, image)->acquired; });
+                                                 [=](VkImage image) { return GetImageState(image)->acquired; });
         if (acquired_images > swapchain_data->images.size() - physical_device_state->surfaceCapabilities.minImageCount) {
             skip |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
                             HandleToUint64(swapchain), kVUID_Core_DrawState_SwapchainTooManyImages,
@@ -12317,7 +12310,7 @@ void CoreChecks::RecordAcquireNextImageState(layer_data *device_data, VkDevice d
     auto swapchain_data = GetSwapchainNode(device_data, swapchain);
     if (swapchain_data && (swapchain_data->images.size() > *pImageIndex)) {
         auto image = swapchain_data->images[*pImageIndex];
-        auto image_state = GetImageState(device_data, image);
+        auto image_state = GetImageState(image);
         if (image_state) {
             image_state->acquired = true;
             image_state->shared_presentable = swapchain_data->shared_presentable;
diff --git a/layers/core_validation.h b/layers/core_validation.h
index ebd70c51a..23dc2be35 100644
--- a/layers/core_validation.h
+++ b/layers/core_validation.h
@@ -248,7 +248,7 @@ class CoreChecks : public ValidationObject {
     cvdescriptorset::DescriptorSet* GetSetNode(VkDescriptorSet);
     DESCRIPTOR_POOL_STATE* GetDescriptorPoolState(const VkDescriptorPool);
     BUFFER_STATE* GetBufferState(VkBuffer);
-    IMAGE_STATE* GetImageState(const layer_data*, VkImage);
+    IMAGE_STATE* GetImageState(VkImage);
     DEVICE_MEM_INFO* GetMemObjInfo(const layer_data*, VkDeviceMemory);
     BUFFER_VIEW_STATE* GetBufferViewState(const layer_data*, VkBufferView);
     SAMPLER_STATE* GetSamplerState(const layer_data*, VkSampler);
diff --git a/layers/descriptor_sets.cpp b/layers/descriptor_sets.cpp
index 690fb66bf..046dac913 100644
--- a/layers/descriptor_sets.cpp
+++ b/layers/descriptor_sets.cpp
@@ -831,7 +831,7 @@ bool cvdescriptorset::DescriptorSet::ValidateDrawState(const std::map<uint32_t,
                         return false;
                     }
 
-                    auto image_node = device_data_->GetImageState(device_data_, image_view_ci.image);
+                    auto image_node = device_data_->GetImageState(image_view_ci.image);
                     assert(image_node);
                     // Verify Image Layout
                     // Copy first mip level into sub_layers and loop over each mip level to verify layout
@@ -1339,7 +1339,7 @@ bool cvdescriptorset::ValidateImageUpdate(VkImageView image_view, VkImageLayout
     VkImage image = iv_state->create_info.image;
     VkFormat format = VK_FORMAT_MAX_ENUM;
     VkImageUsageFlags usage = 0;
-    auto image_node = dev_data->GetImageState(dev_data, image);
+    auto image_node = dev_data->GetImageState(image);
     if (image_node) {
         format = image_node->createInfo.format;
         usage = image_node->createInfo.usage;