Vulkan: Renaming "ShaderBuffers" to "ShaderResources".

This will match the functionality as we expand the descriptor set
cache to non-buffer resources.

Bug: angleproject:6776
Change-Id: I5597d074beea7d3b464802a2db9bcc2fcf84ca6b
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3583359
Reviewed-by: Yuxin Hu <yuxinhu@google.com>
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Jamie Madill <jmadill@chromium.org>

9 files changed, 106 insertions, 106 deletions

diff --git a/scripts/code_generation_hashes/overlay_widgets.json b/scripts/code_generation_hashes/overlay_widgets.json
index ec1cf1ba28..7f2b2897f6 100644
--- a/scripts/code_generation_hashes/overlay_widgets.json
+++ b/scripts/code_generation_hashes/overlay_widgets.json
@@ -1,10 +1,10 @@
 {
   "src/libANGLE/Overlay_autogen.cpp":
-    "45ac90c90602c3f20ae798cb80e3cf58",
+    "c9763a51339da8432a0827322f21bd2e",
   "src/libANGLE/Overlay_autogen.h":
-    "ca17ed3d781260786075375d6275b95c",
+    "e9594b02a505c22e121541810551a19d",
   "src/libANGLE/gen_overlay_widgets.py":
     "4530a7f65c51206ce9de6917683e3687",
   "src/libANGLE/overlay_widgets.json":
-    "48e3cb7165d22a40772b2c733e4c98b5"
+    "2a424ff932317c54df13acabfb1251a3"
 }
\ No newline at end of file
diff --git a/src/common/angleutils.h b/src/common/angleutils.h
index 8d7bcbb586..9b37fb2e3f 100644
--- a/src/common/angleutils.h
+++ b/src/common/angleutils.h
@@ -130,55 +130,55 @@ struct PerfMonitorTriplet
     uint32_t value;
 };
 
