diff --git a/src/dawn_native/d3d12/CommandBufferD3D12.cpp b/src/dawn_native/d3d12/CommandBufferD3D12.cpp
index c2a3282..4771cde 100644
--- a/src/dawn_native/d3d12/CommandBufferD3D12.cpp
+++ b/src/dawn_native/d3d12/CommandBufferD3D12.cpp
@@ -163,20 +163,18 @@
                                 TextureViewBase* view =
                                     static_cast<TextureViewBase*>(mBindings[index][binding]);
                                 ToBackend(view->GetTexture())
-                                    ->TrackUsageAndTransitionNow(
-                                        commandContext, kReadonlyStorageTexture,
-                                        view->GetBaseMipLevel(), view->GetLevelCount(),
-                                        view->GetBaseArrayLayer(), view->GetLayerCount());
+                                    ->TrackUsageAndTransitionNow(commandContext,
+                                                                 kReadonlyStorageTexture,
+                                                                 view->GetSubresourceRange());
                                 break;
                             }
                             case wgpu::BindingType::WriteonlyStorageTexture: {
                                 TextureViewBase* view =
                                     static_cast<TextureViewBase*>(mBindings[index][binding]);
                                 ToBackend(view->GetTexture())
-                                    ->TrackUsageAndTransitionNow(
-                                        commandContext, wgpu::TextureUsage::Storage,
-                                        view->GetBaseMipLevel(), view->GetLevelCount(),
-                                        view->GetBaseArrayLayer(), view->GetLayerCount());
+                                    ->TrackUsageAndTransitionNow(commandContext,
+                                                                 wgpu::TextureUsage::Storage,
+                                                                 view->GetSubresourceRange());
                                 break;
                             }
                             case wgpu::BindingType::StorageTexture:
@@ -435,14 +433,12 @@
                 Texture* resolveTexture = ToBackend(resolveTarget->GetTexture());
 
                 // Transition the usages of the color attachment and resolve target.
-                colorTexture->TrackUsageAndTransitionNow(
-                    commandContext, D3D12_RESOURCE_STATE_RESOLVE_SOURCE,
-                    colorView->GetBaseMipLevel(), colorView->GetLevelCount(),
-                    colorView->GetBaseArrayLayer(), colorView->GetLayerCount());
-                resolveTexture->TrackUsageAndTransitionNow(
-                    commandContext, D3D12_RESOURCE_STATE_RESOLVE_DEST,
-                    resolveTarget->GetBaseMipLevel(), resolveTarget->GetLevelCount(),
-                    resolveTarget->GetBaseArrayLayer(), resolveTarget->GetLayerCount());
+                colorTexture->TrackUsageAndTransitionNow(commandContext,
+                                                         D3D12_RESOURCE_STATE_RESOLVE_SOURCE,
+                                                         colorView->GetSubresourceRange());
+                resolveTexture->TrackUsageAndTransitionNow(commandContext,
+                                                           D3D12_RESOURCE_STATE_RESOLVE_DEST,
+                                                           resolveTarget->GetSubresourceRange());
 
                 // Do MSAA resolve with ResolveSubResource().
                 ID3D12Resource* colorTextureHandle = colorTexture->GetD3D12Resource();
@@ -591,8 +587,7 @@
 
                     buffer->TrackUsageAndTransitionNow(commandContext, wgpu::BufferUsage::CopySrc);
                     texture->TrackUsageAndTransitionNow(commandContext, wgpu::TextureUsage::CopyDst,
-                                                        copy->destination.mipLevel, 1,
-                                                        copy->destination.arrayLayer, 1);
+                                                        subresource);
 
                     auto copySplit = ComputeTextureCopySplit(
                         copy->destination.origin, copy->copySize, texture->GetFormat(),
@@ -626,13 +621,12 @@
 
                     ASSERT(texture->GetDimension() == wgpu::TextureDimension::e2D);
                     ASSERT(copy->copySize.depth == 1);
-                    texture->EnsureSubresourceContentInitialized(
-                        commandContext, SubresourceRange::SingleSubresource(
-                                            copy->source.mipLevel, copy->source.arrayLayer));
+                    SubresourceRange subresource = SubresourceRange::SingleSubresource(
+                        copy->source.mipLevel, copy->source.arrayLayer);
+                    texture->EnsureSubresourceContentInitialized(commandContext, subresource);
 
                     texture->TrackUsageAndTransitionNow(commandContext, wgpu::TextureUsage::CopySrc,
-                                                        copy->source.mipLevel, 1,
-                                                        copy->source.arrayLayer, 1);
+                                                        subresource);
                     buffer->TrackUsageAndTransitionNow(commandContext, wgpu::BufferUsage::CopyDst);
 
                     TextureCopySplit copySplit = ComputeTextureCopySplit(
@@ -692,12 +686,10 @@
                                                   copy->destination.arrayLayer,
                                                   copy->copySize.depth));
                     }
-                    source->TrackUsageAndTransitionNow(
-                        commandContext, wgpu::TextureUsage::CopySrc, copy->source.mipLevel, 1,
-                        copy->source.arrayLayer, copy->copySize.depth);
-                    destination->TrackUsageAndTransitionNow(
-                        commandContext, wgpu::TextureUsage::CopyDst, copy->destination.mipLevel, 1,
-                        copy->destination.arrayLayer, copy->copySize.depth);
+                    source->TrackUsageAndTransitionNow(commandContext, wgpu::TextureUsage::CopySrc,
+                                                       srcRange);
+                    destination->TrackUsageAndTransitionNow(commandContext,
+                                                            wgpu::TextureUsage::CopyDst, dstRange);
 
                     if (CanUseCopyResource(source, destination, copy->copySize)) {
                         commandList->CopyResource(destination->GetD3D12Resource(),
@@ -886,10 +878,7 @@
 
                 resolveDestinationTexture->TrackUsageAndTransitionNow(
                     commandContext, D3D12_RESOURCE_STATE_RESOLVE_DEST,
-                    resolveDestinationView->GetBaseMipLevel(),
-                    resolveDestinationView->GetLevelCount(),
-                    resolveDestinationView->GetBaseArrayLayer(),
-                    resolveDestinationView->GetLayerCount());
+                    resolveDestinationView->GetSubresourceRange());
 
                 renderPassBuilder->SetRenderTargetEndingAccessResolve(i, attachmentInfo.storeOp,
                                                                       view, resolveDestinationView);
diff --git a/src/dawn_native/d3d12/TextureD3D12.cpp b/src/dawn_native/d3d12/TextureD3D12.cpp
index b2021f8..f9bd295 100644
--- a/src/dawn_native/d3d12/TextureD3D12.cpp
+++ b/src/dawn_native/d3d12/TextureD3D12.cpp
@@ -549,32 +549,24 @@
 
     void Texture::TrackUsageAndTransitionNow(CommandRecordingContext* commandContext,
                                              wgpu::TextureUsage usage,
-                                             uint32_t mipLevel,
-                                             uint32_t levelCount,
-                                             uint32_t arrayLayer,
-                                             uint32_t layerCount) {
-        TrackUsageAndTransitionNow(commandContext, D3D12TextureUsage(usage, GetFormat()), mipLevel,
-                                   levelCount, arrayLayer, layerCount);
+                                             const SubresourceRange& range) {
+        TrackUsageAndTransitionNow(commandContext, D3D12TextureUsage(usage, GetFormat()), range);
     }
 
     void Texture::TrackAllUsageAndTransitionNow(CommandRecordingContext* commandContext,
                                                 wgpu::TextureUsage usage) {
-        TrackUsageAndTransitionNow(commandContext, D3D12TextureUsage(usage, GetFormat()), 0,
-                                   GetNumMipLevels(), 0, GetArrayLayers());
+        TrackUsageAndTransitionNow(commandContext, D3D12TextureUsage(usage, GetFormat()),
+                                   GetAllSubresources());
     }
 
     void Texture::TrackAllUsageAndTransitionNow(CommandRecordingContext* commandContext,
                                                 D3D12_RESOURCE_STATES newState) {
-        TrackUsageAndTransitionNow(commandContext, newState, 0, GetNumMipLevels(), 0,
-                                   GetArrayLayers());
+        TrackUsageAndTransitionNow(commandContext, newState, GetAllSubresources());
     }
 
     void Texture::TrackUsageAndTransitionNow(CommandRecordingContext* commandContext,
                                              D3D12_RESOURCE_STATES newState,
-                                             uint32_t baseMipLevel,
-                                             uint32_t levelCount,
-                                             uint32_t baseArrayLayer,
-                                             uint32_t layerCount) {
+                                             const SubresourceRange& range) {
         if (mResourceAllocation.GetInfo().mMethod != AllocationMethod::kExternal) {
             // Track the underlying heap to ensure residency.
             Heap* heap = ToBackend(mResourceAllocation.GetResourceHeap());
@@ -582,10 +574,9 @@
         }
 
         std::vector<D3D12_RESOURCE_BARRIER> barriers;
-        barriers.reserve(levelCount * layerCount);
+        barriers.reserve(range.levelCount * range.layerCount);
 
-        TransitionUsageAndGetResourceBarrier(commandContext, &barriers, newState, baseMipLevel,
-                                             levelCount, baseArrayLayer, layerCount);
+        TransitionUsageAndGetResourceBarrier(commandContext, &barriers, newState, range);
         if (barriers.size()) {
             commandContext->GetCommandList()->ResourceBarrier(barriers.size(), barriers.data());
         }
@@ -687,17 +678,14 @@
         CommandRecordingContext* commandContext,
         std::vector<D3D12_RESOURCE_BARRIER>* barriers,
         D3D12_RESOURCE_STATES newState,
-        uint32_t baseMipLevel,
-        uint32_t levelCount,
-        uint32_t baseArrayLayer,
-        uint32_t layerCount) {
+        const SubresourceRange& range) {
         HandleTransitionSpecialCases(commandContext);
 
         const Serial pendingCommandSerial = ToBackend(GetDevice())->GetPendingCommandSerial();
-        for (uint32_t arrayLayer = 0; arrayLayer < layerCount; ++arrayLayer) {
-            for (uint32_t mipLevel = 0; mipLevel < levelCount; ++mipLevel) {
-                uint32_t index =
-                    GetSubresourceIndex(baseMipLevel + mipLevel, baseArrayLayer + arrayLayer);
+        for (uint32_t arrayLayer = 0; arrayLayer < range.layerCount; ++arrayLayer) {
+            for (uint32_t mipLevel = 0; mipLevel < range.levelCount; ++mipLevel) {
+                uint32_t index = GetSubresourceIndex(range.baseMipLevel + mipLevel,
+                                                     range.baseArrayLayer + arrayLayer);
 
                 TransitionSingleSubresource(barriers, newState, index, pendingCommandSerial);
             }
@@ -797,9 +785,7 @@
 
         if (GetFormat().isRenderable) {
             if (GetFormat().HasDepthOrStencil()) {
-                TrackUsageAndTransitionNow(commandContext, D3D12_RESOURCE_STATE_DEPTH_WRITE,
-                                           range.baseMipLevel, range.levelCount,
-                                           range.baseArrayLayer, range.layerCount);
+                TrackUsageAndTransitionNow(commandContext, D3D12_RESOURCE_STATE_DEPTH_WRITE, range);
 
                 D3D12_CLEAR_FLAGS clearFlags = {};
 
@@ -836,8 +822,7 @@
                 }
             } else {
                 TrackUsageAndTransitionNow(commandContext, D3D12_RESOURCE_STATE_RENDER_TARGET,
-                                           range.baseMipLevel, range.levelCount,
-                                           range.baseArrayLayer, range.layerCount);
+                                           range);
 
                 const float clearColorRGBA[4] = {fClearColor, fClearColor, fClearColor,
                                                  fClearColor};
@@ -882,9 +867,7 @@
                             uploader->Allocate(bufferSize, device->GetPendingCommandSerial()));
             memset(uploadHandle.mappedBuffer, clearColor, bufferSize);
 
-            TrackUsageAndTransitionNow(commandContext, D3D12_RESOURCE_STATE_COPY_DEST,
-                                       range.baseMipLevel, range.levelCount, range.baseArrayLayer,
-                                       range.layerCount);
+            TrackUsageAndTransitionNow(commandContext, D3D12_RESOURCE_STATE_COPY_DEST, range);
 
             for (uint32_t level = range.baseMipLevel; level < range.baseMipLevel + range.levelCount;
                  ++level) {
diff --git a/src/dawn_native/d3d12/TextureD3D12.h b/src/dawn_native/d3d12/TextureD3D12.h
index 7def9be..e152836 100644
--- a/src/dawn_native/d3d12/TextureD3D12.h
+++ b/src/dawn_native/d3d12/TextureD3D12.h
@@ -63,16 +63,10 @@
             const std::vector<wgpu::TextureUsage>& subresourceUsages);
         void TrackUsageAndTransitionNow(CommandRecordingContext* commandContext,
                                         wgpu::TextureUsage usage,
-                                        uint32_t baseMipLevel,
-                                        uint32_t levelCount,
-                                        uint32_t baseArrayLayer,
-                                        uint32_t layerCount);
+                                        const SubresourceRange& range);
         void TrackUsageAndTransitionNow(CommandRecordingContext* commandContext,
                                         D3D12_RESOURCE_STATES newState,
-                                        uint32_t baseMipLevel,
-                                        uint32_t levelCount,
-                                        uint32_t baseArrayLayer,
-                                        uint32_t layerCount);
+                                        const SubresourceRange& range);
         void TrackAllUsageAndTransitionNow(CommandRecordingContext* commandContext,
                                            wgpu::TextureUsage usage);
         void TrackAllUsageAndTransitionNow(CommandRecordingContext* commandContext,
@@ -98,10 +92,7 @@
         void TransitionUsageAndGetResourceBarrier(CommandRecordingContext* commandContext,
                                                   std::vector<D3D12_RESOURCE_BARRIER>* barrier,
                                                   D3D12_RESOURCE_STATES newState,
-                                                  uint32_t baseMipLevel,
-                                                  uint32_t levelCount,
-                                                  uint32_t baseArrayLayer,
-                                                  uint32_t layerCount);
+                                                  const SubresourceRange& range);
 
         void TransitionSingleSubresource(std::vector<D3D12_RESOURCE_BARRIER>* barriers,
                                          D3D12_RESOURCE_STATES subresourceNewState,
diff --git a/src/dawn_native/vulkan/CommandBufferVk.cpp b/src/dawn_native/vulkan/CommandBufferVk.cpp
index 460977c..73d6bbc 100644
--- a/src/dawn_native/vulkan/CommandBufferVk.cpp
+++ b/src/dawn_native/vulkan/CommandBufferVk.cpp
@@ -460,9 +460,7 @@
                     ToBackend(src.buffer)
                         ->TransitionUsageNow(recordingContext, wgpu::BufferUsage::CopySrc);
                     ToBackend(dst.texture)
-                        ->TransitionUsageNow(recordingContext, wgpu::TextureUsage::CopyDst,
-                                             subresource.mipLevel, 1, subresource.baseArrayLayer,
-                                             1);
+                        ->TransitionUsageNow(recordingContext, wgpu::TextureUsage::CopyDst, range);
                     VkBuffer srcBuffer = ToBackend(src.buffer)->GetHandle();
                     VkImage dstImage = ToBackend(dst.texture)->GetHandle();
 
@@ -485,16 +483,13 @@
 
                     ASSERT(src.texture->GetDimension() == wgpu::TextureDimension::e2D);
                     ASSERT(copy->copySize.depth == 1);
+                    SubresourceRange range = SubresourceRange::SingleSubresource(
+                        subresource.mipLevel, subresource.baseArrayLayer);
                     ToBackend(src.texture)
-                        ->EnsureSubresourceContentInitialized(
-                            recordingContext,
-                            SubresourceRange::SingleSubresource(subresource.mipLevel,
-                                                                subresource.baseArrayLayer));
+                        ->EnsureSubresourceContentInitialized(recordingContext, range);
 
                     ToBackend(src.texture)
-                        ->TransitionUsageNow(recordingContext, wgpu::TextureUsage::CopySrc,
-                                             subresource.mipLevel, 1, subresource.baseArrayLayer,
-                                             1);
+                        ->TransitionUsageNow(recordingContext, wgpu::TextureUsage::CopySrc, range);
                     ToBackend(dst.buffer)
                         ->TransitionUsageNow(recordingContext, wgpu::BufferUsage::CopyDst);
 
@@ -538,10 +533,10 @@
 
                     ToBackend(src.texture)
                         ->TransitionUsageNow(recordingContext, wgpu::TextureUsage::CopySrc,
-                                             src.mipLevel, 1, src.arrayLayer, copy->copySize.depth);
+                                             srcRange);
                     ToBackend(dst.texture)
                         ->TransitionUsageNow(recordingContext, wgpu::TextureUsage::CopyDst,
-                                             dst.mipLevel, 1, dst.arrayLayer, copy->copySize.depth);
+                                             dstRange);
 
                     // In some situations we cannot do texture-to-texture copies with vkCmdCopyImage
                     // because as Vulkan SPEC always validates image copies with the virtual size of
diff --git a/src/dawn_native/vulkan/TextureVk.cpp b/src/dawn_native/vulkan/TextureVk.cpp
index 7b35f14..110d618 100644
--- a/src/dawn_native/vulkan/TextureVk.cpp
+++ b/src/dawn_native/vulkan/TextureVk.cpp
@@ -213,10 +213,7 @@
                                                 const VkImage& image,
                                                 wgpu::TextureUsage lastUsage,
                                                 wgpu::TextureUsage usage,
-                                                uint32_t baseMipLevel,
-                                                uint32_t levelCount,
-                                                uint32_t baseArrayLayer,
-                                                uint32_t layerCount) {
+                                                const SubresourceRange& range) {
             VkImageMemoryBarrier barrier;
             barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
             barrier.pNext = nullptr;
@@ -226,10 +223,10 @@
             barrier.newLayout = VulkanImageLayout(usage, format);
             barrier.image = image;
             barrier.subresourceRange.aspectMask = VulkanAspectMask(format);
-            barrier.subresourceRange.baseMipLevel = baseMipLevel;
-            barrier.subresourceRange.levelCount = levelCount;
-            barrier.subresourceRange.baseArrayLayer = baseArrayLayer;
-            barrier.subresourceRange.layerCount = layerCount;
+            barrier.subresourceRange.baseMipLevel = range.baseMipLevel;
+            barrier.subresourceRange.levelCount = range.levelCount;
+            barrier.subresourceRange.baseArrayLayer = range.baseArrayLayer;
+            barrier.subresourceRange.layerCount = range.layerCount;
 
             barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
             barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
@@ -682,9 +679,9 @@
 
         if (mExternalState == ExternalState::PendingAcquire) {
             if (barriers->size() == transitionBarrierStart) {
-                barriers->push_back(BuildMemoryBarrier(GetFormat(), mHandle,
-                                                       wgpu::TextureUsage::None,
-                                                       wgpu::TextureUsage::None, 0, 1, 0, 1));
+                barriers->push_back(BuildMemoryBarrier(
+                    GetFormat(), mHandle, wgpu::TextureUsage::None, wgpu::TextureUsage::None,
+                    SubresourceRange::SingleSubresource(0, 0)));
             }
 
             // Transfer texture from external queue to graphics queue
@@ -696,9 +693,9 @@
             mExternalState = ExternalState::Acquired;
         } else if (mExternalState == ExternalState::PendingRelease) {
             if (barriers->size() == transitionBarrierStart) {
-                barriers->push_back(BuildMemoryBarrier(GetFormat(), mHandle,
-                                                       wgpu::TextureUsage::None,
-                                                       wgpu::TextureUsage::None, 0, 1, 0, 1));
+                barriers->push_back(BuildMemoryBarrier(
+                    GetFormat(), mHandle, wgpu::TextureUsage::None, wgpu::TextureUsage::None,
+                    SubresourceRange::SingleSubresource(0, 0)));
             }
 
             // Transfer texture from graphics queue to external queue
@@ -727,7 +724,7 @@
 
     void Texture::TransitionFullUsage(CommandRecordingContext* recordingContext,
                                       wgpu::TextureUsage usage) {
-        TransitionUsageNow(recordingContext, usage, 0, GetNumMipLevels(), 0, GetArrayLayers());
+        TransitionUsageNow(recordingContext, usage, GetAllSubresources());
     }
 
     void Texture::TransitionUsageForPass(CommandRecordingContext* recordingContext,
@@ -756,8 +753,7 @@
             }
 
             imageBarriers->push_back(BuildMemoryBarrier(format, mHandle, mSubresourceLastUsages[0],
-                                                        textureUsages.usage, 0, GetNumMipLevels(),
-                                                        0, GetArrayLayers()));
+                                                        textureUsages.usage, GetAllSubresources()));
             allLastUsages = mSubresourceLastUsages[0];
             allUsages = textureUsages.usage;
             for (uint32_t i = 0; i < subresourceCount; ++i) {
@@ -779,7 +775,8 @@
                     }
                     imageBarriers->push_back(BuildMemoryBarrier(
                         format, mHandle, mSubresourceLastUsages[index],
-                        textureUsages.subresourceUsages[index], mipLevel, 1, arrayLayer, 1));
+                        textureUsages.subresourceUsages[index],
+                        SubresourceRange::SingleSubresource(mipLevel, arrayLayer)));
                     allLastUsages |= mSubresourceLastUsages[index];
                     allUsages |= textureUsages.subresourceUsages[index];
                     mSubresourceLastUsages[index] = textureUsages.subresourceUsages[index];