-#define ANGLE_VK_PERF_COUNTERS_X(FN)              \
-    FN(primaryBuffers)                            \
-    FN(renderPasses)                              \
-    FN(submittedCommands)                         \
-    FN(writeDescriptorSets)                       \
-    FN(flushedOutsideRenderPassCommandBuffers)    \
-    FN(swapchainResolveInSubpass)                 \
-    FN(swapchainResolveOutsideSubpass)            \
-    FN(resolveImageCommands)                      \
-    FN(colorLoadOpClears)                         \
-    FN(colorLoadOpLoads)                          \
-    FN(colorLoadOpNones)                          \
-    FN(colorStoreOpStores)                        \
-    FN(colorStoreOpNones)                         \
-    FN(colorClearAttachments)                     \
-    FN(depthLoadOpClears)                         \
-    FN(depthLoadOpLoads)                          \
-    FN(depthLoadOpNones)                          \
-    FN(depthStoreOpStores)                        \
-    FN(depthStoreOpNones)                         \
-    FN(depthClearAttachments)                     \
-    FN(stencilLoadOpClears)                       \
-    FN(stencilLoadOpLoads)                        \
-    FN(stencilLoadOpNones)                        \
-    FN(stencilStoreOpStores)                      \
-    FN(stencilStoreOpNones)                       \
-    FN(stencilClearAttachments)                   \
-    FN(colorAttachmentUnresolves)                 \
-    FN(depthAttachmentUnresolves)                 \
-    FN(stencilAttachmentUnresolves)               \
-    FN(colorAttachmentResolves)                   \
-    FN(depthAttachmentResolves)                   \
-    FN(stencilAttachmentResolves)                 \
-    FN(readOnlyDepthStencilRenderPasses)          \
-    FN(descriptorSetAllocations)                  \
-    FN(descriptorSetCacheTotalSize)               \
-    FN(descriptorSetCacheKeySizeBytes)            \
-    FN(uniformsAndXfbDescriptorSetCacheHits)      \
-    FN(uniformsAndXfbDescriptorSetCacheMisses)    \
-    FN(uniformsAndXfbDescriptorSetCacheTotalSize) \
-    FN(textureDescriptorSetCacheHits)             \
-    FN(textureDescriptorSetCacheMisses)           \
-    FN(textureDescriptorSetCacheTotalSize)        \
-    FN(shaderBuffersDescriptorSetCacheHits)       \
-    FN(shaderBuffersDescriptorSetCacheMisses)     \
-    FN(shaderBuffersDescriptorSetCacheTotalSize)  \
-    FN(buffersGhosted)                            \
-    FN(vertexArraySyncStateCalls)                 \
-    FN(allocateNewBufferBlockCalls)               \
+#define ANGLE_VK_PERF_COUNTERS_X(FN)               \
+    FN(primaryBuffers)                             \
+    FN(renderPasses)                               \
+    FN(submittedCommands)                          \
+    FN(writeDescriptorSets)                        \
+    FN(flushedOutsideRenderPassCommandBuffers)     \
+    FN(swapchainResolveInSubpass)                  \
+    FN(swapchainResolveOutsideSubpass)             \
+    FN(resolveImageCommands)                       \
+    FN(colorLoadOpClears)                          \
+    FN(colorLoadOpLoads)                           \
+    FN(colorLoadOpNones)                           \
+    FN(colorStoreOpStores)                         \
+    FN(colorStoreOpNones)                          \
+    FN(colorClearAttachments)                      \
+    FN(depthLoadOpClears)                          \
+    FN(depthLoadOpLoads)                           \
+    FN(depthLoadOpNones)                           \
+    FN(depthStoreOpStores)                         \
+    FN(depthStoreOpNones)                          \
+    FN(depthClearAttachments)                      \
+    FN(stencilLoadOpClears)                        \
+    FN(stencilLoadOpLoads)                         \
+    FN(stencilLoadOpNones)                         \
+    FN(stencilStoreOpStores)                       \
+    FN(stencilStoreOpNones)                        \
+    FN(stencilClearAttachments)                    \
+    FN(colorAttachmentUnresolves)                  \
+    FN(depthAttachmentUnresolves)                  \
+    FN(stencilAttachmentUnresolves)                \
+    FN(colorAttachmentResolves)                    \
+    FN(depthAttachmentResolves)                    \
+    FN(stencilAttachmentResolves)                  \
+    FN(readOnlyDepthStencilRenderPasses)           \
+    FN(descriptorSetAllocations)                   \
+    FN(descriptorSetCacheTotalSize)                \
+    FN(descriptorSetCacheKeySizeBytes)             \
+    FN(uniformsAndXfbDescriptorSetCacheHits)       \
+    FN(uniformsAndXfbDescriptorSetCacheMisses)     \
+    FN(uniformsAndXfbDescriptorSetCacheTotalSize)  \
+    FN(textureDescriptorSetCacheHits)              \
+    FN(textureDescriptorSetCacheMisses)            \
+    FN(textureDescriptorSetCacheTotalSize)         \
+    FN(shaderResourcesDescriptorSetCacheHits)      \
+    FN(shaderResourcesDescriptorSetCacheMisses)    \
+    FN(shaderResourcesDescriptorSetCacheTotalSize) \
+    FN(buffersGhosted)                             \
+    FN(vertexArraySyncStateCalls)                  \
+    FN(allocateNewBufferBlockCalls)                \
     FN(dynamicBufferAllocations)
 
 #define ANGLE_DECLARE_PERF_COUNTER(COUNTER) uint32_t COUNTER;
diff --git a/src/libANGLE/OverlayWidgets.cpp b/src/libANGLE/OverlayWidgets.cpp
index 3e1d745a1f..f538105e0d 100644
--- a/src/libANGLE/OverlayWidgets.cpp
+++ b/src/libANGLE/OverlayWidgets.cpp
@@ -447,15 +447,15 @@ void AppendWidgetDataHelper::AppendVulkanDescriptorSetAllocations(const overlay:
     AppendRunningGraphCommon(widget, imageExtent, textWidget, graphWidget, widgetCounts, format);
 }
 
-void AppendWidgetDataHelper::AppendVulkanShaderBufferDSHitRate(const overlay::Widget *widget,
-                                                               const gl::Extents &imageExtent,
-                                                               TextWidgetData *textWidget,
-                                                               GraphWidgetData *graphWidget,
-                                                               OverlayWidgetCounts *widgetCounts)
+void AppendWidgetDataHelper::AppendVulkanShaderResourceDSHitRate(const overlay::Widget *widget,
+                                                                 const gl::Extents &imageExtent,
+                                                                 TextWidgetData *textWidget,
+                                                                 GraphWidgetData *graphWidget,
+                                                                 OverlayWidgetCounts *widgetCounts)
 {
     auto format = [](size_t maxValue) {
         std::ostringstream text;
-        text << "Shader Buffer DS Hit Rate (Max: " << maxValue << "%)";
+        text << "Shader Resource DS Hit Rate (Max: " << maxValue << "%)";
         return text.str();
     };
 
diff --git a/src/libANGLE/Overlay_autogen.cpp b/src/libANGLE/Overlay_autogen.cpp
index 87d47e38de..6fb3283c56 100644
--- a/src/libANGLE/Overlay_autogen.cpp
+++ b/src/libANGLE/Overlay_autogen.cpp
@@ -338,13 +338,13 @@ void Overlay::initOverlayWidgets()
             widget->color[2]  = 0.29411764705882354f;
             widget->color[3]  = 0.7843137254901961f;
         }