@@ -799,10 +796,7 @@
 
     void Texture::TransitionUsageNow(CommandRecordingContext* recordingContext,
                                      wgpu::TextureUsage usage,
-                                     uint32_t baseMipLevel,
-                                     uint32_t levelCount,
-                                     uint32_t baseArrayLayer,
-                                     uint32_t layerCount) {
+                                     const SubresourceRange& range) {
         std::vector<VkImageMemoryBarrier> barriers;
         const Format& format = GetFormat();
 
@@ -816,29 +810,32 @@
         // are the same, then we can use one barrier to do state transition for all subresources.
         // Note that if the texture has only one mip level and one array slice, it will fall into
         // this category.
-        bool isAllSubresourcesCovered = levelCount * layerCount == subresourceCount;
+        bool isAllSubresourcesCovered = range.levelCount * range.layerCount == subresourceCount;
         if (mSameLastUsagesAcrossSubresources && isAllSubresourcesCovered) {
-            ASSERT(baseMipLevel == 0 && baseArrayLayer == 0);
+            ASSERT(range.baseMipLevel == 0 && range.baseArrayLayer == 0);
             if (CanReuseWithoutBarrier(mSubresourceLastUsages[0], usage)) {
                 return;
             }
-            barriers.push_back(BuildMemoryBarrier(format, mHandle, mSubresourceLastUsages[0], usage,
-                                                  0, levelCount, 0, layerCount));
+            barriers.push_back(
+                BuildMemoryBarrier(format, mHandle, mSubresourceLastUsages[0], usage, range));
             allLastUsages = mSubresourceLastUsages[0];
             for (uint32_t i = 0; i < subresourceCount; ++i) {
                 mSubresourceLastUsages[i] = usage;
             }
         } else {
-            for (uint32_t layer = baseArrayLayer; layer < baseArrayLayer + layerCount; ++layer) {
-                for (uint32_t level = baseMipLevel; level < baseMipLevel + levelCount; ++level) {
+            for (uint32_t layer = range.baseArrayLayer;
+                 layer < range.baseArrayLayer + range.layerCount; ++layer) {
+                for (uint32_t level = range.baseMipLevel;
+                     level < range.baseMipLevel + range.levelCount; ++level) {
                     uint32_t index = GetSubresourceIndex(level, layer);
 
                     if (CanReuseWithoutBarrier(mSubresourceLastUsages[index], usage)) {
                         continue;
                     }
 
-                    barriers.push_back(BuildMemoryBarrier(
-                        format, mHandle, mSubresourceLastUsages[index], usage, level, 1, layer, 1));
+                    barriers.push_back(
+                        BuildMemoryBarrier(format, mHandle, mSubresourceLastUsages[index], usage,
+                                           SubresourceRange::SingleSubresource(level, layer)));
                     allLastUsages |= mSubresourceLastUsages[index];
                     mSubresourceLastUsages[index] = usage;
                 }
@@ -866,8 +863,7 @@
         uint8_t clearColor = (clearValue == TextureBase::ClearValue::Zero) ? 0 : 1;
         float fClearColor = (clearValue == TextureBase::ClearValue::Zero) ? 0.f : 1.f;
 
-        TransitionUsageNow(recordingContext, wgpu::TextureUsage::CopyDst, range.baseMipLevel,
-                           range.levelCount, range.baseArrayLayer, range.layerCount);
+        TransitionUsageNow(recordingContext, wgpu::TextureUsage::CopyDst, range);
         if (GetFormat().isRenderable) {
             VkImageSubresourceRange imageRange = {};
             imageRange.aspectMask = GetVkAspectMask();
diff --git a/src/dawn_native/vulkan/TextureVk.h b/src/dawn_native/vulkan/TextureVk.h
index 4da7c48..8a1564a 100644
--- a/src/dawn_native/vulkan/TextureVk.h
+++ b/src/dawn_native/vulkan/TextureVk.h
@@ -69,10 +69,7 @@
 
         void TransitionUsageNow(CommandRecordingContext* recordingContext,
                                 wgpu::TextureUsage usage,
-                                uint32_t baseMipLevel,
-                                uint32_t levelCount,
-                                uint32_t baseArrayLayer,
-                                uint32_t layerCount);
+                                const SubresourceRange& range);
         void TransitionUsageForPass(CommandRecordingContext* recordingContext,
                                     const PassTextureUsage& textureUsages,
                                     std::vector<VkImageMemoryBarrier>* imageBarriers,