-        mState.mOverlayWidgets[WidgetId::VulkanShaderBufferDSHitRate].reset(widget);
+        mState.mOverlayWidgets[WidgetId::VulkanShaderResourceDSHitRate].reset(widget);
         {
             const int32_t fontSize = GetFontSize(kFontMipSmall, kLargeFont);
             const int32_t offsetX =
-                mState.mOverlayWidgets[WidgetId::VulkanShaderBufferDSHitRate]->coords[0];
+                mState.mOverlayWidgets[WidgetId::VulkanShaderResourceDSHitRate]->coords[0];
             const int32_t offsetY =
-                mState.mOverlayWidgets[WidgetId::VulkanShaderBufferDSHitRate]->coords[1];
+                mState.mOverlayWidgets[WidgetId::VulkanShaderResourceDSHitRate]->coords[1];
             const int32_t width  = 40 * (kFontGlyphWidth >> fontSize);
             const int32_t height = (kFontGlyphHeight >> fontSize);
 
diff --git a/src/libANGLE/Overlay_autogen.h b/src/libANGLE/Overlay_autogen.h
index 34facfb992..533fb35e00 100644
--- a/src/libANGLE/Overlay_autogen.h
+++ b/src/libANGLE/Overlay_autogen.h
@@ -28,8 +28,8 @@ enum class WidgetId
     VulkanWriteDescriptorSetCount,
     // Descriptor Set Allocations.
     VulkanDescriptorSetAllocations,
-    // Shader Buffer Descriptor Set Cache Hit Rate.
-    VulkanShaderBufferDSHitRate,
+    // Shader Resource Descriptor Set Cache Hit Rate.
+    VulkanShaderResourceDSHitRate,
     // Buffer Allocations Made By vk::DynamicBuffer.
     VulkanDynamicBufferAllocations,
     // Total size of all descriptor set caches
@@ -55,7 +55,7 @@ enum class WidgetId
     PROC(VulkanSecondaryCommandBufferPoolWaste) \
     PROC(VulkanWriteDescriptorSetCount)         \
     PROC(VulkanDescriptorSetAllocations)        \
-    PROC(VulkanShaderBufferDSHitRate)           \
+    PROC(VulkanShaderResourceDSHitRate)         \
     PROC(VulkanDynamicBufferAllocations)        \
     PROC(VulkanDescriptorCacheSize)             \
     PROC(VulkanTextureDescriptorCacheSize)      \
diff --git a/src/libANGLE/overlay_widgets.json b/src/libANGLE/overlay_widgets.json
index 07092e75b1..da2108a550 100644
--- a/src/libANGLE/overlay_widgets.json
+++ b/src/libANGLE/overlay_widgets.json
@@ -134,8 +134,8 @@
             }
         },
         {
-            "name": "VulkanShaderBufferDSHitRate",
-            "comment": "Shader Buffer Descriptor Set Cache Hit Rate.",
+            "name": "VulkanShaderResourceDSHitRate",
+            "comment": "Shader Resource Descriptor Set Cache Hit Rate.",
             "type": "RunningGraph(60)",
             "color": [255, 0, 75, 200],
             "coords": [-50, 360],
@@ -143,8 +143,8 @@
             "height": 100,
             "description": {
                 "color": [255, 0, 75, 255],
-                "coords": ["VulkanShaderBufferDSHitRate.left.align",
-                           "VulkanShaderBufferDSHitRate.top.adjacent"],
+                "coords": ["VulkanShaderResourceDSHitRate.left.align",
+                           "VulkanShaderResourceDSHitRate.top.adjacent"],
                 "font": "small",
                 "length": 40
             }
diff --git a/src/libANGLE/renderer/vulkan/ContextVk.cpp b/src/libANGLE/renderer/vulkan/ContextVk.cpp
index 62c5978b1c..370512f9d5 100644
--- a/src/libANGLE/renderer/vulkan/ContextVk.cpp
+++ b/src/libANGLE/renderer/vulkan/ContextVk.cpp
@@ -2460,18 +2460,18 @@ angle::Result ContextVk::handleDirtyDescriptorSetsImpl(CommandBufferT *commandBu
 
 void ContextVk::syncObjectPerfCounters()
 {
-    mPerfCounters.descriptorSetCacheTotalSize               = 0;
-    mPerfCounters.descriptorSetCacheKeySizeBytes            = 0;
-    mPerfCounters.uniformsAndXfbDescriptorSetCacheHits      = 0;
-    mPerfCounters.uniformsAndXfbDescriptorSetCacheMisses    = 0;
-    mPerfCounters.uniformsAndXfbDescriptorSetCacheTotalSize = 0;
-    mPerfCounters.textureDescriptorSetCacheHits             = 0;
-    mPerfCounters.textureDescriptorSetCacheMisses           = 0;
-    mPerfCounters.textureDescriptorSetCacheTotalSize        = 0;
-    mPerfCounters.shaderBuffersDescriptorSetCacheHits       = 0;
-    mPerfCounters.shaderBuffersDescriptorSetCacheMisses     = 0;
-    mPerfCounters.shaderBuffersDescriptorSetCacheTotalSize  = 0;
-    mPerfCounters.dynamicBufferAllocations                  = 0;
+    mPerfCounters.descriptorSetCacheTotalSize                = 0;
+    mPerfCounters.descriptorSetCacheKeySizeBytes             = 0;
+    mPerfCounters.uniformsAndXfbDescriptorSetCacheHits       = 0;
+    mPerfCounters.uniformsAndXfbDescriptorSetCacheMisses     = 0;
+    mPerfCounters.uniformsAndXfbDescriptorSetCacheTotalSize  = 0;
+    mPerfCounters.textureDescriptorSetCacheHits              = 0;
+    mPerfCounters.textureDescriptorSetCacheMisses            = 0;
+    mPerfCounters.textureDescriptorSetCacheTotalSize         = 0;
+    mPerfCounters.shaderResourcesDescriptorSetCacheHits      = 0;
+    mPerfCounters.shaderResourcesDescriptorSetCacheMisses    = 0;
+    mPerfCounters.shaderResourcesDescriptorSetCacheTotalSize = 0;
+    mPerfCounters.dynamicBufferAllocations                   = 0;
 
     // ProgramExecutableVk's descriptor set allocations
     const gl::ShaderProgramManager &shadersAndPrograms = mState.getShaderProgramManagerForCapture();
@@ -2500,11 +2500,11 @@ void ContextVk::syncObjectPerfCounters()
             progPerfCounters.cacheStats[DescriptorSetIndex::Texture].getMissCount();
         mPerfCounters.textureDescriptorSetCacheTotalSize +=
             progPerfCounters.cacheStats[DescriptorSetIndex::Texture].getSize();
-        mPerfCounters.shaderBuffersDescriptorSetCacheHits +=
+        mPerfCounters.shaderResourcesDescriptorSetCacheHits +=
             progPerfCounters.cacheStats[DescriptorSetIndex::ShaderResource].getHitCount();
-        mPerfCounters.shaderBuffersDescriptorSetCacheMisses +=
+        mPerfCounters.shaderResourcesDescriptorSetCacheMisses +=
             progPerfCounters.cacheStats[DescriptorSetIndex::ShaderResource].getMissCount();
-        mPerfCounters.shaderBuffersDescriptorSetCacheTotalSize +=
+        mPerfCounters.shaderResourcesDescriptorSetCacheTotalSize +=
             progPerfCounters.cacheStats[DescriptorSetIndex::ShaderResource].getSize();
 
         for (uint32_t keySizeBytes : progPerfCounters.descriptorSetCacheKeySizesBytes)
@@ -2517,7 +2517,7 @@ void ContextVk::syncObjectPerfCounters()
         mPerfCounters.uniformsAndXfbDescriptorSetCacheTotalSize;
     mPerfCounters.descriptorSetCacheTotalSize += mPerfCounters.textureDescriptorSetCacheTotalSize;
     mPerfCounters.descriptorSetCacheTotalSize +=
-        mPerfCounters.shaderBuffersDescriptorSetCacheTotalSize;
+        mPerfCounters.shaderResourcesDescriptorSetCacheTotalSize;
 
     for (const DriverUniformsDescriptorSet &driverSet : mDriverUniforms)
     {
@@ -2555,18 +2555,18 @@ void ContextVk::updateOverlayOnPresent()
     }
 
     {
-        gl::RunningGraphWidget *shaderBufferHitRate =
-            overlay->getRunningGraphWidget(gl::WidgetId::VulkanShaderBufferDSHitRate);
-        size_t numCacheAccesses = mPerfCounters.shaderBuffersDescriptorSetCacheHits +
-                                  mPerfCounters.shaderBuffersDescriptorSetCacheMisses;
+        gl::RunningGraphWidget *shaderResourceHitRate =
+            overlay->getRunningGraphWidget(gl::WidgetId::VulkanShaderResourceDSHitRate);
+        size_t numCacheAccesses = mPerfCounters.shaderResourcesDescriptorSetCacheHits +
+                                  mPerfCounters.shaderResourcesDescriptorSetCacheMisses;
         if (numCacheAccesses > 0)
         {
             float hitRateFloat =
-                static_cast<float>(mPerfCounters.shaderBuffersDescriptorSetCacheHits) /
+                static_cast<float>(mPerfCounters.shaderResourcesDescriptorSetCacheHits) /
                 static_cast<float>(numCacheAccesses);
             size_t hitRate = static_cast<size_t>(hitRateFloat * 100.0f);
-            shaderBufferHitRate->add(hitRate);
-            shaderBufferHitRate->next();
+            shaderResourceHitRate->add(hitRate);
+            shaderResourceHitRate->next();
         }
     }
 
diff --git a/src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp b/src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp
index 461d68f63d..3a101561c5 100644
--- a/src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp
+++ b/src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp
@@ -1261,13 +1261,13 @@ void ProgramExecutableVk::updateDefaultUniformsDescriptorSet(
 angle::Result ProgramExecutableVk::allocateShaderResourcesDescriptorSet(
     vk::Context *context,
     vk::ResourceUseList *resourceUseList,
-    const vk::DescriptorSetDesc *shaderBuffersDesc)
+    const vk::DescriptorSetDesc *shaderResourcesDesc)
 {
     bool newPoolAllocated = false;
     ANGLE_TRY(allocateDescriptorSetAndGetInfo(
         context, resourceUseList, DescriptorSetIndex::ShaderResource, &newPoolAllocated));
 
-    if (shaderBuffersDesc)
+    if (shaderResourcesDesc)
     {
         // Clear descriptor set cache. It may no longer be valid.
         if (newPoolAllocated)
@@ -1276,7 +1276,7 @@ angle::Result ProgramExecutableVk::allocateShaderResourcesDescriptorSet(
         }
 
         mShaderBufferDescriptorsCache.insert(
-            *shaderBuffersDesc, mDescriptorSets[DescriptorSetIndex::ShaderResource],
+            *shaderResourcesDesc, mDescriptorSets[DescriptorSetIndex::ShaderResource],
             &mPerfCounters.cacheStats[DescriptorSetIndex::ShaderResource]);
     }
     return angle::Result::Continue;
@@ -1288,7 +1288,7 @@ angle::Result ProgramExecutableVk::updateBuffersDescriptorSet(
     vk::BufferHelper *emptyBuffer,
     vk::ResourceUseList *resourceUseList,
     gl::ShaderType shaderType,
-    const vk::DescriptorSetDesc &shaderBuffersDesc,
+    const vk::DescriptorSetDesc &shaderResourcesDesc,
     const gl::BufferVector &buffers,
     const std::vector<gl::InterfaceBlock> &blocks,
     ShaderVariableType variableType,
@@ -1389,7 +1389,7 @@ angle::Result ProgramExecutableVk::updateAtomicCounterBuffersDescriptorSet(
     const gl::BufferVector &atomicCounterBufferBindings,
     const gl::ProgramExecutable &executable,
     gl::ShaderType shaderType,
-    const vk::DescriptorSetDesc &shaderBuffersDesc,
+    const vk::DescriptorSetDesc &shaderResourcesDesc,
     bool cacheHit)
 {
     const std::vector<gl::AtomicCounterBuffer> &atomicCounterBuffers =
@@ -1585,7 +1585,7 @@ angle::Result ProgramExecutableVk::updateShaderResourcesDescriptorSet(
     vk::BufferHelper *emptyBuffer,
     vk::ResourceUseList *resourceUseList,
     FramebufferVk *framebufferVk,
-    const vk::DescriptorSetDesc &shaderBuffersDesc)
+    const vk::DescriptorSetDesc &shaderResourcesDesc)
 {
     // Reset the descriptor set handles so we only allocate a new one when necessary.
     mDescriptorSets[DescriptorSetIndex::ShaderResource]      = VK_NULL_HANDLE;
@@ -1603,7 +1603,7 @@ angle::Result ProgramExecutableVk::updateShaderResourcesDescriptorSet(
     {
         VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
         if (mShaderBufferDescriptorsCache.get(
-                shaderBuffersDesc, &descriptorSet,
+                shaderResourcesDesc, &descriptorSet,
                 &mPerfCounters.cacheStats[DescriptorSetIndex::ShaderResource]))
         {
             mDescriptorSets[DescriptorSetIndex::ShaderResource] = descriptorSet;
@@ -1616,7 +1616,7 @@ angle::Result ProgramExecutableVk::updateShaderResourcesDescriptorSet(
         else
         {
             ANGLE_TRY(allocateShaderResourcesDescriptorSet(contextVk, resourceUseList,
-                                                           &shaderBuffersDesc));
+                                                           &shaderResourcesDesc));
         }
     }
     else
@@ -1640,17 +1640,17 @@ angle::Result ProgramExecutableVk::updateShaderResourcesDescriptorSet(
     for (gl::ShaderType shaderType : executable->getLinkedShaderStages())
     {
         ANGLE_TRY(updateBuffersDescriptorSet(
-            contextVk, updateBuilder, emptyBuffer, resourceUseList, shaderType, shaderBuffersDesc,
+            contextVk, updateBuilder, emptyBuffer, resourceUseList, shaderType, shaderResourcesDesc,
             uniformBuffers, executable->getUniformBlocks(), ShaderVariableType::UniformBuffer,
             mUniformBufferDescriptorType, limits.maxUniformBufferRange, cacheHit));
         ANGLE_TRY(updateBuffersDescriptorSet(
-            contextVk, updateBuilder, emptyBuffer, resourceUseList, shaderType, shaderBuffersDesc,
+            contextVk, updateBuilder, emptyBuffer, resourceUseList, shaderType, shaderResourcesDesc,
             storageBuffers, executable->getShaderStorageBlocks(),
             ShaderVariableType::ShaderStorageBuffer, kStorageBufferDescriptorType,
             limits.maxStorageBufferRange, cacheHit));
         ANGLE_TRY(updateAtomicCounterBuffersDescriptorSet(
             contextVk, updateBuilder, emptyBuffer, resourceUseList, atomicCounterBufferBindings,
-            *executable, shaderType, shaderBuffersDesc, cacheHit));
+            *executable, shaderType, shaderResourcesDesc, cacheHit));
         ANGLE_TRY(updateImagesDescriptorSet(contextVk, resourceUseList, updateBuilder, activeImages,
                                             glState.getImageUnits(), *executable, shaderType));
         ANGLE_TRY(updateInputAttachmentDescriptorSet(contextVk, resourceUseList, updateBuilder,
diff --git a/src/libANGLE/renderer/vulkan/ProgramExecutableVk.h b/src/libANGLE/renderer/vulkan/ProgramExecutableVk.h
index 30a74a744f..3083927517 100644
--- a/src/libANGLE/renderer/vulkan/ProgramExecutableVk.h
+++ b/src/libANGLE/renderer/vulkan/ProgramExecutableVk.h
@@ -171,7 +171,7 @@ class ProgramExecutableVk
         vk::BufferHelper *emptyBuffer,
         vk::ResourceUseList *resourceUseList,
         FramebufferVk *framebufferVk,
-        const vk::DescriptorSetDesc &shaderBuffersDesc);
+        const vk::DescriptorSetDesc &shaderResourcesDesc);
     angle::Result updateUniformsAndXfbDescriptorSet(vk::Context *context,
                                                     UpdateDescriptorSetsBuilder *updateBuilder,
                                                     vk::ResourceUseList *resourceUseList,
@@ -294,13 +294,13 @@ class ProgramExecutableVk
     angle::Result allocateShaderResourcesDescriptorSet(
         vk::Context *context,
         vk::ResourceUseList *resourceUseList,
-        const vk::DescriptorSetDesc *shaderBuffersDesc);
+        const vk::DescriptorSetDesc *shaderResourcesDesc);
     angle::Result updateBuffersDescriptorSet(vk::Context *context,
                                              UpdateDescriptorSetsBuilder *updateBuilder,
                                              vk::BufferHelper *emptyBuffer,
                                              vk::ResourceUseList *resourceUseList,
                                              gl::ShaderType shaderType,
-                                             const vk::DescriptorSetDesc &shaderBuffersDesc,
+                                             const vk::DescriptorSetDesc &shaderResourcesDesc,
                                              const gl::BufferVector &buffers,
                                              const std::vector<gl::InterfaceBlock> &blocks,
                                              ShaderVariableType variableType,
@@ -315,7 +315,7 @@ class ProgramExecutableVk
         const gl::BufferVector &atomicCounterBufferBindings,
         const gl::ProgramExecutable &executable,
         gl::ShaderType shaderType,
-        const vk::DescriptorSetDesc &shaderBuffersDesc,
+        const vk::DescriptorSetDesc &shaderResourcesDesc,
         bool cacheHit);
     angle::Result updateImagesDescriptorSet(vk::Context *context,
                                             vk::ResourceUseList *resourceUseList,