[dawn][headers] ImageCopy* structure renames.

- Renames according to upstream header changes:
  https://github.com/webgpu-native/webgpu-headers/pull/389
- Includes the following renames:
  - ImageCopyBuffer   -> TexelCopyBufferInfo
  - ImageCopyTexture  -> TexelCopyTextureInfo
  - TextureDataLayout -> TexelCopyBufferLayout
- Also removes extensibility on
  TextureDataLayout/TexelCopyBufferLayout.
- Note that typedefs are kept until downstream users are
  updated.

Bug: 42240793
Change-Id: I18d11a0a7421299071a276a76c2e35c50977855f
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/224474
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Loko Kung <lokokung@google.com>
diff --git a/src/dawn/dawn.json b/src/dawn/dawn.json
index cffc024..bca1058 100644
--- a/src/dawn/dawn.json
+++ b/src/dawn/dawn.json
@@ -784,24 +784,24 @@
             {
                 "name": "copy buffer to texture",
                 "args": [
-                    {"name": "source", "type": "image copy buffer", "annotation": "const*"},
-                    {"name": "destination", "type": "image copy texture", "annotation": "const*"},
+                    {"name": "source", "type": "texel copy buffer info", "annotation": "const*"},
+                    {"name": "destination", "type": "texel copy texture info", "annotation": "const*"},
                     {"name": "copy size", "type": "extent 3D", "annotation": "const*"}
                 ]
             },
             {
                 "name": "copy texture to buffer",
                 "args": [
-                    {"name": "source", "type": "image copy texture", "annotation": "const*"},
-                    {"name": "destination", "type": "image copy buffer", "annotation": "const*"},
+                    {"name": "source", "type": "texel copy texture info", "annotation": "const*"},
+                    {"name": "destination", "type": "texel copy buffer info", "annotation": "const*"},
                     {"name": "copy size", "type": "extent 3D", "annotation": "const*"}
                 ]
             },
             {
                 "name": "copy texture to texture",
                 "args": [
-                    {"name": "source", "type": "image copy texture", "annotation": "const*"},
-                    {"name": "destination", "type": "image copy texture", "annotation": "const*"},
+                    {"name": "source", "type": "texel copy texture info", "annotation": "const*"},
+                    {"name": "destination", "type": "texel copy texture info", "annotation": "const*"},
                     {"name": "copy size", "type": "extent 3D", "annotation": "const*"}
                 ]
             },
@@ -2310,13 +2310,29 @@
         ]
     },
     "image copy buffer": {
+        "category": "typedef",
+        "type": "texel copy buffer info"
+    },
+    "texel copy buffer info": {
         "category": "structure",
         "members": [
-            {"name": "layout", "type": "texture data layout"},
+            {"name": "layout", "type": "texel copy buffer layout"},
             {"name": "buffer", "type": "buffer"}
         ]
     },
+    "texel copy buffer layout": {
+        "category": "structure",
+        "members": [
+            {"name": "offset", "type": "uint64_t", "default": 0},
+            {"name": "bytes per row", "type": "uint32_t", "default": "WGPU_COPY_STRIDE_UNDEFINED"},
+            {"name": "rows per image", "type": "uint32_t", "default": "WGPU_COPY_STRIDE_UNDEFINED"}
+        ]
+    },
     "image copy texture": {
+        "category": "typedef",
+        "type": "texel copy texture info"
+    },
+    "texel copy texture info": {
         "category": "structure",
         "members": [
             {"name": "texture", "type": "texture"},
@@ -2689,10 +2705,10 @@
             {
                 "name": "write texture",
                 "args": [
-                    {"name": "destination", "type": "image copy texture", "annotation": "const*"},
+                    {"name": "destination", "type": "texel copy texture info", "annotation": "const*"},
                     {"name": "data", "type": "void", "annotation": "const*", "length": "data size"},
                     {"name": "data size", "type": "size_t"},
-                    {"name": "data layout", "type": "texture data layout", "annotation": "const*"},
+                    {"name": "data layout", "type": "texel copy buffer layout", "annotation": "const*"},
                     {"name": "write size", "type": "extent 3D", "annotation": "const*"}
                 ]
             },
@@ -2701,8 +2717,8 @@
                 "extensible": "in",
                 "tags": ["dawn"],
                 "args": [
-                    {"name": "source", "type": "image copy texture", "annotation": "const*"},
-                    {"name": "destination", "type": "image copy texture", "annotation": "const*"},
+                    {"name": "source", "type": "texel copy texture info", "annotation": "const*"},
+                    {"name": "destination", "type": "texel copy texture info", "annotation": "const*"},
                     {"name": "copy size", "type": "extent 3D", "annotation": "const*"},
                     {"name": "options", "type": "copy texture for browser options", "annotation": "const*"}
                 ]
@@ -2713,7 +2729,7 @@
                 "tags": ["dawn"],
                 "args": [
                     {"name": "source", "type": "image copy external texture", "annotation": "const*"},
-                    {"name": "destination", "type": "image copy texture", "annotation": "const*"},
+                    {"name": "destination", "type": "texel copy texture info", "annotation": "const*"},
                     {"name": "copy size", "type": "extent 3D", "annotation": "const*"},
                     {"name": "options", "type": "copy texture for browser options", "annotation": "const*"}
                 ]
@@ -3801,13 +3817,8 @@
         ]
     },
     "texture data layout": {
-        "category": "structure",
-        "extensible": "in",
-        "members": [
-            {"name": "offset", "type": "uint64_t", "default": 0},
-            {"name": "bytes per row", "type": "uint32_t", "default": "WGPU_COPY_STRIDE_UNDEFINED"},
-            {"name": "rows per image", "type": "uint32_t", "default": "WGPU_COPY_STRIDE_UNDEFINED"}
-        ]
+        "category": "typedef",
+        "type": "texel copy buffer layout"
     },
     "texture descriptor": {
         "category": "structure",
diff --git a/src/dawn/dawn_wire.json b/src/dawn/dawn_wire.json
index ca6df05..73b104c 100644
--- a/src/dawn/dawn_wire.json
+++ b/src/dawn/dawn_wire.json
@@ -92,10 +92,10 @@
         ],
         "queue write texture": [
             {"name": "queue id", "type": "ObjectId", "id_type": "queue" },
-            {"name": "destination", "type": "image copy texture", "annotation": "const*"},
+            {"name": "destination", "type": "texel copy texture info", "annotation": "const*"},
             {"name": "data", "type": "uint8_t", "annotation": "const*", "length": "data size", "wire_is_data_only": true},
             {"name": "data size", "type": "uint64_t"},
-            {"name": "data layout", "type": "texture data layout", "annotation": "const*"},
+            {"name": "data layout", "type": "texel copy buffer layout", "annotation": "const*"},
             {"name": "writeSize", "type": "extent 3D", "annotation": "const*"}
         ],
         "shader module get compilation info": [
diff --git a/src/dawn/native/BlitBufferToDepthStencil.cpp b/src/dawn/native/BlitBufferToDepthStencil.cpp
index c676c26..e006944 100644
--- a/src/dawn/native/BlitBufferToDepthStencil.cpp
+++ b/src/dawn/native/BlitBufferToDepthStencil.cpp
@@ -507,7 +507,7 @@
 
 MaybeError BlitStagingBufferToDepth(DeviceBase* device,
                                     BufferBase* buffer,
-                                    const TextureDataLayout& src,
+                                    const TexelCopyBufferLayout& src,
                                     const TextureCopy& dst,
                                     const Extent3D& copyExtent) {
     const Format& format = dst.texture->GetFormat();
@@ -546,7 +546,7 @@
 MaybeError BlitBufferToDepth(DeviceBase* device,
                              CommandEncoder* commandEncoder,
                              BufferBase* buffer,
-                             const TextureDataLayout& src,
+                             const TexelCopyBufferLayout& src,
                              const TextureCopy& dst,
                              const Extent3D& copyExtent) {
     const Format& format = dst.texture->GetFormat();
@@ -560,11 +560,11 @@
     Ref<TextureBase> dataTexture;
     DAWN_TRY_ASSIGN(dataTexture, device->CreateTexture(&dataTextureDesc));
     {
-        ImageCopyBuffer bufferSrc;
+        TexelCopyBufferInfo bufferSrc;
         bufferSrc.buffer = buffer;
         bufferSrc.layout = src;
 
-        ImageCopyTexture textureDst;
+        TexelCopyTextureInfo textureDst;
         textureDst.texture = dataTexture.Get();
         commandEncoder->APICopyBufferToTexture(&bufferSrc, &textureDst, &copyExtent);
     }
@@ -575,7 +575,7 @@
 
 MaybeError BlitStagingBufferToStencil(DeviceBase* device,
                                       BufferBase* buffer,
-                                      const TextureDataLayout& src,
+                                      const TexelCopyBufferLayout& src,
                                       const TextureCopy& dst,
                                       const Extent3D& copyExtent) {
     TextureDescriptor dataTextureDesc = {};
@@ -610,7 +610,7 @@
 MaybeError BlitBufferToStencil(DeviceBase* device,
                                CommandEncoder* commandEncoder,
                                BufferBase* buffer,
-                               const TextureDataLayout& src,
+                               const TexelCopyBufferLayout& src,
                                const TextureCopy& dst,
                                const Extent3D& copyExtent) {
     TextureDescriptor dataTextureDesc = {};
@@ -621,11 +621,11 @@
     Ref<TextureBase> dataTexture;
     DAWN_TRY_ASSIGN(dataTexture, device->CreateTexture(&dataTextureDesc));
     {
-        ImageCopyBuffer bufferSrc;
+        TexelCopyBufferInfo bufferSrc;
         bufferSrc.buffer = buffer;
         bufferSrc.layout = src;
 
-        ImageCopyTexture textureDst;
+        TexelCopyTextureInfo textureDst;
         textureDst.texture = dataTexture.Get();
         commandEncoder->APICopyBufferToTexture(&bufferSrc, &textureDst, &copyExtent);
     }
diff --git a/src/dawn/native/BlitBufferToDepthStencil.h b/src/dawn/native/BlitBufferToDepthStencil.h
index fc9e8b6..a070296 100644
--- a/src/dawn/native/BlitBufferToDepthStencil.h
+++ b/src/dawn/native/BlitBufferToDepthStencil.h
@@ -48,14 +48,14 @@
 
 MaybeError BlitStagingBufferToDepth(DeviceBase* device,
                                     BufferBase* buffer,
-                                    const TextureDataLayout& src,
+                                    const TexelCopyBufferLayout& src,
                                     const TextureCopy& dst,
                                     const Extent3D& copyExtent);
 
 MaybeError BlitBufferToDepth(DeviceBase* device,
                              CommandEncoder* commandEncoder,
                              BufferBase* buffer,
-                             const TextureDataLayout& src,
+                             const TexelCopyBufferLayout& src,
                              const TextureCopy& dst,
                              const Extent3D& copyExtent);
 
@@ -84,14 +84,14 @@
 
 MaybeError BlitStagingBufferToStencil(DeviceBase* device,
                                       BufferBase* buffer,
-                                      const TextureDataLayout& src,
+                                      const TexelCopyBufferLayout& src,
                                       const TextureCopy& dst,
                                       const Extent3D& copyExtent);
 
 MaybeError BlitBufferToStencil(DeviceBase* device,
                                CommandEncoder* commandEncoder,
                                BufferBase* buffer,
-                               const TextureDataLayout& src,
+                               const TexelCopyBufferLayout& src,
                                const TextureCopy& dst,
                                const Extent3D& copyExtent);
 
diff --git a/src/dawn/native/BlitDepthToDepth.cpp b/src/dawn/native/BlitDepthToDepth.cpp
index fd0767e..f7f7f8b 100644
--- a/src/dawn/native/BlitDepthToDepth.cpp
+++ b/src/dawn/native/BlitDepthToDepth.cpp
@@ -162,13 +162,13 @@
 
             // Copy from the original texture source into the intermediate.
             {
-                ImageCopyTexture intermediateSrc;
+                TexelCopyTextureInfo intermediateSrc;
                 intermediateSrc.texture = src.texture.Get();
                 intermediateSrc.mipLevel = src.mipLevel;
                 intermediateSrc.origin = {0, 0, layer};
                 intermediateSrc.aspect = wgpu::TextureAspect::All;
 
-                ImageCopyTexture intermediateDst;
+                TexelCopyTextureInfo intermediateDst;
                 intermediateDst.texture = intermediateTexture.Get();
                 intermediateDst.mipLevel = 0u;
                 intermediateDst.origin = {0, 0, 0};
diff --git a/src/dawn/native/CommandEncoder.cpp b/src/dawn/native/CommandEncoder.cpp
index 3080ccc..601f965 100644
--- a/src/dawn/native/CommandEncoder.cpp
+++ b/src/dawn/native/CommandEncoder.cpp
@@ -305,7 +305,7 @@
     return {};
 }
 
-MaybeError ValidateLinearTextureCopyOffset(const TextureDataLayout& layout,
+MaybeError ValidateLinearTextureCopyOffset(const TexelCopyBufferLayout& layout,
                                            const TexelBlockInfo& blockInfo,
                                            const bool hasDepthOrStencil) {
     if (hasDepthOrStencil) {
@@ -340,9 +340,9 @@
     return {};
 }
 
-MaybeError ValidateTextureDepthStencilToBufferCopyRestrictions(const ImageCopyTexture& src) {
+MaybeError ValidateTextureDepthStencilToBufferCopyRestrictions(const TexelCopyTextureInfo& src) {
     Aspect aspectUsed;
-    DAWN_TRY_ASSIGN(aspectUsed, SingleAspectUsedByImageCopyTexture(src));
+    DAWN_TRY_ASSIGN(aspectUsed, SingleAspectUsedByTexelCopyTextureInfo(src));
     if (aspectUsed == Aspect::Depth) {
         switch (src.texture->GetFormat().format) {
             case wgpu::TextureFormat::Depth24Plus:
@@ -1549,20 +1549,20 @@
         destination, destinationOffset, size);
 }
 
-void CommandEncoder::APICopyBufferToTexture(const ImageCopyBuffer* source,
-                                            const ImageCopyTexture* destinationOrig,
+void CommandEncoder::APICopyBufferToTexture(const TexelCopyBufferInfo* source,
+                                            const TexelCopyTextureInfo* destinationOrig,
                                             const Extent3D* copySize) {
-    ImageCopyTexture destination = destinationOrig->WithTrivialFrontendDefaults();
+    TexelCopyTextureInfo destination = destinationOrig->WithTrivialFrontendDefaults();
 
     mEncodingContext.TryEncode(
         this,
         [&](CommandAllocator* allocator) -> MaybeError {
             if (GetDevice()->IsValidationEnabled()) {
-                DAWN_TRY(ValidateImageCopyBuffer(GetDevice(), *source));
+                DAWN_TRY(ValidateTexelCopyBufferInfo(GetDevice(), *source));
                 DAWN_TRY_CONTEXT(ValidateCanUseAs(source->buffer, wgpu::BufferUsage::CopySrc),
                                  "validating source %s usage.", source->buffer);
 
-                DAWN_TRY(ValidateImageCopyTexture(GetDevice(), destination, *copySize));
+                DAWN_TRY(ValidateTexelCopyTextureInfo(GetDevice(), destination, *copySize));
                 DAWN_TRY_CONTEXT(ValidateCanUseAs(destination.texture, wgpu::TextureUsage::CopyDst,
                                                   mUsageValidationMode),
                                  "validating destination %s usage.", destination.texture);
@@ -1588,8 +1588,8 @@
             mTopLevelBuffers.insert(source->buffer);
             mTopLevelTextures.insert(destination.texture);
 
-            TextureDataLayout srcLayout = source->layout;
-            ApplyDefaultTextureDataLayoutOptions(&srcLayout, blockInfo, *copySize);
+            TexelCopyBufferLayout srcLayout = source->layout;
+            ApplyDefaultTexelCopyBufferLayoutOptions(&srcLayout, blockInfo, *copySize);
 
             TextureCopy dst;
             dst.texture = destination.texture;
@@ -1638,23 +1638,23 @@
         copySize);
 }
 
-void CommandEncoder::APICopyTextureToBuffer(const ImageCopyTexture* sourceOrig,
-                                            const ImageCopyBuffer* destination,
+void CommandEncoder::APICopyTextureToBuffer(const TexelCopyTextureInfo* sourceOrig,
+                                            const TexelCopyBufferInfo* destination,
                                             const Extent3D* copySize) {
-    ImageCopyTexture source = sourceOrig->WithTrivialFrontendDefaults();
+    TexelCopyTextureInfo source = sourceOrig->WithTrivialFrontendDefaults();
 
     mEncodingContext.TryEncode(
         this,
         [&](CommandAllocator* allocator) -> MaybeError {
             if (GetDevice()->IsValidationEnabled()) {
-                DAWN_TRY(ValidateImageCopyTexture(GetDevice(), source, *copySize));
+                DAWN_TRY(ValidateTexelCopyTextureInfo(GetDevice(), source, *copySize));
                 DAWN_TRY_CONTEXT(ValidateCanUseAs(source.texture, wgpu::TextureUsage::CopySrc,
                                                   mUsageValidationMode),
                                  "validating source %s usage.", source.texture);
                 DAWN_TRY(ValidateTextureSampleCountInBufferCopyCommands(source.texture));
                 DAWN_TRY(ValidateTextureDepthStencilToBufferCopyRestrictions(source));
 
-                DAWN_TRY(ValidateImageCopyBuffer(GetDevice(), *destination));
+                DAWN_TRY(ValidateTexelCopyBufferInfo(GetDevice(), *destination));
                 DAWN_TRY_CONTEXT(ValidateCanUseAs(destination->buffer, wgpu::BufferUsage::CopyDst),
                                  "validating destination %s usage.", destination->buffer);
 
@@ -1682,8 +1682,8 @@
             mTopLevelTextures.insert(source.texture);
             mTopLevelBuffers.insert(destination->buffer);
 
-            TextureDataLayout dstLayout = destination->layout;
-            ApplyDefaultTextureDataLayoutOptions(&dstLayout, blockInfo, *copySize);
+            TexelCopyBufferLayout dstLayout = destination->layout;
+            ApplyDefaultTexelCopyBufferLayoutOptions(&dstLayout, blockInfo, *copySize);
 
             if (copySize->width == 0 || copySize->height == 0 ||
                 copySize->depthOrArrayLayers == 0) {
@@ -1737,11 +1737,11 @@
         copySize);
 }
 
-void CommandEncoder::APICopyTextureToTexture(const ImageCopyTexture* sourceOrig,
-                                             const ImageCopyTexture* destinationOrig,
+void CommandEncoder::APICopyTextureToTexture(const TexelCopyTextureInfo* sourceOrig,
+                                             const TexelCopyTextureInfo* destinationOrig,
                                              const Extent3D* copySize) {
-    ImageCopyTexture source = sourceOrig->WithTrivialFrontendDefaults();
-    ImageCopyTexture destination = destinationOrig->WithTrivialFrontendDefaults();
+    TexelCopyTextureInfo source = sourceOrig->WithTrivialFrontendDefaults();
+    TexelCopyTextureInfo destination = destinationOrig->WithTrivialFrontendDefaults();
 
     mEncodingContext.TryEncode(
         this,
@@ -1754,9 +1754,9 @@
                                     destination.texture->GetFormat().IsMultiPlanar(),
                                 "Copying between a multiplanar texture and another texture is "
                                 "currently not allowed.");
-                DAWN_TRY_CONTEXT(ValidateImageCopyTexture(GetDevice(), source, *copySize),
+                DAWN_TRY_CONTEXT(ValidateTexelCopyTextureInfo(GetDevice(), source, *copySize),
                                  "validating source %s.", source.texture);
-                DAWN_TRY_CONTEXT(ValidateImageCopyTexture(GetDevice(), destination, *copySize),
+                DAWN_TRY_CONTEXT(ValidateTexelCopyTextureInfo(GetDevice(), destination, *copySize),
                                  "validating destination %s.", destination.texture);
 
                 DAWN_TRY_CONTEXT(ValidateTextureCopyRange(GetDevice(), source, *copySize),
@@ -1818,7 +1818,7 @@
                 Ref<BufferBase> intermediateBuffer;
                 DAWN_TRY_ASSIGN(intermediateBuffer, GetDevice()->CreateBuffer(&descriptor));
 
-                ImageCopyBuffer buf;
+                TexelCopyBufferInfo buf;
                 buf.buffer = intermediateBuffer.Get();
                 buf.layout.bytesPerRow = bytesPerRow;
                 buf.layout.rowsPerImage = rowsPerImage;
diff --git a/src/dawn/native/CommandEncoder.h b/src/dawn/native/CommandEncoder.h
index a94457d..5f1b5e63 100644
--- a/src/dawn/native/CommandEncoder.h
+++ b/src/dawn/native/CommandEncoder.h
@@ -80,14 +80,14 @@
                                                      BufferBase* destination,
                                                      uint64_t destinationOffset,
                                                      uint64_t size);
-    void APICopyBufferToTexture(const ImageCopyBuffer* source,
-                                const ImageCopyTexture* destination,
+    void APICopyBufferToTexture(const TexelCopyBufferInfo* source,
+                                const TexelCopyTextureInfo* destination,
                                 const Extent3D* copySize);
-    void APICopyTextureToBuffer(const ImageCopyTexture* source,
-                                const ImageCopyBuffer* destination,
+    void APICopyTextureToBuffer(const TexelCopyTextureInfo* source,
+                                const TexelCopyBufferInfo* destination,
                                 const Extent3D* copySize);
-    void APICopyTextureToTexture(const ImageCopyTexture* source,
-                                 const ImageCopyTexture* destination,
+    void APICopyTextureToTexture(const TexelCopyTextureInfo* source,
+                                 const TexelCopyTextureInfo* destination,
                                  const Extent3D* copySize);
     void APIClearBuffer(BufferBase* destination, uint64_t destinationOffset, uint64_t size);
 
diff --git a/src/dawn/native/CommandValidation.cpp b/src/dawn/native/CommandValidation.cpp
index 4f2e5f0..863d535 100644
--- a/src/dawn/native/CommandValidation.cpp
+++ b/src/dawn/native/CommandValidation.cpp
@@ -325,9 +325,9 @@
 
 // Replace wgpu::kCopyStrideUndefined with real values, so backends don't have to think about
 // it.
-void ApplyDefaultTextureDataLayoutOptions(TextureDataLayout* layout,
-                                          const TexelBlockInfo& blockInfo,
-                                          const Extent3D& copyExtent) {
+void ApplyDefaultTexelCopyBufferLayoutOptions(TexelCopyBufferLayout* layout,
+                                              const TexelBlockInfo& blockInfo,
+                                              const Extent3D& copyExtent) {
     DAWN_ASSERT(layout != nullptr);
     DAWN_ASSERT(copyExtent.height % blockInfo.height == 0);
     uint32_t heightInBlocks = copyExtent.height / blockInfo.height;
@@ -346,7 +346,7 @@
     }
 }
 
-MaybeError ValidateLinearTextureData(const TextureDataLayout& layout,
+MaybeError ValidateLinearTextureData(const TexelCopyBufferLayout& layout,
                                      uint64_t byteSize,
                                      const TexelBlockInfo& blockInfo,
                                      const Extent3D& copyExtent) {
@@ -403,26 +403,26 @@
     return {};
 }
 
-MaybeError ValidateImageCopyBuffer(DeviceBase const* device,
-                                   const ImageCopyBuffer& imageCopyBuffer) {
-    DAWN_TRY(device->ValidateObject(imageCopyBuffer.buffer));
+MaybeError ValidateTexelCopyBufferInfo(DeviceBase const* device,
+                                       const TexelCopyBufferInfo& texelCopyBufferInfo) {
+    DAWN_TRY(device->ValidateObject(texelCopyBufferInfo.buffer));
     auto alignment = kTextureBytesPerRowAlignment;
     if (device->HasFeature(Feature::DawnTexelCopyBufferRowAlignment)) {
         alignment =
             device->GetLimits().texelCopyBufferRowAlignmentLimits.minTexelCopyBufferRowAlignment;
     }
-    if (imageCopyBuffer.layout.bytesPerRow != wgpu::kCopyStrideUndefined) {
-        DAWN_INVALID_IF(imageCopyBuffer.layout.bytesPerRow % alignment != 0,
+    if (texelCopyBufferInfo.layout.bytesPerRow != wgpu::kCopyStrideUndefined) {
+        DAWN_INVALID_IF(texelCopyBufferInfo.layout.bytesPerRow % alignment != 0,
                         "bytesPerRow (%u) is not a multiple of %u.",
-                        imageCopyBuffer.layout.bytesPerRow, alignment);
+                        texelCopyBufferInfo.layout.bytesPerRow, alignment);
     }
 
     return {};
 }
 
-MaybeError ValidateImageCopyTexture(DeviceBase const* device,
-                                    const ImageCopyTexture& textureCopy,
-                                    const Extent3D& copySize) {
+MaybeError ValidateTexelCopyTextureInfo(DeviceBase const* device,
+                                        const TexelCopyTextureInfo& textureCopy,
+                                        const Extent3D& copySize) {
     const TextureBase* texture = textureCopy.texture;
     DAWN_TRY(device->ValidateObject(texture));
 
@@ -456,7 +456,7 @@
 }
 
 MaybeError ValidateTextureCopyRange(DeviceBase const* device,
-                                    const ImageCopyTexture& textureCopy,
+                                    const TexelCopyTextureInfo& textureCopy,
                                     const Extent3D& copySize) {
     const TextureBase* texture = textureCopy.texture;
     const Format& format = textureCopy.texture->GetFormat();
@@ -515,7 +515,7 @@
 
 // Always returns a single aspect (color, stencil, depth, or ith plane for multi-planar
 // formats).
-ResultOrError<Aspect> SingleAspectUsedByImageCopyTexture(const ImageCopyTexture& view) {
+ResultOrError<Aspect> SingleAspectUsedByTexelCopyTextureInfo(const TexelCopyTextureInfo& view) {
     const Format& format = view.texture->GetFormat();
     switch (view.aspect) {
         case wgpu::TextureAspect::All: {
@@ -546,9 +546,9 @@
     DAWN_UNREACHABLE();
 }
 
-MaybeError ValidateLinearToDepthStencilCopyRestrictions(const ImageCopyTexture& dst) {
+MaybeError ValidateLinearToDepthStencilCopyRestrictions(const TexelCopyTextureInfo& dst) {
     Aspect aspectUsed;
-    DAWN_TRY_ASSIGN(aspectUsed, SingleAspectUsedByImageCopyTexture(dst));
+    DAWN_TRY_ASSIGN(aspectUsed, SingleAspectUsedByTexelCopyTextureInfo(dst));
 
     const Format& format = dst.texture->GetFormat();
     switch (format.format) {
@@ -565,8 +565,8 @@
 }
 
 MaybeError ValidateTextureToTextureCopyCommonRestrictions(DeviceBase const* device,
-                                                          const ImageCopyTexture& src,
-                                                          const ImageCopyTexture& dst,
+                                                          const TexelCopyTextureInfo& src,
+                                                          const TexelCopyTextureInfo& dst,
                                                           const Extent3D& copySize) {
     const uint32_t srcSamples = src.texture->GetSampleCount();
     const uint32_t dstSamples = dst.texture->GetSampleCount();
@@ -625,8 +625,8 @@
 }
 
 MaybeError ValidateTextureToTextureCopyRestrictions(DeviceBase const* device,
-                                                    const ImageCopyTexture& src,
-                                                    const ImageCopyTexture& dst,
+                                                    const TexelCopyTextureInfo& src,
+                                                    const TexelCopyTextureInfo& dst,
                                                     const Extent3D& copySize) {
     // Metal requires texture-to-texture copies happens between texture formats that equal to
     // each other or only have diff on srgb-ness.
diff --git a/src/dawn/native/CommandValidation.h b/src/dawn/native/CommandValidation.h
index 5f176a4..e5691b5 100644
--- a/src/dawn/native/CommandValidation.h
+++ b/src/dawn/native/CommandValidation.h
@@ -73,24 +73,24 @@
                                                    uint32_t bytesPerRow,
                                                    uint32_t rowsPerImage);
 
-void ApplyDefaultTextureDataLayoutOptions(TextureDataLayout* layout,
-                                          const TexelBlockInfo& blockInfo,
-                                          const Extent3D& copyExtent);
-MaybeError ValidateLinearTextureData(const TextureDataLayout& layout,
+void ApplyDefaultTexelCopyBufferLayoutOptions(TexelCopyBufferLayout* layout,
+                                              const TexelBlockInfo& blockInfo,
+                                              const Extent3D& copyExtent);
+MaybeError ValidateLinearTextureData(const TexelCopyBufferLayout& layout,
                                      uint64_t byteSize,
                                      const TexelBlockInfo& blockInfo,
                                      const Extent3D& copyExtent);
 MaybeError ValidateTextureCopyRange(DeviceBase const* device,
-                                    const ImageCopyTexture& imageCopyTexture,
+                                    const TexelCopyTextureInfo& TexelCopyTextureInfo,
                                     const Extent3D& copySize);
-ResultOrError<Aspect> SingleAspectUsedByImageCopyTexture(const ImageCopyTexture& view);
-MaybeError ValidateLinearToDepthStencilCopyRestrictions(const ImageCopyTexture& dst);
+ResultOrError<Aspect> SingleAspectUsedByTexelCopyTextureInfo(const TexelCopyTextureInfo& view);
+MaybeError ValidateLinearToDepthStencilCopyRestrictions(const TexelCopyTextureInfo& dst);
 
-MaybeError ValidateImageCopyBuffer(DeviceBase const* device,
-                                   const ImageCopyBuffer& imageCopyBuffer);
-MaybeError ValidateImageCopyTexture(DeviceBase const* device,
-                                    const ImageCopyTexture& imageCopyTexture,
-                                    const Extent3D& copySize);
+MaybeError ValidateTexelCopyBufferInfo(DeviceBase const* device,
+                                       const TexelCopyBufferInfo& texelCopyBufferInfo);
+MaybeError ValidateTexelCopyTextureInfo(DeviceBase const* device,
+                                        const TexelCopyTextureInfo& TexelCopyTextureInfo,
+                                        const Extent3D& copySize);
 
 MaybeError ValidateCopySizeFitsInBuffer(const Ref<BufferBase>& buffer,
                                         uint64_t offset,
@@ -100,12 +100,12 @@
 bool IsRangeOverlapped(uint32_t startA, uint32_t startB, uint32_t length);
 
 MaybeError ValidateTextureToTextureCopyCommonRestrictions(DeviceBase const* device,
-                                                          const ImageCopyTexture& src,
-                                                          const ImageCopyTexture& dst,
+                                                          const TexelCopyTextureInfo& src,
+                                                          const TexelCopyTextureInfo& dst,
                                                           const Extent3D& copySize);
 MaybeError ValidateTextureToTextureCopyRestrictions(DeviceBase const* device,
-                                                    const ImageCopyTexture& src,
-                                                    const ImageCopyTexture& dst,
+                                                    const TexelCopyTextureInfo& src,
+                                                    const TexelCopyTextureInfo& dst,
                                                     const Extent3D& copySize);
 
 MaybeError ValidateCanUseAs(const TextureBase* textureView,
diff --git a/src/dawn/native/CopyTextureForBrowserHelper.cpp b/src/dawn/native/CopyTextureForBrowserHelper.cpp
index 641c048..1f0e09e 100644
--- a/src/dawn/native/CopyTextureForBrowserHelper.cpp
+++ b/src/dawn/native/CopyTextureForBrowserHelper.cpp
@@ -399,7 +399,7 @@
 MaybeError DoCopyForBrowser(DeviceBase* device,
                             const TextureInfo* sourceInfo,
                             T* sourceResource,
-                            const ImageCopyTexture* destination,
+                            const TexelCopyTextureInfo* destination,
                             const Extent3D* copySize,
                             const CopyTextureForBrowserOptions* options,
                             RenderPipelineBase* pipeline) {
@@ -603,13 +603,13 @@
 }
 
 MaybeError ValidateCopyForBrowserDestination(DeviceBase* device,
-                                             const ImageCopyTexture& destination,
+                                             const TexelCopyTextureInfo& destination,
                                              const Extent3D& copySize,
                                              const CopyTextureForBrowserOptions& options) {
     DAWN_TRY(device->ValidateObject(destination.texture));
     DAWN_TRY(destination.texture->ValidateCanUseInSubmitNow());
-    DAWN_TRY_CONTEXT(ValidateImageCopyTexture(device, destination, copySize),
-                     "validating the ImageCopyTexture for the destination");
+    DAWN_TRY_CONTEXT(ValidateTexelCopyTextureInfo(device, destination, copySize),
+                     "validating the TexelCopyTextureInfo for the destination");
     DAWN_TRY_CONTEXT(ValidateTextureCopyRange(device, destination, copySize),
                      "validating that the copy fits in the destination");
 
@@ -652,15 +652,15 @@
 }  // anonymous namespace
 
 MaybeError ValidateCopyTextureForBrowser(DeviceBase* device,
-                                         const ImageCopyTexture* source,
-                                         const ImageCopyTexture* destination,
+                                         const TexelCopyTextureInfo* source,
+                                         const TexelCopyTextureInfo* destination,
                                          const Extent3D* copySize,
                                          const CopyTextureForBrowserOptions* options) {
     // Validate source
     DAWN_TRY(device->ValidateObject(source->texture));
     DAWN_TRY(source->texture->ValidateCanUseInSubmitNow());
-    DAWN_TRY_CONTEXT(ValidateImageCopyTexture(device, *source, *copySize),
-                     "validating the ImageCopyTexture for the source");
+    DAWN_TRY_CONTEXT(ValidateTexelCopyTextureInfo(device, *source, *copySize),
+                     "validating the TexelCopyTextureInfo for the source");
     DAWN_TRY_CONTEXT(ValidateTextureCopyRange(device, *source, *copySize),
                      "validating that the copy fits in the source");
     DAWN_INVALID_IF(source->origin.z > 0, "Source has a non-zero z origin (%u).", source->origin.z);
@@ -693,7 +693,7 @@
 
 MaybeError ValidateCopyExternalTextureForBrowser(DeviceBase* device,
                                                  const ImageCopyExternalTexture* source,
-                                                 const ImageCopyTexture* destination,
+                                                 const TexelCopyTextureInfo* destination,
                                                  const Extent3D* copySize,
                                                  const CopyTextureForBrowserOptions* options) {
     // Validate source
@@ -734,7 +734,7 @@
 
 MaybeError DoCopyExternalTextureForBrowser(DeviceBase* device,
                                            const ImageCopyExternalTexture* source,
-                                           const ImageCopyTexture* destination,
+                                           const TexelCopyTextureInfo* destination,
                                            const Extent3D* copySize,
                                            const CopyTextureForBrowserOptions* options) {
     TextureInfo info;
@@ -749,8 +749,8 @@
 }
 
 MaybeError DoCopyTextureForBrowser(DeviceBase* device,
-                                   const ImageCopyTexture* source,
-                                   const ImageCopyTexture* destination,
+                                   const TexelCopyTextureInfo* source,
+                                   const TexelCopyTextureInfo* destination,
                                    const Extent3D* copySize,
                                    const CopyTextureForBrowserOptions* options) {
     TextureInfo info;
diff --git a/src/dawn/native/CopyTextureForBrowserHelper.h b/src/dawn/native/CopyTextureForBrowserHelper.h
index 7879342..69f24dd 100644
--- a/src/dawn/native/CopyTextureForBrowserHelper.h
+++ b/src/dawn/native/CopyTextureForBrowserHelper.h
@@ -34,30 +34,30 @@
 namespace dawn::native {
 class DeviceBase;
 struct Extent3D;
-struct ImageCopyTexture;
+struct TexelCopyTextureInfo;
 struct CopyTextureForBrowserOptions;
 
 MaybeError ValidateCopyTextureForBrowser(DeviceBase* device,
-                                         const ImageCopyTexture* source,
-                                         const ImageCopyTexture* destination,
+                                         const TexelCopyTextureInfo* source,
+                                         const TexelCopyTextureInfo* destination,
                                          const Extent3D* copySize,
                                          const CopyTextureForBrowserOptions* options);
 
 MaybeError ValidateCopyExternalTextureForBrowser(DeviceBase* device,
                                                  const ImageCopyExternalTexture* source,
-                                                 const ImageCopyTexture* destination,
+                                                 const TexelCopyTextureInfo* destination,
                                                  const Extent3D* copySize,
                                                  const CopyTextureForBrowserOptions* options);
 
 MaybeError DoCopyTextureForBrowser(DeviceBase* device,
-                                   const ImageCopyTexture* source,
-                                   const ImageCopyTexture* destination,
+                                   const TexelCopyTextureInfo* source,
+                                   const TexelCopyTextureInfo* destination,
                                    const Extent3D* copySize,
                                    const CopyTextureForBrowserOptions* options);
 
 MaybeError DoCopyExternalTextureForBrowser(DeviceBase* device,
                                            const ImageCopyExternalTexture* source,
-                                           const ImageCopyTexture* destination,
+                                           const TexelCopyTextureInfo* destination,
                                            const Extent3D* copySize,
                                            const CopyTextureForBrowserOptions* options);
 }  // namespace dawn::native
diff --git a/src/dawn/native/Device.cpp b/src/dawn/native/Device.cpp
index d6dcfbd..341ba1a 100644
--- a/src/dawn/native/Device.cpp
+++ b/src/dawn/native/Device.cpp
@@ -2343,7 +2343,7 @@
 }
 
 MaybeError DeviceBase::CopyFromStagingToTexture(BufferBase* source,
-                                                const TextureDataLayout& src,
+                                                const TexelCopyBufferLayout& src,
                                                 const TextureCopy& dst,
                                                 const Extent3D& copySizePixels) {
     if (dst.aspect == Aspect::Depth &&
diff --git a/src/dawn/native/Device.h b/src/dawn/native/Device.h
index 7217a93..b4887ae 100644
--- a/src/dawn/native/Device.h
+++ b/src/dawn/native/Device.h
@@ -295,7 +295,7 @@
                                        uint64_t destinationOffset,
                                        uint64_t size);
     MaybeError CopyFromStagingToTexture(BufferBase* source,
-                                        const TextureDataLayout& src,
+                                        const TexelCopyBufferLayout& src,
                                         const TextureCopy& dst,
                                         const Extent3D& copySizePixels);
 
@@ -526,7 +526,7 @@
                                                    uint64_t destinationOffset,
                                                    uint64_t size) = 0;
     virtual MaybeError CopyFromStagingToTextureImpl(const BufferBase* source,
-                                                    const TextureDataLayout& src,
+                                                    const TexelCopyBufferLayout& src,
                                                     const TextureCopy& dst,
                                                     const Extent3D& copySizePixels) = 0;
 
diff --git a/src/dawn/native/Queue.cpp b/src/dawn/native/Queue.cpp
index c99e358..cc7aca5 100644
--- a/src/dawn/native/Queue.cpp
+++ b/src/dawn/native/Queue.cpp
@@ -105,7 +105,7 @@
     uint32_t alignedBytesPerRow,
     uint32_t optimallyAlignedBytesPerRow,
     uint32_t alignedRowsPerImage,
-    const TextureDataLayout& dataLayout,
+    const TexelCopyBufferLayout& dataLayout,
     bool hasDepthOrStencil,
     const TexelBlockInfo& blockInfo,
     const Extent3D& writeSizePixel) {
@@ -389,10 +389,10 @@
     return buffer->UploadData(bufferOffset, data, size);
 }
 
-void QueueBase::APIWriteTexture(const ImageCopyTexture* destination,
+void QueueBase::APIWriteTexture(const TexelCopyTextureInfo* destination,
                                 const void* data,
                                 size_t dataSize,
-                                const TextureDataLayout* dataLayout,
+                                const TexelCopyBufferLayout* dataLayout,
                                 const Extent3D* writeSize) {
     [[maybe_unused]] bool hadError = GetDevice()->ConsumedError(
         WriteTextureInternal(destination, data, dataSize, *dataLayout, writeSize),
@@ -400,12 +400,12 @@
         writeSize);
 }
 
-MaybeError QueueBase::WriteTextureInternal(const ImageCopyTexture* destinationOrig,
+MaybeError QueueBase::WriteTextureInternal(const TexelCopyTextureInfo* destinationOrig,
                                            const void* data,
                                            size_t dataSize,
-                                           const TextureDataLayout& dataLayout,
+                                           const TexelCopyBufferLayout& dataLayout,
                                            const Extent3D* writeSize) {
-    ImageCopyTexture destination = destinationOrig->WithTrivialFrontendDefaults();
+    TexelCopyTextureInfo destination = destinationOrig->WithTrivialFrontendDefaults();
 
     DAWN_TRY(ValidateWriteTexture(&destination, dataSize, dataLayout, writeSize));
 
@@ -415,15 +415,15 @@
 
     const TexelBlockInfo& blockInfo =
         destination.texture->GetFormat().GetAspectInfo(destination.aspect).block;
-    TextureDataLayout layout = dataLayout;
-    ApplyDefaultTextureDataLayoutOptions(&layout, blockInfo, *writeSize);
+    TexelCopyBufferLayout layout = dataLayout;
+    ApplyDefaultTexelCopyBufferLayoutOptions(&layout, blockInfo, *writeSize);
     return WriteTextureImpl(destination, data, dataSize, layout, *writeSize);
 }
 
-MaybeError QueueBase::WriteTextureImpl(const ImageCopyTexture& destination,
+MaybeError QueueBase::WriteTextureImpl(const TexelCopyTextureInfo& destination,
                                        const void* data,
                                        size_t dataSize,
-                                       const TextureDataLayout& dataLayout,
+                                       const TexelCopyBufferLayout& dataLayout,
                                        const Extent3D& writeSizePixel) {
     const Format& format = destination.texture->GetFormat();
     const TexelBlockInfo& blockInfo = format.GetAspectInfo(destination.aspect).block;
@@ -445,7 +445,7 @@
                                       optimallyAlignedBytesPerRow, alignedRowsPerImage, dataLayout,
                                       format.HasDepthOrStencil(), blockInfo, writeSizePixel));
 
-    TextureDataLayout passDataLayout = dataLayout;
+    TexelCopyBufferLayout passDataLayout = dataLayout;
     passDataLayout.offset = uploadHandle.startOffset;
     passDataLayout.bytesPerRow = optimallyAlignedBytesPerRow;
     passDataLayout.rowsPerImage = alignedRowsPerImage;
@@ -462,8 +462,8 @@
                                             writeSizePixel);
 }
 
-void QueueBase::APICopyTextureForBrowser(const ImageCopyTexture* source,
-                                         const ImageCopyTexture* destination,
+void QueueBase::APICopyTextureForBrowser(const TexelCopyTextureInfo* source,
+                                         const TexelCopyTextureInfo* destination,
                                          const Extent3D* copySize,
                                          const CopyTextureForBrowserOptions* options) {
     [[maybe_unused]] bool hadError = GetDevice()->ConsumedError(
@@ -471,19 +471,19 @@
 }
 
 void QueueBase::APICopyExternalTextureForBrowser(const ImageCopyExternalTexture* source,
-                                                 const ImageCopyTexture* destination,
+                                                 const TexelCopyTextureInfo* destination,
                                                  const Extent3D* copySize,
                                                  const CopyTextureForBrowserOptions* options) {
     [[maybe_unused]] bool hadError = GetDevice()->ConsumedError(
         CopyExternalTextureForBrowserInternal(source, destination, copySize, options));
 }
 
-MaybeError QueueBase::CopyTextureForBrowserInternal(const ImageCopyTexture* sourceOrig,
-                                                    const ImageCopyTexture* destinationOrig,
+MaybeError QueueBase::CopyTextureForBrowserInternal(const TexelCopyTextureInfo* sourceOrig,
+                                                    const TexelCopyTextureInfo* destinationOrig,
                                                     const Extent3D* copySize,
                                                     const CopyTextureForBrowserOptions* options) {
-    ImageCopyTexture source = sourceOrig->WithTrivialFrontendDefaults();
-    ImageCopyTexture destination = destinationOrig->WithTrivialFrontendDefaults();
+    TexelCopyTextureInfo source = sourceOrig->WithTrivialFrontendDefaults();
+    TexelCopyTextureInfo destination = destinationOrig->WithTrivialFrontendDefaults();
 
     if (GetDevice()->IsValidationEnabled()) {
         DAWN_TRY_CONTEXT(
@@ -496,10 +496,10 @@
 
 MaybeError QueueBase::CopyExternalTextureForBrowserInternal(
     const ImageCopyExternalTexture* source,
-    const ImageCopyTexture* destinationOrig,
+    const TexelCopyTextureInfo* destinationOrig,
     const Extent3D* copySize,
     const CopyTextureForBrowserOptions* options) {
-    ImageCopyTexture destination = destinationOrig->WithTrivialFrontendDefaults();
+    TexelCopyTextureInfo destination = destinationOrig->WithTrivialFrontendDefaults();
 
     if (GetDevice()->IsValidationEnabled()) {
         DAWN_TRY_CONTEXT(ValidateCopyExternalTextureForBrowser(GetDevice(), source, &destination,
@@ -574,15 +574,15 @@
     return {};
 }
 
-MaybeError QueueBase::ValidateWriteTexture(const ImageCopyTexture* destination,
+MaybeError QueueBase::ValidateWriteTexture(const TexelCopyTextureInfo* destination,
                                            size_t dataSize,
-                                           const TextureDataLayout& dataLayout,
+                                           const TexelCopyBufferLayout& dataLayout,
                                            const Extent3D* writeSize) const {
     DAWN_TRY(GetDevice()->ValidateIsAlive());
     DAWN_TRY(GetDevice()->ValidateObject(this));
     DAWN_TRY(GetDevice()->ValidateObject(destination->texture));
 
-    DAWN_TRY(ValidateImageCopyTexture(GetDevice(), *destination, *writeSize));
+    DAWN_TRY(ValidateTexelCopyTextureInfo(GetDevice(), *destination, *writeSize));
 
     DAWN_INVALID_IF(dataLayout.offset > dataSize,
                     "Data offset (%u) is greater than the data size (%u).", dataLayout.offset,
diff --git a/src/dawn/native/Queue.h b/src/dawn/native/Queue.h
index 81568ef..bcc3777 100644
--- a/src/dawn/native/Queue.h
+++ b/src/dawn/native/Queue.h
@@ -75,17 +75,17 @@
     void APISubmit(uint32_t commandCount, CommandBufferBase* const* commands);
     Future APIOnSubmittedWorkDone(const WGPUQueueWorkDoneCallbackInfo& callbackInfo);
     void APIWriteBuffer(BufferBase* buffer, uint64_t bufferOffset, const void* data, size_t size);
-    void APIWriteTexture(const ImageCopyTexture* destination,
+    void APIWriteTexture(const TexelCopyTextureInfo* destination,
                          const void* data,
                          size_t dataSize,
-                         const TextureDataLayout* dataLayout,
+                         const TexelCopyBufferLayout* dataLayout,
                          const Extent3D* writeSize);
-    void APICopyTextureForBrowser(const ImageCopyTexture* source,
-                                  const ImageCopyTexture* destination,
+    void APICopyTextureForBrowser(const TexelCopyTextureInfo* source,
+                                  const TexelCopyTextureInfo* destination,
                                   const Extent3D* copySize,
                                   const CopyTextureForBrowserOptions* options);
     void APICopyExternalTextureForBrowser(const ImageCopyExternalTexture* source,
-                                          const ImageCopyTexture* destination,
+                                          const TexelCopyTextureInfo* destination,
                                           const Extent3D* copySize,
                                           const CopyTextureForBrowserOptions* options);
 
@@ -119,32 +119,32 @@
                                        uint64_t bufferOffset,
                                        const void* data,
                                        size_t size);
-    virtual MaybeError WriteTextureImpl(const ImageCopyTexture& destination,
+    virtual MaybeError WriteTextureImpl(const TexelCopyTextureInfo& destination,
                                         const void* data,
                                         size_t dataSize,
-                                        const TextureDataLayout& dataLayout,
+                                        const TexelCopyBufferLayout& dataLayout,
                                         const Extent3D& writeSize);
 
   private:
-    MaybeError WriteTextureInternal(const ImageCopyTexture* destination,
+    MaybeError WriteTextureInternal(const TexelCopyTextureInfo* destination,
                                     const void* data,
                                     size_t dataSize,
-                                    const TextureDataLayout& dataLayout,
+                                    const TexelCopyBufferLayout& dataLayout,
                                     const Extent3D* writeSize);
-    MaybeError CopyTextureForBrowserInternal(const ImageCopyTexture* source,
-                                             const ImageCopyTexture* destination,
+    MaybeError CopyTextureForBrowserInternal(const TexelCopyTextureInfo* source,
+                                             const TexelCopyTextureInfo* destination,
                                              const Extent3D* copySize,
                                              const CopyTextureForBrowserOptions* options);
     MaybeError CopyExternalTextureForBrowserInternal(const ImageCopyExternalTexture* source,
-                                                     const ImageCopyTexture* destination,
+                                                     const TexelCopyTextureInfo* destination,
                                                      const Extent3D* copySize,
                                                      const CopyTextureForBrowserOptions* options);
 
     MaybeError ValidateSubmit(uint32_t commandCount, CommandBufferBase* const* commands) const;
     MaybeError ValidateOnSubmittedWorkDone() const;
-    MaybeError ValidateWriteTexture(const ImageCopyTexture* destination,
+    MaybeError ValidateWriteTexture(const TexelCopyTextureInfo* destination,
                                     size_t dataSize,
-                                    const TextureDataLayout& dataLayout,
+                                    const TexelCopyBufferLayout& dataLayout,
                                     const Extent3D* writeSize) const;
 
     MaybeError SubmitInternal(uint32_t commandCount, CommandBufferBase* const* commands);
diff --git a/src/dawn/native/RenderPassWorkaroundsHelper.cpp b/src/dawn/native/RenderPassWorkaroundsHelper.cpp
index 612ebc8..d22fd42 100644
--- a/src/dawn/native/RenderPassWorkaroundsHelper.cpp
+++ b/src/dawn/native/RenderPassWorkaroundsHelper.cpp
@@ -60,22 +60,22 @@
 };
 
 void CopyTextureView(CommandEncoder* encoder, TextureViewBase* src, TextureViewBase* dst) {
-    ImageCopyTexture srcImageCopyTexture = {};
-    srcImageCopyTexture.texture = src->GetTexture();
-    srcImageCopyTexture.aspect = wgpu::TextureAspect::All;
-    srcImageCopyTexture.mipLevel = src->GetBaseMipLevel();
-    srcImageCopyTexture.origin = {0, 0, src->GetBaseArrayLayer()};
+    TexelCopyTextureInfo srcTexelCopyTextureInfo = {};
+    srcTexelCopyTextureInfo.texture = src->GetTexture();
+    srcTexelCopyTextureInfo.aspect = wgpu::TextureAspect::All;
+    srcTexelCopyTextureInfo.mipLevel = src->GetBaseMipLevel();
+    srcTexelCopyTextureInfo.origin = {0, 0, src->GetBaseArrayLayer()};
 
-    ImageCopyTexture dstImageCopyTexture = {};
-    dstImageCopyTexture.texture = dst->GetTexture();
-    dstImageCopyTexture.aspect = wgpu::TextureAspect::All;
-    dstImageCopyTexture.mipLevel = dst->GetBaseMipLevel();
-    dstImageCopyTexture.origin = {0, 0, dst->GetBaseArrayLayer()};
+    TexelCopyTextureInfo dstTexelCopyTextureInfo = {};
+    dstTexelCopyTextureInfo.texture = dst->GetTexture();
+    dstTexelCopyTextureInfo.aspect = wgpu::TextureAspect::All;
+    dstTexelCopyTextureInfo.mipLevel = dst->GetBaseMipLevel();
+    dstTexelCopyTextureInfo.origin = {0, 0, dst->GetBaseArrayLayer()};
 
     Extent3D extent3D = src->GetSingleSubresourceVirtualSize();
 
     auto internalUsageScope = encoder->MakeInternalUsageScope();
-    encoder->APICopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &extent3D);
+    encoder->APICopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &extent3D);
 }
 
 void ResolveWithRenderPass(CommandEncoder* encoder,
diff --git a/src/dawn/native/d3d11/DeviceD3D11.cpp b/src/dawn/native/d3d11/DeviceD3D11.cpp
index c8dec84..0a538c9 100644
--- a/src/dawn/native/d3d11/DeviceD3D11.cpp
+++ b/src/dawn/native/d3d11/DeviceD3D11.cpp
@@ -341,7 +341,7 @@
 }
 
 MaybeError Device::CopyFromStagingToTextureImpl(const BufferBase* source,
-                                                const TextureDataLayout& src,
+                                                const TexelCopyBufferLayout& src,
                                                 const TextureCopy& dst,
                                                 const Extent3D& copySizePixels) {
     return DAWN_UNIMPLEMENTED_ERROR("CopyFromStagingToTextureImpl");
diff --git a/src/dawn/native/d3d11/DeviceD3D11.h b/src/dawn/native/d3d11/DeviceD3D11.h
index e46a520..e627cd7 100644
--- a/src/dawn/native/d3d11/DeviceD3D11.h
+++ b/src/dawn/native/d3d11/DeviceD3D11.h
@@ -67,7 +67,7 @@
                                            uint64_t destinationOffset,
                                            uint64_t size) override;
     MaybeError CopyFromStagingToTextureImpl(const BufferBase* source,
-                                            const TextureDataLayout& src,
+                                            const TexelCopyBufferLayout& src,
                                             const TextureCopy& dst,
                                             const Extent3D& copySizePixels) override;
     uint32_t GetOptimalBytesPerRowAlignment() const override;
diff --git a/src/dawn/native/d3d11/QueueD3D11.cpp b/src/dawn/native/d3d11/QueueD3D11.cpp
index 0ac8457..e3efe02 100644
--- a/src/dawn/native/d3d11/QueueD3D11.cpp
+++ b/src/dawn/native/d3d11/QueueD3D11.cpp
@@ -246,10 +246,10 @@
     return ToBackend(buffer)->Write(&commandContext, bufferOffset, data, size);
 }
 
-MaybeError Queue::WriteTextureImpl(const ImageCopyTexture& destination,
+MaybeError Queue::WriteTextureImpl(const TexelCopyTextureInfo& destination,
                                    const void* data,
                                    size_t dataSize,
-                                   const TextureDataLayout& dataLayout,
+                                   const TexelCopyBufferLayout& dataLayout,
                                    const Extent3D& writeSizePixel) {
     if (writeSizePixel.width == 0 || writeSizePixel.height == 0 ||
         writeSizePixel.depthOrArrayLayers == 0) {
diff --git a/src/dawn/native/d3d11/QueueD3D11.h b/src/dawn/native/d3d11/QueueD3D11.h
index 3c8bb0e..3f2c8d1 100644
--- a/src/dawn/native/d3d11/QueueD3D11.h
+++ b/src/dawn/native/d3d11/QueueD3D11.h
@@ -70,10 +70,10 @@
                                uint64_t bufferOffset,
                                const void* data,
                                size_t size) override;
-    MaybeError WriteTextureImpl(const ImageCopyTexture& destination,
+    MaybeError WriteTextureImpl(const TexelCopyTextureInfo& destination,
                                 const void* data,
                                 size_t dataSize,
-                                const TextureDataLayout& dataLayout,
+                                const TexelCopyBufferLayout& dataLayout,
                                 const Extent3D& writeSizePixel) override;
 
     void DestroyImpl() override;
diff --git a/src/dawn/native/d3d12/DeviceD3D12.cpp b/src/dawn/native/d3d12/DeviceD3D12.cpp
index a218e0b..945c315 100644
--- a/src/dawn/native/d3d12/DeviceD3D12.cpp
+++ b/src/dawn/native/d3d12/DeviceD3D12.cpp
@@ -522,7 +522,7 @@
 }
 
 MaybeError Device::CopyFromStagingToTextureImpl(const BufferBase* source,
-                                                const TextureDataLayout& src,
+                                                const TexelCopyBufferLayout& src,
                                                 const TextureCopy& dst,
                                                 const Extent3D& copySizePixels) {
     CommandRecordingContext* commandContext =
diff --git a/src/dawn/native/d3d12/DeviceD3D12.h b/src/dawn/native/d3d12/DeviceD3D12.h
index 85e47f8..1df4aac 100644
--- a/src/dawn/native/d3d12/DeviceD3D12.h
+++ b/src/dawn/native/d3d12/DeviceD3D12.h
@@ -108,7 +108,7 @@
                                        uint64_t size);
 
     MaybeError CopyFromStagingToTextureImpl(const BufferBase* source,
-                                            const TextureDataLayout& src,
+                                            const TexelCopyBufferLayout& src,
                                             const TextureCopy& dst,
                                             const Extent3D& copySizePixels) override;
 
diff --git a/src/dawn/native/metal/DeviceMTL.h b/src/dawn/native/metal/DeviceMTL.h
index 6820b8b..dba3090 100644
--- a/src/dawn/native/metal/DeviceMTL.h
+++ b/src/dawn/native/metal/DeviceMTL.h
@@ -69,7 +69,7 @@
                                            uint64_t destinationOffset,
                                            uint64_t size) override;
     MaybeError CopyFromStagingToTextureImpl(const BufferBase* source,
-                                            const TextureDataLayout& dataLayout,
+                                            const TexelCopyBufferLayout& dataLayout,
                                             const TextureCopy& dst,
                                             const Extent3D& copySizePixels) override;
 
diff --git a/src/dawn/native/metal/DeviceMTL.mm b/src/dawn/native/metal/DeviceMTL.mm
index 2ca87ba..70b643b 100644
--- a/src/dawn/native/metal/DeviceMTL.mm
+++ b/src/dawn/native/metal/DeviceMTL.mm
@@ -346,7 +346,7 @@
 // replaceRegion function, because the function requires a non-private storage mode and Dawn
 // sets the private storage mode by default for all textures except IOSurfaces on macOS.
 MaybeError Device::CopyFromStagingToTextureImpl(const BufferBase* source,
-                                                const TextureDataLayout& dataLayout,
+                                                const TexelCopyBufferLayout& dataLayout,
                                                 const TextureCopy& dst,
                                                 const Extent3D& copySizePixels) {
     Texture* texture = ToBackend(dst.texture.Get());
diff --git a/src/dawn/native/null/DeviceNull.cpp b/src/dawn/native/null/DeviceNull.cpp
index c7ea6c6..9dd152c 100644
--- a/src/dawn/native/null/DeviceNull.cpp
+++ b/src/dawn/native/null/DeviceNull.cpp
@@ -296,7 +296,7 @@
 }
 
 MaybeError Device::CopyFromStagingToTextureImpl(const BufferBase* source,
-                                                const TextureDataLayout& src,
+                                                const TexelCopyBufferLayout& src,
                                                 const TextureCopy& dst,
                                                 const Extent3D& copySizePixels) {
     return {};
diff --git a/src/dawn/native/null/DeviceNull.h b/src/dawn/native/null/DeviceNull.h
index e1b4489..1098c05 100644
--- a/src/dawn/native/null/DeviceNull.h
+++ b/src/dawn/native/null/DeviceNull.h
@@ -126,7 +126,7 @@
                                            uint64_t destinationOffset,
                                            uint64_t size) override;
     MaybeError CopyFromStagingToTextureImpl(const BufferBase* source,
-                                            const TextureDataLayout& src,
+                                            const TexelCopyBufferLayout& src,
                                             const TextureCopy& dst,
                                             const Extent3D& copySizePixels) override;
 
diff --git a/src/dawn/native/opengl/CommandBufferGL.cpp b/src/dawn/native/opengl/CommandBufferGL.cpp
index 47c9a0e..b99934c 100644
--- a/src/dawn/native/opengl/CommandBufferGL.cpp
+++ b/src/dawn/native/opengl/CommandBufferGL.cpp
@@ -685,7 +685,7 @@
 
                 gl.BindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer->GetHandle());
 
-                TextureDataLayout dataLayout;
+                TexelCopyBufferLayout dataLayout;
                 dataLayout.offset = 0;
                 dataLayout.bytesPerRow = src.bytesPerRow;
                 dataLayout.rowsPerImage = src.rowsPerImage;
@@ -1416,7 +1416,7 @@
 void DoTexSubImage(const OpenGLFunctions& gl,
                    const TextureCopy& destination,
                    const void* data,
-                   const TextureDataLayout& dataLayout,
+                   const TexelCopyBufferLayout& dataLayout,
                    const Extent3D& copySize) {
     Texture* texture = ToBackend(destination.texture.Get());
 
diff --git a/src/dawn/native/opengl/CommandBufferGL.h b/src/dawn/native/opengl/CommandBufferGL.h
index 374c50e..d6af6cc 100644
--- a/src/dawn/native/opengl/CommandBufferGL.h
+++ b/src/dawn/native/opengl/CommandBufferGL.h
@@ -55,7 +55,7 @@
 void DoTexSubImage(const OpenGLFunctions& gl,
                    const TextureCopy& destination,
                    const void* data,
-                   const TextureDataLayout& dataLayout,
+                   const TexelCopyBufferLayout& dataLayout,
                    const Extent3D& copySize);
 }  // namespace dawn::native::opengl
 
diff --git a/src/dawn/native/opengl/DeviceGL.cpp b/src/dawn/native/opengl/DeviceGL.cpp
index 38d5908..dbd193a 100644
--- a/src/dawn/native/opengl/DeviceGL.cpp
+++ b/src/dawn/native/opengl/DeviceGL.cpp
@@ -438,7 +438,7 @@
 }
 
 MaybeError Device::CopyFromStagingToTextureImpl(const BufferBase* source,
-                                                const TextureDataLayout& src,
+                                                const TexelCopyBufferLayout& src,
                                                 const TextureCopy& dst,
                                                 const Extent3D& copySizePixels) {
     // If implemented, be sure to call SynchronizeTextureBeforeUse on the destination texture.
diff --git a/src/dawn/native/opengl/DeviceGL.h b/src/dawn/native/opengl/DeviceGL.h
index 653537b..0fb64d7 100644
--- a/src/dawn/native/opengl/DeviceGL.h
+++ b/src/dawn/native/opengl/DeviceGL.h
@@ -93,7 +93,7 @@
                                            uint64_t size) override;
 
     MaybeError CopyFromStagingToTextureImpl(const BufferBase* source,
-                                            const TextureDataLayout& src,
+                                            const TexelCopyBufferLayout& src,
                                             const TextureCopy& dst,
                                             const Extent3D& copySizePixels) override;
 
diff --git a/src/dawn/native/opengl/QueueGL.cpp b/src/dawn/native/opengl/QueueGL.cpp
index 06c6a0f..596addf 100644
--- a/src/dawn/native/opengl/QueueGL.cpp
+++ b/src/dawn/native/opengl/QueueGL.cpp
@@ -83,10 +83,10 @@
     return {};
 }
 
-MaybeError Queue::WriteTextureImpl(const ImageCopyTexture& destination,
+MaybeError Queue::WriteTextureImpl(const TexelCopyTextureInfo& destination,
                                    const void* data,
                                    size_t dataSize,
-                                   const TextureDataLayout& dataLayout,
+                                   const TexelCopyBufferLayout& dataLayout,
                                    const Extent3D& writeSizePixel) {
     TextureCopy textureCopy;
     textureCopy.texture = destination.texture;
@@ -111,7 +111,7 @@
         Ref<TextureBase> dataTexture;
         DAWN_TRY_ASSIGN(dataTexture, device->CreateTexture(&dataTextureDesc));
         {
-            ImageCopyTexture destinationDataTexture;
+            TexelCopyTextureInfo destinationDataTexture;
             destinationDataTexture.texture = dataTexture.Get();
             destinationDataTexture.aspect = wgpu::TextureAspect::All;
             // The size of R8Uint texture equals to writeSizePixel and only has 1 mip level.
diff --git a/src/dawn/native/opengl/QueueGL.h b/src/dawn/native/opengl/QueueGL.h
index f57080c..1f93140 100644
--- a/src/dawn/native/opengl/QueueGL.h
+++ b/src/dawn/native/opengl/QueueGL.h
@@ -59,10 +59,10 @@
                                uint64_t bufferOffset,
                                const void* data,
                                size_t size) override;
-    MaybeError WriteTextureImpl(const ImageCopyTexture& destination,
+    MaybeError WriteTextureImpl(const TexelCopyTextureInfo& destination,
                                 const void* data,
                                 size_t dataSize,
-                                const TextureDataLayout& dataLayout,
+                                const TexelCopyBufferLayout& dataLayout,
                                 const Extent3D& writeSizePixel) override;
 
     ResultOrError<bool> WaitForQueueSerial(ExecutionSerial serial, Nanoseconds timeout) override;
diff --git a/src/dawn/native/opengl/TextureGL.cpp b/src/dawn/native/opengl/TextureGL.cpp
index 56e921f..bb95d98 100644
--- a/src/dawn/native/opengl/TextureGL.cpp
+++ b/src/dawn/native/opengl/TextureGL.cpp
@@ -537,7 +537,7 @@
             textureCopy.origin = {};
             textureCopy.aspect = Aspect::Color;
 
-            TextureDataLayout dataLayout;
+            TexelCopyBufferLayout dataLayout;
             dataLayout.offset = 0;
             dataLayout.bytesPerRow = bytesPerRow;
             dataLayout.rowsPerImage = largestMipSize.height;
diff --git a/src/dawn/native/vulkan/DeviceVk.cpp b/src/dawn/native/vulkan/DeviceVk.cpp
index 805cf6d..e072ab6 100644
--- a/src/dawn/native/vulkan/DeviceVk.cpp
+++ b/src/dawn/native/vulkan/DeviceVk.cpp
@@ -659,7 +659,7 @@
 }
 
 MaybeError Device::CopyFromStagingToTextureImpl(const BufferBase* source,
-                                                const TextureDataLayout& src,
+                                                const TexelCopyBufferLayout& src,
                                                 const TextureCopy& dst,
                                                 const Extent3D& copySizePixels) {
     // There is no need of a barrier to make host writes available and visible to the copy
diff --git a/src/dawn/native/vulkan/DeviceVk.h b/src/dawn/native/vulkan/DeviceVk.h
index 47cf0c5..9ecfbf0 100644
--- a/src/dawn/native/vulkan/DeviceVk.h
+++ b/src/dawn/native/vulkan/DeviceVk.h
@@ -104,7 +104,7 @@
                                            uint64_t destinationOffset,
                                            uint64_t size) override;
     MaybeError CopyFromStagingToTextureImpl(const BufferBase* source,
-                                            const TextureDataLayout& src,
+                                            const TexelCopyBufferLayout& src,
                                             const TextureCopy& dst,
                                             const Extent3D& copySizePixels) override;
 
diff --git a/src/dawn/native/vulkan/TextureVk.cpp b/src/dawn/native/vulkan/TextureVk.cpp
index f09f50b..d685620 100644
--- a/src/dawn/native/vulkan/TextureVk.cpp
+++ b/src/dawn/native/vulkan/TextureVk.cpp
@@ -1204,7 +1204,7 @@
                     continue;
                 }
 
-                TextureDataLayout dataLayout;
+                TexelCopyBufferLayout dataLayout;
                 dataLayout.offset = uploadHandle.startOffset;
                 dataLayout.rowsPerImage = copySize.height / blockInfo.height;
                 dataLayout.bytesPerRow = bytesPerRow;
diff --git a/src/dawn/native/vulkan/UtilsVulkan.cpp b/src/dawn/native/vulkan/UtilsVulkan.cpp
index 95f6539..4634aa5 100644
--- a/src/dawn/native/vulkan/UtilsVulkan.cpp
+++ b/src/dawn/native/vulkan/UtilsVulkan.cpp
@@ -162,14 +162,14 @@
 VkBufferImageCopy ComputeBufferImageCopyRegion(const BufferCopy& bufferCopy,
                                                const TextureCopy& textureCopy,
                                                const Extent3D& copySize) {
-    TextureDataLayout passDataLayout;
+    TexelCopyBufferLayout passDataLayout;
     passDataLayout.offset = bufferCopy.offset;
     passDataLayout.rowsPerImage = bufferCopy.rowsPerImage;
     passDataLayout.bytesPerRow = bufferCopy.bytesPerRow;
     return ComputeBufferImageCopyRegion(passDataLayout, textureCopy, copySize);
 }
 
-VkBufferImageCopy ComputeBufferImageCopyRegion(const TextureDataLayout& dataLayout,
+VkBufferImageCopy ComputeBufferImageCopyRegion(const TexelCopyBufferLayout& dataLayout,
                                                const TextureCopy& textureCopy,
                                                const Extent3D& copySize) {
     const Texture* texture = ToBackend(textureCopy.texture.Get());
diff --git a/src/dawn/native/vulkan/UtilsVulkan.h b/src/dawn/native/vulkan/UtilsVulkan.h
index aeee0e3..31bfac2 100644
--- a/src/dawn/native/vulkan/UtilsVulkan.h
+++ b/src/dawn/native/vulkan/UtilsVulkan.h
@@ -123,7 +123,7 @@
 VkBufferImageCopy ComputeBufferImageCopyRegion(const BufferCopy& bufferCopy,
                                                const TextureCopy& textureCopy,
                                                const Extent3D& copySize);
-VkBufferImageCopy ComputeBufferImageCopyRegion(const TextureDataLayout& dataLayout,
+VkBufferImageCopy ComputeBufferImageCopyRegion(const TexelCopyBufferLayout& dataLayout,
                                                const TextureCopy& textureCopy,
                                                const Extent3D& copySize);
 
diff --git a/src/dawn/native/webgpu_absl_format.cpp b/src/dawn/native/webgpu_absl_format.cpp
index 2984617..2e04715 100644
--- a/src/dawn/native/webgpu_absl_format.cpp
+++ b/src/dawn/native/webgpu_absl_format.cpp
@@ -231,7 +231,7 @@
 }
 
 absl::FormatConvertResult<absl::FormatConversionCharSet::kString> AbslFormatConvert(
-    const ImageCopyTexture* value,
+    const TexelCopyTextureInfo* value,
     const absl::FormatConversionSpec& spec,
     absl::FormatSink* s) {
     if (value == nullptr) {
@@ -239,20 +239,20 @@
         return {true};
     }
     s->Append(
-        absl::StrFormat("[ImageCopyTexture texture: %s, mipLevel: %u, origin: %s, aspect: %s]",
+        absl::StrFormat("[TexelCopyTextureInfo texture: %s, mipLevel: %u, origin: %s, aspect: %s]",
                         value->texture, value->mipLevel, &value->origin, value->aspect));
     return {true};
 }
 
 absl::FormatConvertResult<absl::FormatConversionCharSet::kString> AbslFormatConvert(
-    const TextureDataLayout* value,
+    const TexelCopyBufferLayout* value,
     const absl::FormatConversionSpec& spec,
     absl::FormatSink* s) {
     if (value == nullptr) {
         s->Append("[null]");
         return {true};
     }
-    s->Append(absl::StrFormat("[TextureDataLayout offset:%u, bytesPerRow:%u, rowsPerImage:%u]",
+    s->Append(absl::StrFormat("[TexelCopyBufferLayout offset:%u, bytesPerRow:%u, rowsPerImage:%u]",
                               value->offset, value->bytesPerRow, value->rowsPerImage));
     return {true};
 }
diff --git a/src/dawn/native/webgpu_absl_format.h b/src/dawn/native/webgpu_absl_format.h
index 1c27ab8..b8e19e1 100644
--- a/src/dawn/native/webgpu_absl_format.h
+++ b/src/dawn/native/webgpu_absl_format.h
@@ -144,15 +144,15 @@
     const absl::FormatConversionSpec& spec,
     absl::FormatSink* s);
 
-struct ImageCopyTexture;
+struct TexelCopyTextureInfo;
 absl::FormatConvertResult<absl::FormatConversionCharSet::kString> AbslFormatConvert(
-    const ImageCopyTexture* value,
+    const TexelCopyTextureInfo* value,
     const absl::FormatConversionSpec& spec,
     absl::FormatSink* s);
 
-struct TextureDataLayout;
+struct TexelCopyBufferLayout;
 absl::FormatConvertResult<absl::FormatConversionCharSet::kString> AbslFormatConvert(
-    const TextureDataLayout* value,
+    const TexelCopyBufferLayout* value,
     const absl::FormatConversionSpec& spec,
     absl::FormatSink* s);
 
diff --git a/src/dawn/node/binding/Converter.cpp b/src/dawn/node/binding/Converter.cpp
index a4c72ed..c8b5c68 100644
--- a/src/dawn/node/binding/Converter.cpp
+++ b/src/dawn/node/binding/Converter.cpp
@@ -147,13 +147,14 @@
     return Throw("invalid value for GPUTextureAspect");
 }
 
-bool Converter::Convert(wgpu::ImageCopyTexture& out, const interop::GPUTexelCopyTextureInfo& in) {
+bool Converter::Convert(wgpu::TexelCopyTextureInfo& out,
+                        const interop::GPUTexelCopyTextureInfo& in) {
     out = {};
     return Convert(out.texture, in.texture) && Convert(out.mipLevel, in.mipLevel) &&
            Convert(out.origin, in.origin) && Convert(out.aspect, in.aspect);
 }
 
-bool Converter::Convert(wgpu::ImageCopyBuffer& out, const interop::GPUTexelCopyBufferInfo& in) {
+bool Converter::Convert(wgpu::TexelCopyBufferInfo& out, const interop::GPUTexelCopyBufferInfo& in) {
     out = {};
     out.buffer = *in.buffer.As<GPUBuffer>();
     return Convert(out.layout.offset, in.offset) &&
@@ -183,7 +184,8 @@
     return Throw("invalid value for BufferSource");
 }
 
-bool Converter::Convert(wgpu::TextureDataLayout& out, const interop::GPUTexelCopyBufferLayout& in) {
+bool Converter::Convert(wgpu::TexelCopyBufferLayout& out,
+                        const interop::GPUTexelCopyBufferLayout& in) {
     out = {};
     return Convert(out.bytesPerRow, in.bytesPerRow) && Convert(out.offset, in.offset) &&
            Convert(out.rowsPerImage, in.rowsPerImage);
diff --git a/src/dawn/node/binding/Converter.h b/src/dawn/node/binding/Converter.h
index aa5aa80..7b54871 100644
--- a/src/dawn/node/binding/Converter.h
+++ b/src/dawn/node/binding/Converter.h
@@ -129,15 +129,15 @@
 
     [[nodiscard]] bool Convert(wgpu::TextureAspect& out, const interop::GPUTextureAspect& in);
 
-    [[nodiscard]] bool Convert(wgpu::ImageCopyTexture& out,
+    [[nodiscard]] bool Convert(wgpu::TexelCopyTextureInfo& out,
                                const interop::GPUTexelCopyTextureInfo& in);
 
-    [[nodiscard]] bool Convert(wgpu::ImageCopyBuffer& out,
+    [[nodiscard]] bool Convert(wgpu::TexelCopyBufferInfo& out,
                                const interop::GPUTexelCopyBufferInfo& in);
 
     [[nodiscard]] bool Convert(BufferSource& out, interop::BufferSource in);
 
-    [[nodiscard]] bool Convert(wgpu::TextureDataLayout& out,
+    [[nodiscard]] bool Convert(wgpu::TexelCopyBufferLayout& out,
                                const interop::GPUTexelCopyBufferLayout& in);
 
     [[nodiscard]] bool Convert(wgpu::TextureFormat& out, const interop::GPUTextureFormat& in);
diff --git a/src/dawn/node/binding/GPUCommandEncoder.cpp b/src/dawn/node/binding/GPUCommandEncoder.cpp
index de1dd04..167dee3 100644
--- a/src/dawn/node/binding/GPUCommandEncoder.cpp
+++ b/src/dawn/node/binding/GPUCommandEncoder.cpp
@@ -124,8 +124,8 @@
                                             interop::GPUExtent3D copySize) {
     Converter conv(env);
 
-    wgpu::ImageCopyBuffer src{};
-    wgpu::ImageCopyTexture dst{};
+    wgpu::TexelCopyBufferInfo src{};
+    wgpu::TexelCopyTextureInfo dst{};
     wgpu::Extent3D size{};
     if (!conv(src, source) ||       //
         !conv(dst, destination) ||  //
@@ -142,8 +142,8 @@
                                             interop::GPUExtent3D copySize) {
     Converter conv(env);
 
-    wgpu::ImageCopyTexture src{};
-    wgpu::ImageCopyBuffer dst{};
+    wgpu::TexelCopyTextureInfo src{};
+    wgpu::TexelCopyBufferInfo dst{};
     wgpu::Extent3D size{};
     if (!conv(src, source) ||       //
         !conv(dst, destination) ||  //
@@ -160,8 +160,8 @@
                                              interop::GPUExtent3D copySize) {
     Converter conv(env);
 
-    wgpu::ImageCopyTexture src{};
-    wgpu::ImageCopyTexture dst{};
+    wgpu::TexelCopyTextureInfo src{};
+    wgpu::TexelCopyTextureInfo dst{};
     wgpu::Extent3D size{};
     if (!conv(src, source) ||       //
         !conv(dst, destination) ||  //
diff --git a/src/dawn/node/binding/GPUQueue.cpp b/src/dawn/node/binding/GPUQueue.cpp
index 8638a68..4cd3e92 100644
--- a/src/dawn/node/binding/GPUQueue.cpp
+++ b/src/dawn/node/binding/GPUQueue.cpp
@@ -131,9 +131,9 @@
                             interop::AllowSharedBufferSource data,
                             interop::GPUTexelCopyBufferLayout dataLayout,
                             interop::GPUExtent3D size) {
-    wgpu::ImageCopyTexture dst{};
+    wgpu::TexelCopyTextureInfo dst{};
     Converter::BufferSource src{};
-    wgpu::TextureDataLayout layout{};
+    wgpu::TexelCopyBufferLayout layout{};
     wgpu::Extent3D sz{};
     Converter conv(env);
     if (!conv(dst, destination) ||    //
diff --git a/src/dawn/tests/DawnTest.cpp b/src/dawn/tests/DawnTest.cpp
index ebe079f..c7d3817 100644
--- a/src/dawn/tests/DawnTest.cpp
+++ b/src/dawn/tests/DawnTest.cpp
@@ -1350,13 +1350,13 @@
 
     // We need to enqueue the copy immediately because by the time we resolve the expectation,
     // the texture might have been modified.
-    wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(texture, level, origin, aspect);
-    wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(readback.buffer, readback.offset, bytesPerRow, rowsPerImage);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, level, origin, aspect);
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
+        readback.buffer, readback.offset, bytesPerRow, rowsPerImage);
 
     wgpu::CommandEncoder encoder = targetDevice.CreateCommandEncoder();
-    encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &extent);
+    encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &extent);
 
     wgpu::CommandBuffer commands = encoder.Finish();
     targetDevice.GetQueue().Submit(1, &commands);
@@ -1561,14 +1561,15 @@
         depthDataTexture = device.CreateTexture(&depthDataDesc);
 
         // Upload the depth data.
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(depthDataTexture, 0, {0, 0, 0});
-        wgpu::TextureDataLayout textureDataLayout =
-            utils::CreateTextureDataLayout(0, sizeof(float) * width);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(depthDataTexture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+            utils::CreateTexelCopyBufferLayout(0, sizeof(float) * width);
         wgpu::Extent3D copyExtent = {width, height, 1};
 
-        queue.WriteTexture(&imageCopyTexture, expectedDepth.data(),
-                           sizeof(float) * expectedDepth.size(), &textureDataLayout, &copyExtent);
+        queue.WriteTexture(&texelCopyTextureInfo, expectedDepth.data(),
+                           sizeof(float) * expectedDepth.size(), &texelCopyBufferLayout,
+                           &copyExtent);
     }
 
     // Pipeline for a full screen quad.
diff --git a/src/dawn/tests/end2end/BindGroupTests.cpp b/src/dawn/tests/end2end/BindGroupTests.cpp
index 2087e15..e1a0cf3 100644
--- a/src/dawn/tests/end2end/BindGroupTests.cpp
+++ b/src/dawn/tests/end2end/BindGroupTests.cpp
@@ -344,11 +344,12 @@
                              {{0, buffer, 0, sizeof(transform)}, {1, sampler}, {2, textureView}});
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(stagingBuffer, 0, widthInBytes);
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, widthInBytes);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {width, height, 1};
-    encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+    encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
     wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
     pass.SetPipeline(pipeline);
     pass.SetBindGroup(0, bindGroup);
diff --git a/src/dawn/tests/end2end/BufferZeroInitTests.cpp b/src/dawn/tests/end2end/BufferZeroInitTests.cpp
index eb85bb0..7fa1102 100644
--- a/src/dawn/tests/end2end/BufferZeroInitTests.cpp
+++ b/src/dawn/tests/end2end/BufferZeroInitTests.cpp
@@ -121,19 +121,19 @@
         wgpu::Texture texture =
             CreateAndInitializeTexture(spec.textureSize, kTextureFormat, kClearColor);
 
-        const wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+        const wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
 
         const uint64_t bufferSize = spec.bufferOffset + spec.extraBytes +
                                     utils::RequiredBytesInCopy(spec.bytesPerRow, spec.rowsPerImage,
                                                                spec.textureSize, kTextureFormat);
         wgpu::Buffer buffer =
             CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst);
-        const wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(
+        const wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
             buffer, spec.bufferOffset, spec.bytesPerRow, spec.rowsPerImage);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &spec.textureSize);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &spec.textureSize);
         wgpu::CommandBuffer commandBuffer = encoder.Finish();
         EXPECT_LAZY_CLEAR(spec.lazyClearCount, queue.Submit(1, &commandBuffer));
 
@@ -865,8 +865,8 @@
     constexpr wgpu::TextureFormat kTextureFormat = wgpu::TextureFormat::R32Uint;
 
     wgpu::Texture texture = CreateAndInitializeTexture(kTextureSize, kTextureFormat);
-    const wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+    const wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
 
     const uint32_t rowsPerImage = kTextureSize.height;
     const uint32_t requiredBufferSizeForCopy = utils::RequiredBytesInCopy(
@@ -880,11 +880,11 @@
         constexpr uint64_t kOffset = 0;
         const uint32_t totalBufferSize = requiredBufferSizeForCopy + kOffset;
         wgpu::Buffer buffer = CreateBuffer(totalBufferSize, kBufferUsage);
-        const wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(
+        const wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
             buffer, kOffset, kTextureBytesPerRowAlignment, kTextureSize.height);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &kTextureSize);
+        encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &kTextureSize);
         wgpu::CommandBuffer commandBuffer = encoder.Finish();
         EXPECT_LAZY_CLEAR(1u, queue.Submit(1, &commandBuffer));
 
@@ -898,11 +898,11 @@
         constexpr uint64_t kOffset = 8u;
         const uint32_t totalBufferSize = requiredBufferSizeForCopy + kOffset;
         wgpu::Buffer buffer = CreateBuffer(totalBufferSize, kBufferUsage);
-        const wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(
+        const wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
             buffer, kOffset, kTextureBytesPerRowAlignment, kTextureSize.height);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &kTextureSize);
+        encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &kTextureSize);
         wgpu::CommandBuffer commandBuffer = encoder.Finish();
         EXPECT_LAZY_CLEAR(1u, queue.Submit(1, &commandBuffer));
 
@@ -1172,11 +1172,11 @@
         initTextureDesc.size = {vertexFormatSize + 4, 1, 1};
         initTextureDesc.format = wgpu::TextureFormat::R8Unorm;
         initTextureDesc.usage = wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst;
-        wgpu::ImageCopyTexture zeroTextureSrc =
-            utils::CreateImageCopyTexture(device.CreateTexture(&initTextureDesc), 0, {0, 0, 0});
+        wgpu::TexelCopyTextureInfo zeroTextureSrc =
+            utils::CreateTexelCopyTextureInfo(device.CreateTexture(&initTextureDesc), 0, {0, 0, 0});
         {
-            wgpu::TextureDataLayout layout =
-                utils::CreateTextureDataLayout(0, wgpu::kCopyStrideUndefined);
+            wgpu::TexelCopyBufferLayout layout =
+                utils::CreateTexelCopyBufferLayout(0, wgpu::kCopyStrideUndefined);
             std::vector<uint8_t> data(initTextureDesc.size.width);
             queue.WriteTexture(&zeroTextureSrc, data.data(), data.size(), &layout,
                                &initTextureDesc.size);
@@ -1199,8 +1199,8 @@
                 // it does not require 4-byte alignment.
                 {
                     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-                    wgpu::ImageCopyBuffer dst =
-                        utils::CreateImageCopyBuffer(vertexBuffer, 0, wgpu::kCopyStrideUndefined);
+                    wgpu::TexelCopyBufferInfo dst = utils::CreateTexelCopyBufferInfo(
+                        vertexBuffer, 0, wgpu::kCopyStrideUndefined);
                     wgpu::Extent3D extent = {vertexBufferSize, 1, 1};
                     encoder.CopyTextureToBuffer(&zeroTextureSrc, &dst, &extent);
 
diff --git a/src/dawn/tests/end2end/CompressedTextureFormatTests.cpp b/src/dawn/tests/end2end/CompressedTextureFormatTests.cpp
index b54c9bc..f0d1bbd 100644
--- a/src/dawn/tests/end2end/CompressedTextureFormatTests.cpp
+++ b/src/dawn/tests/end2end/CompressedTextureFormatTests.cpp
@@ -134,15 +134,16 @@
         // Copy texture data from a staging buffer to the destination texture.
         wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(device, data.data(), data.size(),
                                                                  wgpu::BufferUsage::CopySrc);
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(stagingBuffer, copyConfig.bufferOffset,
-                                         copyConfig.bytesPerRowAlignment, copyConfig.rowsPerImage);
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
+            stagingBuffer, copyConfig.bufferOffset, copyConfig.bytesPerRowAlignment,
+            copyConfig.rowsPerImage);
 
-        wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
             compressedTexture, copyConfig.viewMipmapLevel, copyConfig.copyOrigin3D);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copyConfig.copyExtent3D);
+        encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo,
+                                    &copyConfig.copyExtent3D);
         wgpu::CommandBuffer copy = encoder.Finish();
         queue.Submit(1, &copy);
     }
@@ -347,11 +348,11 @@
                                     wgpu::Texture dstTexture,
                                     CopyConfig srcConfig,
                                     CopyConfig dstConfig) {
-        wgpu::ImageCopyTexture imageCopyTextureSrc = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfoSrc = utils::CreateTexelCopyTextureInfo(
             srcTexture, srcConfig.viewMipmapLevel, srcConfig.copyOrigin3D);
-        wgpu::ImageCopyTexture imageCopyTextureDst = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfoDst = utils::CreateTexelCopyTextureInfo(
             dstTexture, dstConfig.viewMipmapLevel, dstConfig.copyOrigin3D);
-        encoder.CopyTextureToTexture(&imageCopyTextureSrc, &imageCopyTextureDst,
+        encoder.CopyTextureToTexture(&texelCopyTextureInfoSrc, &texelCopyTextureInfoDst,
                                      &dstConfig.copyExtent3D);
     }
 
@@ -935,7 +936,7 @@
     // Create textureSrc as the source texture and initialize it with pre-prepared compressed
     // data.
     wgpu::Texture textureSrc = CreateTextureWithCompressedData(srcConfig);
-    wgpu::ImageCopyTexture imageCopyTextureSrc = utils::CreateImageCopyTexture(
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfoSrc = utils::CreateTexelCopyTextureInfo(
         textureSrc, srcConfig.viewMipmapLevel, srcConfig.copyOrigin3D);
 
     // Create textureDst and copy from the content in textureSrc into it.
@@ -1324,12 +1325,14 @@
     bufferDescriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
     wgpu::Buffer buffer = device.CreateBuffer(&bufferDescriptor);
 
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
-    wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(buffer, 0, 256);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(buffer, 0, 256);
     wgpu::Extent3D copyExtent = {4, 4, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copyExtent);
+    encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copyExtent);
     wgpu::CommandBuffer commands = encoder.Finish();
     queue.Submit(1, &commands);
 }
@@ -1357,13 +1360,13 @@
 
         std::vector<uint8_t> data = UploadData(copyConfig);
 
-        wgpu::TextureDataLayout textureDataLayout = utils::CreateTextureDataLayout(
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout = utils::CreateTexelCopyBufferLayout(
             copyConfig.bufferOffset, copyConfig.bytesPerRowAlignment, copyConfig.rowsPerImage);
 
-        wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
             compressedTexture, copyConfig.viewMipmapLevel, copyConfig.copyOrigin3D);
 
-        queue.WriteTexture(&imageCopyTexture, data.data(), data.size(), &textureDataLayout,
+        queue.WriteTexture(&texelCopyTextureInfo, data.data(), data.size(), &texelCopyBufferLayout,
                            &copyConfig.copyExtent3D);
     }
 
diff --git a/src/dawn/tests/end2end/CopyExternalTextureForBrowserTests.cpp b/src/dawn/tests/end2end/CopyExternalTextureForBrowserTests.cpp
index d7db04c..1e3abe1 100644
--- a/src/dawn/tests/end2end/CopyExternalTextureForBrowserTests.cpp
+++ b/src/dawn/tests/end2end/CopyExternalTextureForBrowserTests.cpp
@@ -113,12 +113,12 @@
         //  {0.2126, 0.4172, 1.0, utils::RGBA8::kRed, 1.0f},
         //  {0.7152, 0.1402, 0.0175, utils::RGBA8::kGreen, 0.0f},
         //  {0.0722, 1.0, 0.4937, utils::RGBA8::kBlue, 0.0f},
-        wgpu::ImageCopyTexture plane0 = {};
+        wgpu::TexelCopyTextureInfo plane0 = {};
         plane0.texture = externalTexturePlane0;
         std::array<uint8_t, 16> yPlaneData = {0,   0,   54, 54, 0,   0,   54, 54,
                                               182, 182, 18, 18, 182, 182, 18, 18};
 
-        wgpu::TextureDataLayout externalTexturePlane0DataLayout = {};
+        wgpu::TexelCopyBufferLayout externalTexturePlane0DataLayout = {};
         externalTexturePlane0DataLayout.bytesPerRow = 4;
 
         this->queue.WriteTexture(&plane0, yPlaneData.data(),
@@ -135,7 +135,7 @@
         wgpu::Texture externalTexturePlane1 =
             this->device.CreateTexture(&externalTexturePlane1Desc);
 
-        wgpu::ImageCopyTexture plane1 = {};
+        wgpu::TexelCopyTextureInfo plane1 = {};
         // (Off-topic) spot-test for defaulting of .aspect.
         plane1.aspect = wgpu::TextureAspect::Undefined;
         plane1.texture = externalTexturePlane1;
@@ -143,7 +143,7 @@
             128, 128, 106, 255, 36, 4, 255, 126,
         };
 
-        wgpu::TextureDataLayout externalTexturePlane1DataLayout = {};
+        wgpu::TexelCopyBufferLayout externalTexturePlane1DataLayout = {};
         externalTexturePlane1DataLayout.bytesPerRow = 4;
 
         this->queue.WriteTexture(&plane1, uvPlaneData.data(),
@@ -284,11 +284,11 @@
                             wgpu::TextureFormat::RGBA8Unorm,
                             wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc |
                                 wgpu::TextureUsage::CopyDst);
-        wgpu::ImageCopyTexture dstImageCopyTexture =
-            utils::CreateImageCopyTexture(dstTexture, 0, dstOrigin, dstAspect);
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dstTexture, 0, dstOrigin, dstAspect);
 
         this->queue.CopyExternalTextureForBrowser(&srcImageCopyExternalTexture,
-                                                  &dstImageCopyTexture, &copySize, &options);
+                                                  &dstTexelCopyTextureInfo, &copySize, &options);
 
         std::vector<utils::RGBA8> expected = this->GetExpectedData(
             options.flipY, srcImageCopyExternalTexture.origin, copySize, naturalSize);
diff --git a/src/dawn/tests/end2end/CopyTests.cpp b/src/dawn/tests/end2end/CopyTests.cpp
index 9b4bb10..537cf49 100644
--- a/src/dawn/tests/end2end/CopyTests.cpp
+++ b/src/dawn/tests/end2end/CopyTests.cpp
@@ -371,12 +371,12 @@
         const std::vector<uint8_t> textureArrayData =
             GetExpectedTextureData(textureSpec.format, copyLayout);
         {
-            wgpu::ImageCopyTexture imageCopyTexture =
-                utils::CreateImageCopyTexture(texture, textureSpec.copyLevel, {0, 0, 0});
-            wgpu::TextureDataLayout textureDataLayout =
-                utils::CreateTextureDataLayout(0, copyLayout.bytesPerRow, copyLayout.rowsPerImage);
-            queue.WriteTexture(&imageCopyTexture, textureArrayData.data(), copyLayout.byteLength,
-                               &textureDataLayout, &copyLayout.mipSize);
+            wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+                utils::CreateTexelCopyTextureInfo(texture, textureSpec.copyLevel, {0, 0, 0});
+            wgpu::TexelCopyBufferLayout texelCopyBufferLayout = utils::CreateTexelCopyBufferLayout(
+                0, copyLayout.bytesPerRow, copyLayout.rowsPerImage);
+            queue.WriteTexture(&texelCopyTextureInfo, textureArrayData.data(),
+                               copyLayout.byteLength, &texelCopyBufferLayout, &copyLayout.mipSize);
         }
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -396,11 +396,11 @@
         wgpu::Buffer buffer = device.CreateBuffer(&bufferDesc);
 
         {
-            wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+            wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
                 texture, textureSpec.copyLevel, textureSpec.copyOrigin);
-            wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(
+            wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
                 buffer, bufferSpec.offset, bufferSpec.bytesPerRow, bufferSpec.rowsPerImage);
-            encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copySize);
+            encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copySize);
         }
 
         wgpu::CommandBuffer commands = encoder.Finish();
@@ -523,11 +523,11 @@
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
 
-        wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
             buffer, bufferSpec.offset, bufferSpec.bytesPerRow, bufferSpec.rowsPerImage);
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, textureSpec.copyLevel, textureSpec.copyOrigin);
-        encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
+            texture, textureSpec.copyLevel, textureSpec.copyOrigin);
+        encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
 
         wgpu::CommandBuffer commands = encoder.Finish();
         queue.Submit(1, &commands);
@@ -628,26 +628,26 @@
         const std::vector<uint8_t> srcTextureCopyData =
             GetExpectedTextureData(format, srcDataCopyLayout);
         {
-            wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+            wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
                 srcTexture, srcSpec.copyLevel, {0, 0, srcSpec.copyOrigin.z});
-            wgpu::TextureDataLayout textureDataLayout = utils::CreateTextureDataLayout(
+            wgpu::TexelCopyBufferLayout texelCopyBufferLayout = utils::CreateTexelCopyBufferLayout(
                 0, srcDataCopyLayout.bytesPerRow, srcDataCopyLayout.rowsPerImage);
-            this->queue.WriteTexture(&imageCopyTexture, srcTextureCopyData.data(),
-                                     srcDataCopyLayout.byteLength, &textureDataLayout,
+            this->queue.WriteTexture(&texelCopyTextureInfo, srcTextureCopyData.data(),
+                                     srcDataCopyLayout.byteLength, &texelCopyBufferLayout,
                                      &srcDataCopyLayout.mipSize);
         }
 
         wgpu::CommandEncoder encoder = this->device.CreateCommandEncoder();
 
         // Perform the texture to texture copy
-        wgpu::ImageCopyTexture srcImageCopyTexture =
-            utils::CreateImageCopyTexture(srcTexture, srcSpec.copyLevel, srcSpec.copyOrigin);
-        wgpu::ImageCopyTexture dstImageCopyTexture =
-            utils::CreateImageCopyTexture(dstTexture, dstSpec.copyLevel, dstSpec.copyOrigin);
+        wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(srcTexture, srcSpec.copyLevel, srcSpec.copyOrigin);
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dstTexture, dstSpec.copyLevel, dstSpec.copyOrigin);
         // (Off-topic) spot-test for defaulting of .aspect.
-        srcImageCopyTexture.aspect = wgpu::TextureAspect::Undefined;
-        dstImageCopyTexture.aspect = wgpu::TextureAspect::Undefined;
-        encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &copySize);
+        srcTexelCopyTextureInfo.aspect = wgpu::TextureAspect::Undefined;
+        dstTexelCopyTextureInfo.aspect = wgpu::TextureAspect::Undefined;
+        encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &copySize);
 
         // Create an output buffer and use it to completely populate the subresources of the dst
         // texture that will be copied to at the given mip level.
@@ -666,10 +666,11 @@
         const uint32_t bytesPerTexel = utils::GetTexelBlockSizeInBytes(format);
         const uint32_t expectedDstDataOffset = dstSpec.copyOrigin.x * bytesPerTexel +
                                                dstSpec.copyOrigin.y * dstDataCopyLayout.bytesPerRow;
-        wgpu::ImageCopyBuffer outputImageCopyBuffer = utils::CreateImageCopyBuffer(
+        wgpu::TexelCopyBufferInfo outputTexelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
             outputBuffer, expectedDstDataOffset, dstDataCopyLayout.bytesPerRow,
             dstDataCopyLayout.rowsPerImage);
-        encoder.CopyTextureToBuffer(&dstImageCopyTexture, &outputImageCopyBuffer, &copySize);
+        encoder.CopyTextureToBuffer(&dstTexelCopyTextureInfo, &outputTexelCopyBufferInfo,
+                                    &copySize);
 
         wgpu::CommandBuffer commands = encoder.Finish();
         this->queue.Submit(1, &commands);
@@ -1191,12 +1192,12 @@
         GetExpectedTextureData(texDesc.format, copyLayout);
     const uint32_t bytesPerTexel = utils::GetTexelBlockSizeInBytes(texDesc.format);
     {
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
-        wgpu::TextureDataLayout textureDataLayout =
-            utils::CreateTextureDataLayout(0, copyLayout.bytesPerRow, copyLayout.rowsPerImage);
-        queue.WriteTexture(&imageCopyTexture, textureArrayData.data(), copyLayout.byteLength,
-                           &textureDataLayout, &copyLayout.mipSize);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+            utils::CreateTexelCopyBufferLayout(0, copyLayout.bytesPerRow, copyLayout.rowsPerImage);
+        queue.WriteTexture(&texelCopyTextureInfo, textureArrayData.data(), copyLayout.byteLength,
+                           &texelCopyBufferLayout, &copyLayout.mipSize);
     }
 
     // Create a destination buffer and fill its before & after bytes with random data
@@ -1221,12 +1222,12 @@
     // Copy the texture to buffer at offset=bytesPerTexel and with tightly packed rows.
     {
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(buffer, /*offset=*/kCopyOffset,
-                                         /*bytesPerRow=*/256 * bytesPerTexel, /*rowsPerImage=*/1);
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &texDesc.size);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
+            buffer, /*offset=*/kCopyOffset,
+            /*bytesPerRow=*/256 * bytesPerTexel, /*rowsPerImage=*/1);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &texDesc.size);
         wgpu::CommandBuffer commands = encoder.Finish();
         queue.Submit(1, &commands);
     }
@@ -1836,14 +1837,15 @@
     bufferDescriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
     wgpu::Buffer buffer = device.CreateBuffer(&bufferDescriptor);
 
-    wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(buffer, kBufferCopyOffset, kTextureBytesPerRowAlignment);
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(buffer, kBufferCopyOffset, kTextureBytesPerRowAlignment);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
     // (Off-topic) spot-test for defaulting of .aspect.
-    imageCopyTexture.aspect = wgpu::TextureAspect::Undefined;
+    texelCopyTextureInfo.aspect = wgpu::TextureAspect::Undefined;
 
     wgpu::Extent3D copySize = textureDescriptor.size;
-    encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copySize);
+    encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copySize);
     wgpu::CommandBuffer commandBuffer = encoder.Finish();
     queue.Submit(1, &commandBuffer);
 
@@ -3288,11 +3290,13 @@
         memcpy(uploadData, expectedData.data(), expectedData.size());
         uploadBuffer.Unmap();
 
-        wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(uploadBuffer);
-        wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(destinationTexture);
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(uploadBuffer);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(destinationTexture);
         // (Off-topic) spot-test for defaulting of .aspect.
-        imageCopyTexture.aspect = wgpu::TextureAspect::Undefined;
-        encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+        texelCopyTextureInfo.aspect = wgpu::TextureAspect::Undefined;
+        encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
     };
 
     switch (GetParam().mInitializationMethod) {
@@ -3301,9 +3305,10 @@
             break;
         }
         case InitializationMethod::WriteTexture: {
-            wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture);
-            wgpu::TextureDataLayout layout;
-            queue.WriteTexture(&imageCopyTexture, expectedData.data(), texelBlockSize, &layout,
+            wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+                utils::CreateTexelCopyTextureInfo(texture);
+            wgpu::TexelCopyBufferLayout layout;
+            queue.WriteTexture(&texelCopyTextureInfo, expectedData.data(), texelBlockSize, &layout,
                                &copySize);
             break;
         }
@@ -3311,10 +3316,12 @@
             wgpu::Texture stagingTexture = device.CreateTexture(&textureDescriptor);
             EncodeUploadDataToTexture(encoder, stagingTexture, expectedData);
 
-            wgpu::ImageCopyTexture imageCopyStagingTexture =
-                utils::CreateImageCopyTexture(stagingTexture);
-            wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture);
-            encoder.CopyTextureToTexture(&imageCopyStagingTexture, &imageCopyTexture, &copySize);
+            wgpu::TexelCopyTextureInfo imageCopyStagingTexture =
+                utils::CreateTexelCopyTextureInfo(stagingTexture);
+            wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+                utils::CreateTexelCopyTextureInfo(texture);
+            encoder.CopyTextureToTexture(&imageCopyStagingTexture, &texelCopyTextureInfo,
+                                         &copySize);
             break;
         }
         default:
@@ -3327,10 +3334,10 @@
     destinationBufferDescriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
     wgpu::Buffer destinationBuffer = device.CreateBuffer(&destinationBufferDescriptor);
 
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture);
-    wgpu::ImageCopyBuffer imageCopyDestinationBuffer =
-        utils::CreateImageCopyBuffer(destinationBuffer);
-    encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyDestinationBuffer, &copySize);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(texture);
+    wgpu::TexelCopyBufferInfo imageCopyDestinationBuffer =
+        utils::CreateTexelCopyBufferInfo(destinationBuffer);
+    encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &imageCopyDestinationBuffer, &copySize);
 
     wgpu::CommandBuffer commandBuffer = encoder.Finish();
     queue.Submit(1, &commandBuffer);
@@ -3431,10 +3438,10 @@
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         for (uint32_t layer = 0; layer < layerCount; ++layer) {
             for (uint32_t level = 0; level < levelCount; ++level) {
-                wgpu::ImageCopyBuffer uploadCopyBuffer =
-                    utils::CreateImageCopyBuffer(uploadBuffer, 0, kBytesPerRow, kTextureSize);
-                wgpu::ImageCopyTexture colorCopyTexture =
-                    utils::CreateImageCopyTexture(texture, level, {0, 0, layer});
+                wgpu::TexelCopyBufferInfo uploadCopyBuffer =
+                    utils::CreateTexelCopyBufferInfo(uploadBuffer, 0, kBytesPerRow, kTextureSize);
+                wgpu::TexelCopyTextureInfo colorCopyTexture =
+                    utils::CreateTexelCopyTextureInfo(texture, level, {0, 0, layer});
 
                 wgpu::Extent3D copySize = {kTextureSize >> level, kTextureSize >> level, 1};
                 encoder.CopyBufferToTexture(&uploadCopyBuffer, &colorCopyTexture, &copySize);
@@ -3453,11 +3460,12 @@
 
         // Copy from miplevel = copyLevel and arrayLayer = copyLayer of sourceTexture into
         // stagingTexture
-        wgpu::ImageCopyTexture colorCopyTexture =
-            utils::CreateImageCopyTexture(sourceTexture, copyLevel, {0, 0, copyLayer});
+        wgpu::TexelCopyTextureInfo colorCopyTexture =
+            utils::CreateTexelCopyTextureInfo(sourceTexture, copyLevel, {0, 0, copyLayer});
         uint32_t stagingTextureSize = kTextureSize >> copyLevel;
         wgpu::Extent3D copySize = {stagingTextureSize, stagingTextureSize, 1};
-        wgpu::ImageCopyTexture stagingCopyTexture = utils::CreateImageCopyTexture(stagingTexture);
+        wgpu::TexelCopyTextureInfo stagingCopyTexture =
+            utils::CreateTexelCopyTextureInfo(stagingTexture);
         encoder.CopyTextureToTexture(&colorCopyTexture, &stagingCopyTexture, &copySize);
 
         // Copy from stagingTexture into readback buffer. Note that we don't use EXPECT_BUFFER_xxx()
@@ -3470,8 +3478,8 @@
         readbackBufferDesc.size = kBufferSize;
         readbackBufferDesc.usage = wgpu::BufferUsage::MapRead | wgpu::BufferUsage::CopyDst;
         wgpu::Buffer readbackBuffer = device.CreateBuffer(&readbackBufferDesc);
-        wgpu::ImageCopyBuffer readbackCopyBuffer =
-            utils::CreateImageCopyBuffer(readbackBuffer, 0, kBytesPerRow, kTextureSize);
+        wgpu::TexelCopyBufferInfo readbackCopyBuffer =
+            utils::CreateTexelCopyBufferInfo(readbackBuffer, 0, kBytesPerRow, kTextureSize);
         encoder.CopyTextureToBuffer(&stagingCopyTexture, &readbackCopyBuffer, &copySize);
 
         wgpu::CommandBuffer commandBuffer = encoder.Finish();
diff --git a/src/dawn/tests/end2end/CopyTextureForBrowserTests.cpp b/src/dawn/tests/end2end/CopyTextureForBrowserTests.cpp
index 5c04e3c..9d223af 100644
--- a/src/dawn/tests/end2end/CopyTextureForBrowserTests.cpp
+++ b/src/dawn/tests/end2end/CopyTextureForBrowserTests.cpp
@@ -415,16 +415,16 @@
                                        uint32_t initBytes) {
         wgpu::Texture texture = CreateTexture(spec, usage);
 
-        wgpu::ImageCopyTexture imageTextureInit =
-            utils::CreateImageCopyTexture(texture, spec.level, {0, 0});
+        wgpu::TexelCopyTextureInfo imageTextureInit =
+            utils::CreateTexelCopyTextureInfo(texture, spec.level, {0, 0});
 
-        wgpu::TextureDataLayout textureDataLayout;
-        textureDataLayout.offset = 0;
-        textureDataLayout.bytesPerRow = copyLayout.bytesPerRow;
-        textureDataLayout.rowsPerImage = copyLayout.rowsPerImage;
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout;
+        texelCopyBufferLayout.offset = 0;
+        texelCopyBufferLayout.bytesPerRow = copyLayout.bytesPerRow;
+        texelCopyBufferLayout.rowsPerImage = copyLayout.rowsPerImage;
 
-        this->device.GetQueue().WriteTexture(&imageTextureInit, init, initBytes, &textureDataLayout,
-                                             &copyLayout.mipSize);
+        this->device.GetQueue().WriteTexture(&imageTextureInit, init, initBytes,
+                                             &texelCopyBufferLayout, &copyLayout.mipSize);
         return texture;
     }
 
@@ -436,12 +436,12 @@
         const wgpu::Extent3D& copySize,
         const wgpu::CopyTextureForBrowserOptions options,
         const wgpu::TextureAspect aspect = wgpu::TextureAspect::All) {
-        wgpu::ImageCopyTexture srcImageCopyTexture =
-            utils::CreateImageCopyTexture(srcTexture, srcSpec.level, srcSpec.copyOrigin, aspect);
-        wgpu::ImageCopyTexture dstImageCopyTexture =
-            utils::CreateImageCopyTexture(dstTexture, dstSpec.level, dstSpec.copyOrigin, aspect);
-        this->device.GetQueue().CopyTextureForBrowser(&srcImageCopyTexture, &dstImageCopyTexture,
-                                                      &copySize, &options);
+        wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
+            srcTexture, srcSpec.level, srcSpec.copyOrigin, aspect);
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
+            dstTexture, dstSpec.level, dstSpec.copyOrigin, aspect);
+        this->device.GetQueue().CopyTextureForBrowser(
+            &srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &copySize, &options);
     }
 
     void CheckResultInBuiltInComputePipeline(const TextureSpec& srcSpec,
@@ -719,7 +719,7 @@
             dstTextureSpec, wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::TextureBinding |
                                 wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc);
 
-        // (Off-topic) spot-test the defaulting of ImageCopyTexture.aspect.
+        // (Off-topic) spot-test the defaulting of TexelCopyTextureInfo.aspect.
         wgpu::TextureAspect aspect = wgpu::TextureAspect::Undefined;
         // Perform the texture to texture copy
         RunCopyExternalImageToTexture(srcTextureSpec, srcTexture, dstTextureSpec, dstTexture,
@@ -742,12 +742,13 @@
             wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
 
             // Perform the texture to texture copy
-            wgpu::ImageCopyTexture dstImageCopyTexture =
-                utils::CreateImageCopyTexture(dstTexture, 0, {0, 0, 0});
-            wgpu::ImageCopyTexture intermediateImageCopyTexture =
-                utils::CreateImageCopyTexture(intermediateTexture, 0, {0, 0, 0});
+            wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+                utils::CreateTexelCopyTextureInfo(dstTexture, 0, {0, 0, 0});
+            wgpu::TexelCopyTextureInfo intermediateTexelCopyTextureInfo =
+                utils::CreateTexelCopyTextureInfo(intermediateTexture, 0, {0, 0, 0});
 
-            encoder.CopyTextureToTexture(&dstImageCopyTexture, &intermediateImageCopyTexture,
+            encoder.CopyTextureToTexture(&dstTexelCopyTextureInfo,
+                                         &intermediateTexelCopyTextureInfo,
                                          &(dstTextureSpec.textureSize));
             wgpu::CommandBuffer commands = encoder.Finish();
             queue.Submit(1, &commands);
diff --git a/src/dawn/tests/end2end/DepthStencilCopyTests.cpp b/src/dawn/tests/end2end/DepthStencilCopyTests.cpp
index edae745..c1df7ae 100644
--- a/src/dawn/tests/end2end/DepthStencilCopyTests.cpp
+++ b/src/dawn/tests/end2end/DepthStencilCopyTests.cpp
@@ -277,10 +277,10 @@
         // Perform a T2T copy of all aspects
         {
             wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder();
-            wgpu::ImageCopyTexture srcView =
-                utils::CreateImageCopyTexture(src, mipLevel, {0, 0, 0});
-            wgpu::ImageCopyTexture dstView =
-                utils::CreateImageCopyTexture(dst, mipLevel, {0, 0, 0});
+            wgpu::TexelCopyTextureInfo srcView =
+                utils::CreateTexelCopyTextureInfo(src, mipLevel, {0, 0, 0});
+            wgpu::TexelCopyTextureInfo dstView =
+                utils::CreateTexelCopyTextureInfo(dst, mipLevel, {0, 0, 0});
             wgpu::Extent3D copySize = {width >> mipLevel, height >> mipLevel, 1};
             commandEncoder.CopyTextureToTexture(&srcView, &dstView, &copySize);
 
@@ -545,11 +545,11 @@
         uint32_t bytesPerImage = bytesPerRow * copyHeight;
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, testLevel, {0, 0, 0}, aspect);
-        wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, testLevel, {0, 0, 0}, aspect);
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
             destinationBuffer, bufferCopyOffset, bytesPerRow, copyHeight);
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copySize);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copySize);
         wgpu::CommandBuffer commandBuffer = encoder.Finish();
         queue.Submit(1, &commandBuffer);
 
@@ -870,9 +870,9 @@
         wgpu::Buffer srcBuffer = device.CreateBuffer(&descriptor);
 
         constexpr uint32_t kBytesPerRow = kTextureBytesPerRowAlignment;
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(srcBuffer, bufferCopyOffset, kBytesPerRow, kHeight);
-        wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(srcBuffer, bufferCopyOffset, kBytesPerRow, kHeight);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
             destTexture, 0, {0, 0, 0}, wgpu::TextureAspect::DepthOnly);
         wgpu::Extent3D extent = {kWidth, kHeight, 1};
 
@@ -888,7 +888,7 @@
             srcBuffer.Unmap();
 
             wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-            encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &extent);
+            encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &extent);
             wgpu::CommandBuffer commands = encoder.Finish();
             queue.Submit(1, &commands);
 
@@ -905,7 +905,7 @@
             srcBuffer.Unmap();
 
             wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-            encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &extent);
+            encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &extent);
             wgpu::CommandBuffer commands = encoder.Finish();
             queue.Submit(1, &commands);
 
@@ -997,11 +997,11 @@
         uint32_t bytesPerImage = bytesPerRow * copyHeight;
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(depthStencilTexture, testLevel, {0, 0, 0}, aspect);
-        wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(depthStencilTexture, testLevel, {0, 0, 0}, aspect);
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
             destinationBuffer, bufferCopyOffset, bytesPerRow, copyHeight);
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copySize);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copySize);
         wgpu::CommandBuffer commandBuffer = encoder.Finish();
         queue.Submit(1, &commandBuffer);
 
@@ -1083,12 +1083,13 @@
             srcBuffer.Unmap();
 
             wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder();
-            wgpu::ImageCopyBuffer imageCopyBuffer =
-                utils::CreateImageCopyBuffer(srcBuffer, bufferCopyOffset, kBytesPerRow, kHeight);
-            wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+            wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
+                srcBuffer, bufferCopyOffset, kBytesPerRow, kHeight);
+            wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
                 depthStencilTexture, 0, {0, 0, 0}, wgpu::TextureAspect::StencilOnly);
             wgpu::Extent3D copySize = {kWidth, kHeight, 1};
-            commandEncoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+            commandEncoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo,
+                                               &copySize);
             wgpu::CommandBuffer commandBuffer = commandEncoder.Finish();
             queue.Submit(1, &commandBuffer);
         }
@@ -1363,15 +1364,15 @@
 
     // Upload the stencil data.
     {
-        wgpu::TextureDataLayout dataLayout = {};
+        wgpu::TexelCopyBufferLayout dataLayout = {};
         dataLayout.bytesPerRow = kWidth >> kMipLevel;
 
-        wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
             depthStencilTexture, 1, {0, 0, 0}, wgpu::TextureAspect::StencilOnly);
         wgpu::Extent3D copySize = {kWidth >> kMipLevel, kHeight >> kMipLevel, 1};
 
-        queue.WriteTexture(&imageCopyTexture, stencilData.data(), stencilData.size(), &dataLayout,
-                           &copySize);
+        queue.WriteTexture(&texelCopyTextureInfo, stencilData.data(), stencilData.size(),
+                           &dataLayout, &copySize);
     }
 
     // Check the stencil contents.
@@ -1492,10 +1493,10 @@
                     // Perform a T2T copy
                     {
                         wgpu::CommandEncoder commandEncoder = device.CreateCommandEncoder();
-                        wgpu::ImageCopyTexture srcView =
-                            utils::CreateImageCopyTexture(src, mipLevel, {0, 0, srcArrayLayer});
-                        wgpu::ImageCopyTexture dstView =
-                            utils::CreateImageCopyTexture(dst, mipLevel, {0, 0, dstArrayLayer});
+                        wgpu::TexelCopyTextureInfo srcView =
+                            utils::CreateTexelCopyTextureInfo(src, mipLevel, {0, 0, srcArrayLayer});
+                        wgpu::TexelCopyTextureInfo dstView =
+                            utils::CreateTexelCopyTextureInfo(dst, mipLevel, {0, 0, dstArrayLayer});
                         wgpu::Extent3D copySize = {mipWidth, mipHeight, layerCount};
                         commandEncoder.CopyTextureToTexture(&srcView, &dstView, &copySize);
 
diff --git a/src/dawn/tests/end2end/ExternalTextureTests.cpp b/src/dawn/tests/end2end/ExternalTextureTests.cpp
index 6002ea1..a3f1e91 100644
--- a/src/dawn/tests/end2end/ExternalTextureTests.cpp
+++ b/src/dawn/tests/end2end/ExternalTextureTests.cpp
@@ -752,12 +752,12 @@
         pass.End();
 
         {
-            wgpu::ImageCopyTexture imageCopyTexture =
-                utils::CreateImageCopyTexture(dimensionTexture, 0, {0, 0, 0});
-            wgpu::ImageCopyBuffer imageCopyBuffer =
-                utils::CreateImageCopyBuffer(dimensionBuffer, 0, 256, 1);
+            wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+                utils::CreateTexelCopyTextureInfo(dimensionTexture, 0, {0, 0, 0});
+            wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+                utils::CreateTexelCopyBufferInfo(dimensionBuffer, 0, 256, 1);
             wgpu::Extent3D size = {1, 1, 1};
-            encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &size);
+            encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &size);
         }
 
         wgpu::CommandBuffer commands = encoder.Finish();
@@ -1127,12 +1127,12 @@
     }
 
     {
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(dimensionTexture, 0, {0, 0, 0});
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(dimensionBuffer, 0, 256, 1);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dimensionTexture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(dimensionBuffer, 0, 256, 1);
         wgpu::Extent3D size = {1, 1, 1};
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &size);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &size);
     }
 
     wgpu::CommandBuffer commands = encoder.Finish();
diff --git a/src/dawn/tests/end2end/FragDepthTests.cpp b/src/dawn/tests/end2end/FragDepthTests.cpp
index 68ba894..11e9bf0 100644
--- a/src/dawn/tests/end2end/FragDepthTests.cpp
+++ b/src/dawn/tests/end2end/FragDepthTests.cpp
@@ -147,12 +147,15 @@
     texDesc.usage = wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::CopyDst;
     wgpu::Texture texture = device.CreateTexture(&texDesc);
 
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
-    wgpu::TextureDataLayout textureDataLayout = utils::CreateTextureDataLayout(0, sizeof(float));
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+        utils::CreateTexelCopyBufferLayout(0, sizeof(float));
     wgpu::Extent3D copyExtent = {1, 1, 1};
 
     float one = 1.0;
-    queue.WriteTexture(&imageCopyTexture, &one, sizeof(float), &textureDataLayout, &copyExtent);
+    queue.WriteTexture(&texelCopyTextureInfo, &one, sizeof(float), &texelCopyBufferLayout,
+                       &copyExtent);
 
     wgpu::BindGroup textureBG = utils::MakeBindGroup(device, texturePipeline.GetBindGroupLayout(0),
                                                      {{0, texture.CreateView()}});
diff --git a/src/dawn/tests/end2end/MaxLimitTests.cpp b/src/dawn/tests/end2end/MaxLimitTests.cpp
index cdcf5d1..56355aa 100644
--- a/src/dawn/tests/end2end/MaxLimitTests.cpp
+++ b/src/dawn/tests/end2end/MaxLimitTests.cpp
@@ -578,16 +578,16 @@
         wgpu::Buffer textureData =
             utils::CreateBufferFromData(device, wgpu::BufferUsage::CopySrc, {value});
 
-        wgpu::ImageCopyBuffer imageCopyBuffer = {};
-        imageCopyBuffer.buffer = textureData;
-        imageCopyBuffer.layout.bytesPerRow = 256;
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo = {};
+        texelCopyBufferInfo.buffer = textureData;
+        texelCopyBufferInfo.layout.bytesPerRow = 256;
 
-        wgpu::ImageCopyTexture imageCopyTexture = {};
-        imageCopyTexture.texture = texture;
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo = {};
+        texelCopyTextureInfo.texture = texture;
 
         wgpu::Extent3D copySize = {1, 1, 1};
 
-        commandEncoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+        commandEncoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
         return texture;
     };
 
diff --git a/src/dawn/tests/end2end/MultithreadTests.cpp b/src/dawn/tests/end2end/MultithreadTests.cpp
index af2bf6e..e87ea82 100644
--- a/src/dawn/tests/end2end/MultithreadTests.cpp
+++ b/src/dawn/tests/end2end/MultithreadTests.cpp
@@ -887,12 +887,13 @@
 
         wgpu::Extent3D textureSize = {width, height, 1};
 
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 0, {0, 0, 0}, wgpu::TextureAspect::All);
-        wgpu::TextureDataLayout textureDataLayout =
-            utils::CreateTextureDataLayout(0, dataSize / height);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0}, wgpu::TextureAspect::All);
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+            utils::CreateTexelCopyBufferLayout(0, dataSize / height);
 
-        queue.WriteTexture(&imageCopyTexture, data, dataSize, &textureDataLayout, &textureSize);
+        queue.WriteTexture(&texelCopyTextureInfo, data, dataSize, &texelCopyBufferLayout,
+                           &textureSize);
 
         return texture;
     }
@@ -904,12 +905,12 @@
 
     void CopyTextureToTextureHelper(
         const wgpu::Texture& srcTexture,
-        const wgpu::ImageCopyTexture& dst,
+        const wgpu::TexelCopyTextureInfo& dst,
         const wgpu::Extent3D& dstSize,
         const wgpu::CommandEncoder& encoder,
         const wgpu::CopyTextureForBrowserOptions* copyForBrowerOptions = nullptr) {
-        wgpu::ImageCopyTexture srcView =
-            utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::All);
+        wgpu::TexelCopyTextureInfo srcView =
+            utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::All);
 
         if (copyForBrowerOptions == nullptr) {
             encoder.CopyTextureToTexture(&srcView, &dst, &dstSize);
@@ -925,11 +926,11 @@
 
     void CopyBufferToTextureHelper(const wgpu::Buffer& srcBuffer,
                                    uint32_t srcBytesPerRow,
-                                   const wgpu::ImageCopyTexture& dst,
+                                   const wgpu::TexelCopyTextureInfo& dst,
                                    const wgpu::Extent3D& dstSize,
                                    const wgpu::CommandEncoder& encoder) {
-        wgpu::ImageCopyBuffer srcView =
-            utils::CreateImageCopyBuffer(srcBuffer, 0, srcBytesPerRow, dstSize.height);
+        wgpu::TexelCopyBufferInfo srcView =
+            utils::CreateTexelCopyBufferInfo(srcBuffer, 0, srcBytesPerRow, dstSize.height);
 
         encoder.CopyBufferToTexture(&srcView, &dst, &dstSize);
 
@@ -994,7 +995,7 @@
 
         // Copy from depthTexture to destTexture.
         const wgpu::Extent3D dstSize = {kWidth, kHeight, 1};
-        wgpu::ImageCopyTexture dest = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo dest = utils::CreateTexelCopyTextureInfo(
             destTexture, /*dstMipLevel=*/1, {0, 0, 0}, wgpu::TextureAspect::All);
         auto encoder = device.CreateCommandEncoder();
         lockStep.Wait(Step::WriteTexture);
@@ -1062,7 +1063,7 @@
 
         auto encoder = device.CreateCommandEncoder();
 
-        wgpu::ImageCopyTexture dest = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo dest = utils::CreateTexelCopyTextureInfo(
             destTexture, /*dstMipLevel=*/0, {0, 0, 0}, wgpu::TextureAspect::All);
 
         // Wait until src buffer is written.
@@ -1130,7 +1131,7 @@
 
         // Copy from stencilTexture to destTexture.
         const wgpu::Extent3D dstSize = {kWidth, kHeight, 1};
-        wgpu::ImageCopyTexture dest = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo dest = utils::CreateTexelCopyTextureInfo(
             destTexture, /*dstMipLevel=*/1, {0, 0, 0}, wgpu::TextureAspect::All);
         auto encoder = device.CreateCommandEncoder();
         lockStep.Wait(Step::WriteTexture);
@@ -1189,7 +1190,7 @@
 
         auto encoder = device.CreateCommandEncoder();
 
-        wgpu::ImageCopyTexture dest = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo dest = utils::CreateTexelCopyTextureInfo(
             destTexture, /*dstMipLevel=*/0, {0, 0, 0}, wgpu::TextureAspect::All);
 
         // Wait until src buffer is written.
@@ -1259,7 +1260,7 @@
 
         // Copy from srcTexture to destTexture.
         const wgpu::Extent3D dstSize = {kWidth, kHeight, 1};
-        wgpu::ImageCopyTexture dest = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo dest = utils::CreateTexelCopyTextureInfo(
             destTexture, /*dstMipLevel=*/0, {0, 0, 0}, wgpu::TextureAspect::All);
         wgpu::CopyTextureForBrowserOptions options;
         options.flipY = true;
@@ -1324,7 +1325,7 @@
 
         // Copy from srcTexture to destTexture.
         const wgpu::Extent3D dstSize = {kWidth, kHeight, 1};
-        wgpu::ImageCopyTexture dest = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo dest = utils::CreateTexelCopyTextureInfo(
             destTexture, /*dstMipLevel=*/0, {0, 0, 0}, wgpu::TextureAspect::All);
         wgpu::CopyTextureForBrowserOptions options = {};
 
diff --git a/src/dawn/tests/end2end/NonzeroTextureCreationTests.cpp b/src/dawn/tests/end2end/NonzeroTextureCreationTests.cpp
index c914e5b..8ef5a35 100644
--- a/src/dawn/tests/end2end/NonzeroTextureCreationTests.cpp
+++ b/src/dawn/tests/end2end/NonzeroTextureCreationTests.cpp
@@ -241,13 +241,13 @@
                 wgpu::Buffer bufferDst = utils::CreateBufferFromData(
                     device, data.data(), bufferSize, wgpu::BufferUsage::CopySrc);
 
-                wgpu::ImageCopyBuffer imageCopyBuffer =
-                    utils::CreateImageCopyBuffer(bufferDst, 0, bytesPerRow, rowsPerImage);
-                wgpu::ImageCopyTexture imageCopyTexture =
-                    utils::CreateImageCopyTexture(texture, mip, {0, 0, 0});
+                wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+                    utils::CreateTexelCopyBufferInfo(bufferDst, 0, bytesPerRow, rowsPerImage);
+                wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+                    utils::CreateTexelCopyTextureInfo(texture, mip, {0, 0, 0});
 
                 wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-                encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copySize);
+                encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copySize);
                 wgpu::CommandBuffer commands = encoder.Finish();
                 queue.Submit(1, &commands);
 
diff --git a/src/dawn/tests/end2end/PixelLocalStorageTests.cpp b/src/dawn/tests/end2end/PixelLocalStorageTests.cpp
index 8eb0aaa..75482ff 100644
--- a/src/dawn/tests/end2end/PixelLocalStorageTests.cpp
+++ b/src/dawn/tests/end2end/PixelLocalStorageTests.cpp
@@ -216,8 +216,8 @@
                 pass.End();
 
                 // Copy clearedTexture -> attachment.
-                wgpu::ImageCopyTexture src = utils::CreateImageCopyTexture(clearedTexture);
-                wgpu::ImageCopyTexture dst = utils::CreateImageCopyTexture(attachment);
+                wgpu::TexelCopyTextureInfo src = utils::CreateTexelCopyTextureInfo(clearedTexture);
+                wgpu::TexelCopyTextureInfo dst = utils::CreateTexelCopyTextureInfo(attachment);
                 wgpu::Extent3D copySize = {1, 1, 1};
                 encoder.CopyTextureToTexture(&src, &dst, &copySize);
 
diff --git a/src/dawn/tests/end2end/QueueTests.cpp b/src/dawn/tests/end2end/QueueTests.cpp
index 5248242..bef8a71 100644
--- a/src/dawn/tests/end2end/QueueTests.cpp
+++ b/src/dawn/tests/end2end/QueueTests.cpp
@@ -362,14 +362,14 @@
         descriptor.usage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::CopySrc;
         wgpu::Texture texture = device.CreateTexture(&descriptor);
 
-        wgpu::TextureDataLayout textureDataLayout = utils::CreateTextureDataLayout(
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout = utils::CreateTexelCopyBufferLayout(
             dataSpec.offset, dataSpec.bytesPerRow, dataSpec.rowsPerImage);
 
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, textureSpec.level, textureSpec.copyOrigin);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, textureSpec.level, textureSpec.copyOrigin);
 
-        queue.WriteTexture(&imageCopyTexture, data.data(), dataSpec.size, &textureDataLayout,
-                           &copySize);
+        queue.WriteTexture(&texelCopyTextureInfo, data.data(), dataSpec.size,
+                           &texelCopyBufferLayout, &copySize);
 
         const uint32_t bytesPerTexel = utils::GetTexelBlockSizeInBytes(GetParam().mTextureFormat);
         wgpu::Extent3D mipSize = {textureSpec.textureSize.width >> textureSpec.level,
@@ -818,13 +818,14 @@
         descriptor.usage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::CopySrc;
         wgpu::Texture texture = device.CreateTexture(&descriptor);
 
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
-        wgpu::TextureDataLayout textureDataLayout =
-            utils::CreateTextureDataLayout(0, width * kPixelSize);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+            utils::CreateTexelCopyBufferLayout(0, width * kPixelSize);
         wgpu::Extent3D copyExtent = {width, height, 1};
-        device.GetQueue().WriteTexture(&imageCopyTexture, data.data(), width * height * kPixelSize,
-                                       &textureDataLayout, &copyExtent);
+        device.GetQueue().WriteTexture(&texelCopyTextureInfo, data.data(),
+                                       width * height * kPixelSize, &texelCopyBufferLayout,
+                                       &copyExtent);
 
         EXPECT_TEXTURE_EQ(data.data(), texture, {0, 0}, {width, height});
     }
@@ -872,17 +873,17 @@
     // internal ring buffer and write the user data into it at the offset 0.
     {
         constexpr uint32_t kDataOffset1 = 0u;
-        wgpu::TextureDataLayout textureDataLayout =
-            utils::CreateTextureDataLayout(kDataOffset1, kBytesPerRowForWriteTexture);
-        wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+            utils::CreateTexelCopyBufferLayout(kDataOffset1, kBytesPerRowForWriteTexture);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
             dstTexture1, 0, {0, 0, 0}, wgpu::TextureAspect::StencilOnly);
-        queue.WriteTexture(&imageCopyTexture, kData, sizeof(kData), &textureDataLayout,
+        queue.WriteTexture(&texelCopyTextureInfo, kData, sizeof(kData), &texelCopyBufferLayout,
                            &kWriteSize);
 
         constexpr uint32_t kOutputBufferOffset1 = 0u;
-        wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
             outputBuffer, kOutputBufferOffset1, kTextureBytesPerRowAlignment);
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &kWriteSize);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &kWriteSize);
 
         expectedData[kOutputBufferOffset1] = kData[kDataOffset1];
     }
@@ -893,17 +894,17 @@
     // destination texture aspect is stencil.
     {
         constexpr uint32_t kDataOffset2 = 1u;
-        wgpu::TextureDataLayout textureDataLayout =
-            utils::CreateTextureDataLayout(kDataOffset2, kBytesPerRowForWriteTexture);
-        wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+            utils::CreateTexelCopyBufferLayout(kDataOffset2, kBytesPerRowForWriteTexture);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
             dstTexture2, 0, {0, 0, 0}, wgpu::TextureAspect::StencilOnly);
-        queue.WriteTexture(&imageCopyTexture, kData, sizeof(kData), &textureDataLayout,
+        queue.WriteTexture(&texelCopyTextureInfo, kData, sizeof(kData), &texelCopyBufferLayout,
                            &kWriteSize);
 
         constexpr uint32_t kOutputBufferOffset2 = 4u;
-        wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
             outputBuffer, kOutputBufferOffset2, kTextureBytesPerRowAlignment);
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &kWriteSize);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &kWriteSize);
 
         expectedData[kOutputBufferOffset2] = kData[kDataOffset2];
     }
@@ -926,18 +927,20 @@
     wgpu::Texture depthTexture2 = device.CreateTexture(&textureDescriptor);
 
     constexpr uint16_t kExpectedData1 = (204 << 8) | 205;
-    wgpu::ImageCopyTexture imageCopyTexture1 = utils::CreateImageCopyTexture(depthTexture1);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo1 =
+        utils::CreateTexelCopyTextureInfo(depthTexture1);
     // (Off-topic) spot-test for defaulting of .aspect.
-    imageCopyTexture1.aspect = wgpu::TextureAspect::Undefined;
-    wgpu::TextureDataLayout textureDataLayout =
-        utils::CreateTextureDataLayout(0, sizeof(kExpectedData1));
-    queue.WriteTexture(&imageCopyTexture1, &kExpectedData1, sizeof(kExpectedData1),
-                       &textureDataLayout, &textureDescriptor.size);
+    texelCopyTextureInfo1.aspect = wgpu::TextureAspect::Undefined;
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+        utils::CreateTexelCopyBufferLayout(0, sizeof(kExpectedData1));
+    queue.WriteTexture(&texelCopyTextureInfo1, &kExpectedData1, sizeof(kExpectedData1),
+                       &texelCopyBufferLayout, &textureDescriptor.size);
 
     constexpr uint16_t kExpectedData2 = (206 << 8) | 207;
-    wgpu::ImageCopyTexture imageCopyTexture2 = utils::CreateImageCopyTexture(depthTexture2);
-    queue.WriteTexture(&imageCopyTexture2, &kExpectedData2, sizeof(kExpectedData2),
-                       &textureDataLayout, &textureDescriptor.size);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo2 =
+        utils::CreateTexelCopyTextureInfo(depthTexture2);
+    queue.WriteTexture(&texelCopyTextureInfo2, &kExpectedData2, sizeof(kExpectedData2),
+                       &texelCopyBufferLayout, &textureDescriptor.size);
 
     EXPECT_TEXTURE_EQ(&kExpectedData1, depthTexture1, {0, 0}, {1, 1}, 0,
                       wgpu::TextureAspect::DepthOnly);
@@ -960,18 +963,18 @@
     wgpu::Texture depthStencilTexture2 = device.CreateTexture(&textureDescriptor);
 
     constexpr uint8_t kExpectedData1 = 204u;
-    wgpu::ImageCopyTexture imageCopyTexture1 = utils::CreateImageCopyTexture(
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo1 = utils::CreateTexelCopyTextureInfo(
         depthStencilTexture1, 0, {0, 0, 0}, wgpu::TextureAspect::StencilOnly);
-    wgpu::TextureDataLayout textureDataLayout =
-        utils::CreateTextureDataLayout(0, sizeof(kExpectedData1));
-    queue.WriteTexture(&imageCopyTexture1, &kExpectedData1, sizeof(kExpectedData1),
-                       &textureDataLayout, &textureDescriptor.size);
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+        utils::CreateTexelCopyBufferLayout(0, sizeof(kExpectedData1));
+    queue.WriteTexture(&texelCopyTextureInfo1, &kExpectedData1, sizeof(kExpectedData1),
+                       &texelCopyBufferLayout, &textureDescriptor.size);
 
     constexpr uint8_t kExpectedData2 = 205;
-    wgpu::ImageCopyTexture imageCopyTexture2 = utils::CreateImageCopyTexture(
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo2 = utils::CreateTexelCopyTextureInfo(
         depthStencilTexture2, 0, {0, 0, 0}, wgpu::TextureAspect::StencilOnly);
-    queue.WriteTexture(&imageCopyTexture2, &kExpectedData2, sizeof(kExpectedData2),
-                       &textureDataLayout, &textureDescriptor.size);
+    queue.WriteTexture(&texelCopyTextureInfo2, &kExpectedData2, sizeof(kExpectedData2),
+                       &texelCopyBufferLayout, &textureDescriptor.size);
 
     EXPECT_TEXTURE_EQ(&kExpectedData1, depthStencilTexture1, {0, 0}, {1, 1}, 0,
                       wgpu::TextureAspect::StencilOnly);
diff --git a/src/dawn/tests/end2end/RenderPassLoadOpTests.cpp b/src/dawn/tests/end2end/RenderPassLoadOpTests.cpp
index 9ae847c..1f4cfd1 100644
--- a/src/dawn/tests/end2end/RenderPassLoadOpTests.cpp
+++ b/src/dawn/tests/end2end/RenderPassLoadOpTests.cpp
@@ -143,11 +143,11 @@
         bufferDescriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
         wgpu::Buffer buffer = device.CreateBuffer(&bufferDescriptor);
 
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(buffer, 0, kTextureBytesPerRowAlignment);
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &kTextureSize);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(buffer, 0, kTextureBytesPerRowAlignment);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &kTextureSize);
 
         wgpu::CommandBuffer commandBuffer = encoder.Finish();
         queue.Submit(1, &commandBuffer);
@@ -669,11 +669,11 @@
         renderPass.End();
 
         for (uint32_t i = 0; i < testCase.size(); ++i) {
-            wgpu::ImageCopyTexture imageCopyTexture =
-                utils::CreateImageCopyTexture(textures[i], 0, {0, 0, 0});
-            wgpu::ImageCopyBuffer imageCopyBuffer =
-                utils::CreateImageCopyBuffer(outputBuffers[i], 0, kTextureBytesPerRowAlignment);
-            encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer,
+            wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+                utils::CreateTexelCopyTextureInfo(textures[i], 0, {0, 0, 0});
+            wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+                utils::CreateTexelCopyBufferInfo(outputBuffers[i], 0, kTextureBytesPerRowAlignment);
+            encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo,
                                         &textureDescriptor.size);
         }
 
@@ -740,18 +740,18 @@
         bufferDescriptor.size = 2 * sizeof(uint32_t);
         outputBuffer = device.CreateBuffer(&bufferDescriptor);
 
-        wgpu::ImageCopyTexture imageCopyTextureForLoad =
-            utils::CreateImageCopyTexture(textureForLoad, 0, {0, 0, 0});
-        wgpu::ImageCopyBuffer imageCopyBufferForLoad =
-            utils::CreateImageCopyBuffer(outputBuffer, 0, kTextureBytesPerRowAlignment);
-        encoder.CopyTextureToBuffer(&imageCopyTextureForLoad, &imageCopyBufferForLoad,
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfoForLoad =
+            utils::CreateTexelCopyTextureInfo(textureForLoad, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfoForLoad =
+            utils::CreateTexelCopyBufferInfo(outputBuffer, 0, kTextureBytesPerRowAlignment);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfoForLoad, &texelCopyBufferInfoForLoad,
                                     &textureDescriptor.size);
 
-        wgpu::ImageCopyTexture imageCopyTextureForClear =
-            utils::CreateImageCopyTexture(textureForClear, 0, {0, 0, 0});
-        wgpu::ImageCopyBuffer imageCopyBufferForClear = utils::CreateImageCopyBuffer(
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfoForClear =
+            utils::CreateTexelCopyTextureInfo(textureForClear, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfoForClear = utils::CreateTexelCopyBufferInfo(
             outputBuffer, sizeof(uint32_t), kTextureBytesPerRowAlignment);
-        encoder.CopyTextureToBuffer(&imageCopyTextureForClear, &imageCopyBufferForClear,
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfoForClear, &texelCopyBufferInfoForClear,
                                     &textureDescriptor.size);
 
         wgpu::CommandBuffer commandBuffer = encoder.Finish();
diff --git a/src/dawn/tests/end2end/RenderPassTests.cpp b/src/dawn/tests/end2end/RenderPassTests.cpp
index b0c1330..06013e2 100644
--- a/src/dawn/tests/end2end/RenderPassTests.cpp
+++ b/src/dawn/tests/end2end/RenderPassTests.cpp
@@ -230,8 +230,8 @@
     // Copy the texture in the buffer.
     {
         wgpu::Extent3D copySize = {1, 1};
-        wgpu::ImageCopyTexture src = utils::CreateImageCopyTexture(tex, kLastMipLevel);
-        wgpu::ImageCopyBuffer dst = utils::CreateImageCopyBuffer(buf);
+        wgpu::TexelCopyTextureInfo src = utils::CreateTexelCopyTextureInfo(tex, kLastMipLevel);
+        wgpu::TexelCopyBufferInfo dst = utils::CreateTexelCopyBufferInfo(buf);
 
         encoder.CopyTextureToBuffer(&src, &dst, &copySize);
     }
@@ -292,20 +292,20 @@
             // Initialize all subresources with WriteTexture.
             for (uint32_t level = 0; level < mipLevelCount; ++level) {
                 for (uint32_t layer = 0; layer < arrayLayerCount; ++layer) {
-                    wgpu::ImageCopyTexture imageCopyTexture =
-                        utils::CreateImageCopyTexture(tex, level, {0, 0, layer});
+                    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+                        utils::CreateTexelCopyTextureInfo(tex, level, {0, 0, layer});
                     wgpu::Extent3D copySize = {width >> level, height >> level, 1};
 
-                    wgpu::TextureDataLayout textureDataLayout;
-                    textureDataLayout.offset = 0;
-                    textureDataLayout.bytesPerRow = copySize.width * sizeof(uint16_t);
-                    textureDataLayout.rowsPerImage = copySize.height;
+                    wgpu::TexelCopyBufferLayout texelCopyBufferLayout;
+                    texelCopyBufferLayout.offset = 0;
+                    texelCopyBufferLayout.bytesPerRow = copySize.width * sizeof(uint16_t);
+                    texelCopyBufferLayout.rowsPerImage = copySize.height;
 
                     // Use a distinct value for each subresource.
                     uint16_t value = level * 10 + layer;
                     std::vector<uint16_t> data(copySize.width * copySize.height, value);
-                    queue.WriteTexture(&imageCopyTexture, data.data(),
-                                       data.size() * sizeof(uint16_t), &textureDataLayout,
+                    queue.WriteTexture(&texelCopyTextureInfo, data.data(),
+                                       data.size() * sizeof(uint16_t), &texelCopyBufferLayout,
                                        &copySize);
                 }
             }
diff --git a/src/dawn/tests/end2end/RequiredBufferSizeInCopyTests.cpp b/src/dawn/tests/end2end/RequiredBufferSizeInCopyTests.cpp
index 35b9e18..57ed65d 100644
--- a/src/dawn/tests/end2end/RequiredBufferSizeInCopyTests.cpp
+++ b/src/dawn/tests/end2end/RequiredBufferSizeInCopyTests.cpp
@@ -110,10 +110,10 @@
         texDesc.usage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::CopySrc;
         wgpu::Texture texture = device.CreateTexture(&texDesc);
 
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(buffer, kOffset, kBytesPerRow, rowsPerImage);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(buffer, kOffset, kBytesPerRow, rowsPerImage);
 
         // Initialize copied data and set expected data for buffer and texture.
         DAWN_ASSERT(sizeof(uint32_t) == kBytesPerBlock);
@@ -135,18 +135,18 @@
         wgpu::CommandEncoder encoder = this->device.CreateCommandEncoder();
         switch (GetParam().mType) {
             case Type::T2BCopy: {
-                wgpu::TextureDataLayout textureDataLayout =
-                    utils::CreateTextureDataLayout(kOffset, kBytesPerRow, rowsPerImage);
+                wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+                    utils::CreateTexelCopyBufferLayout(kOffset, kBytesPerRow, rowsPerImage);
 
-                queue.WriteTexture(&imageCopyTexture, data.data(), bufferSize, &textureDataLayout,
-                                   &copySize);
+                queue.WriteTexture(&texelCopyTextureInfo, data.data(), bufferSize,
+                                   &texelCopyBufferLayout, &copySize);
 
-                encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copySize);
+                encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copySize);
                 break;
             }
             case Type::B2TCopy:
                 queue.WriteBuffer(buffer, 0, data.data(), bufferSize);
-                encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+                encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
                 break;
         }
         wgpu::CommandBuffer commands = encoder.Finish();
diff --git a/src/dawn/tests/end2end/SamplerFilterAnisotropicTests.cpp b/src/dawn/tests/end2end/SamplerFilterAnisotropicTests.cpp
index b1f5da5..29b9a83 100644
--- a/src/dawn/tests/end2end/SamplerFilterAnisotropicTests.cpp
+++ b/src/dawn/tests/end2end/SamplerFilterAnisotropicTests.cpp
@@ -141,12 +141,12 @@
             wgpu::Buffer stagingBuffer =
                 utils::CreateBufferFromData(device, data.data(), data.size() * sizeof(utils::RGBA8),
                                             wgpu::BufferUsage::CopySrc);
-            wgpu::ImageCopyBuffer imageCopyBuffer =
-                utils::CreateImageCopyBuffer(stagingBuffer, 0, kTextureBytesPerRowAlignment);
-            wgpu::ImageCopyTexture imageCopyTexture =
-                utils::CreateImageCopyTexture(texture, level, {0, 0, 0});
+            wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+                utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, kTextureBytesPerRowAlignment);
+            wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+                utils::CreateTexelCopyTextureInfo(texture, level, {0, 0, 0});
             wgpu::Extent3D copySize = {texWidth, texHeight, 1};
-            encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+            encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
         }
         wgpu::CommandBuffer copy = encoder.Finish();
         queue.Submit(1, &copy);
diff --git a/src/dawn/tests/end2end/SamplerTests.cpp b/src/dawn/tests/end2end/SamplerTests.cpp
index efed4e5..dd19ae3 100644
--- a/src/dawn/tests/end2end/SamplerTests.cpp
+++ b/src/dawn/tests/end2end/SamplerTests.cpp
@@ -112,13 +112,14 @@
         wgpu::Buffer stagingBuffer =
             utils::CreateBufferFromData(device, pixels.data(), pixels.size() * sizeof(utils::RGBA8),
                                         wgpu::BufferUsage::CopySrc);
-        wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(stagingBuffer, 0, 256);
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, 256);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
         wgpu::Extent3D copySize = {2, 2, 1};
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+        encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
 
         wgpu::CommandBuffer copy = encoder.Finish();
         queue.Submit(1, &copy);
diff --git a/src/dawn/tests/end2end/StorageTextureTests.cpp b/src/dawn/tests/end2end/StorageTextureTests.cpp
index f6868bb..056cc7b 100644
--- a/src/dawn/tests/end2end/StorageTextureTests.cpp
+++ b/src/dawn/tests/end2end/StorageTextureTests.cpp
@@ -479,11 +479,11 @@
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
 
         const wgpu::Extent3D copyExtent = {kWidth, kHeight, sliceCount};
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(uploadBuffer, 0, kTextureBytesPerRowAlignment, kHeight);
-        wgpu::ImageCopyTexture imageCopyTexture;
-        imageCopyTexture.texture = outputTexture;
-        encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copyExtent);
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
+            uploadBuffer, 0, kTextureBytesPerRowAlignment, kHeight);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo;
+        texelCopyTextureInfo.texture = outputTexture;
+        encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copyExtent);
 
         wgpu::CommandBuffer commandBuffer = encoder.Finish();
         queue.Submit(1, &commandBuffer);
@@ -677,11 +677,11 @@
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         {
-            wgpu::ImageCopyTexture imageCopyTexture =
-                utils::CreateImageCopyTexture(storageTexture, mipLevel, {0, 0, 0});
-            wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(
+            wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+                utils::CreateTexelCopyTextureInfo(storageTexture, mipLevel, {0, 0, 0});
+            wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
                 resultBuffer, 0, kTextureBytesPerRowAlignment, size.height);
-            encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &size);
+            encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &size);
         }
         wgpu::CommandBuffer commandBuffer = encoder.Finish();
         queue.Submit(1, &commandBuffer);
@@ -895,12 +895,13 @@
     bufferDescriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
     wgpu::Buffer resultBuffer = device.CreateBuffer(&bufferDescriptor);
 
-    wgpu::ImageCopyTexture imageCopyTexture;
-    imageCopyTexture.texture = storageTexture1;
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo;
+    texelCopyTextureInfo.texture = storageTexture1;
 
-    wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(resultBuffer, 0, 256, 1);
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(resultBuffer, 0, 256, 1);
     wgpu::Extent3D extent3D = {1, 1, 1};
-    encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &extent3D);
+    encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &extent3D);
 
     wgpu::CommandBuffer commands = encoder.Finish();
     queue.Submit(1, &commands);
@@ -1506,21 +1507,21 @@
     computeEncoder.End();
 
     {
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(resultBuffer0, 0, 256, 1);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(resultBuffer0, 0, 256, 1);
         wgpu::Extent3D size({1, 1, 1});
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &size);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &size);
     }
 
     {
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 1, {0, 0, 0});
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(resultBuffer1, 0, 256, 1);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 1, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(resultBuffer1, 0, 256, 1);
         wgpu::Extent3D size({1, 1, 1});
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &size);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &size);
     }
 
     wgpu::CommandBuffer commandBuffer = encoder.Finish();
@@ -1583,11 +1584,12 @@
         uint32_t width = 4 >> mipLevel;
         uint32_t bytesPerRow = width * 4;
         wgpu::Extent3D copySize({width, 1, 1});
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, mipLevel, {0, 0, 0});
-        wgpu::TextureDataLayout textureDataLayout = utils::CreateTextureDataLayout(0, bytesPerRow);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, mipLevel, {0, 0, 0});
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+            utils::CreateTexelCopyBufferLayout(0, bytesPerRow);
         std::vector<uint8_t> data(bytesPerRow, mipLevel + 1);
-        queue.WriteTexture(&imageCopyTexture, data.data(), bytesPerRow, &textureDataLayout,
+        queue.WriteTexture(&texelCopyTextureInfo, data.data(), bytesPerRow, &texelCopyBufferLayout,
                            &copySize);
     }
 
@@ -1662,11 +1664,12 @@
         uint32_t width = 4 >> mipLevel;
         uint32_t bytesPerRow = width * 4;
         wgpu::Extent3D copySize({width, 1, 1});
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, mipLevel, {0, 0, 0});
-        wgpu::TextureDataLayout textureDataLayout = utils::CreateTextureDataLayout(0, bytesPerRow);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, mipLevel, {0, 0, 0});
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+            utils::CreateTexelCopyBufferLayout(0, bytesPerRow);
         std::vector<uint8_t> data(bytesPerRow, mipLevel + 1);
-        queue.WriteTexture(&imageCopyTexture, data.data(), bytesPerRow, &textureDataLayout,
+        queue.WriteTexture(&texelCopyTextureInfo, data.data(), bytesPerRow, &texelCopyBufferLayout,
                            &copySize);
     }
 
@@ -1695,12 +1698,12 @@
 
     // copy a texel from mip level 2
     {
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 2, {0, 0, 0});
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(resultBuffer, 0, 256, 1);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 2, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(resultBuffer, 0, 256, 1);
         wgpu::Extent3D size({1, 1, 1});
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &size);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &size);
     }
 
     wgpu::CommandBuffer commandBuffer = encoder.Finish();
diff --git a/src/dawn/tests/end2end/SurfaceTests.cpp b/src/dawn/tests/end2end/SurfaceTests.cpp
index 9451ce6..7e1f9ee 100644
--- a/src/dawn/tests/end2end/SurfaceTests.cpp
+++ b/src/dawn/tests/end2end/SurfaceTests.cpp
@@ -602,9 +602,9 @@
     surface.GetCurrentTexture(&t);
 
     wgpu::Extent3D writeSize = {1, 1, 1};
-    wgpu::ImageCopyTexture dest = {};
+    wgpu::TexelCopyTextureInfo dest = {};
     dest.texture = t.texture;
-    wgpu::TextureDataLayout dataLayout = {};
+    wgpu::TexelCopyBufferLayout dataLayout = {};
     queue.WriteTexture(&dest, &utils::RGBA8::kRed, sizeof(utils::RGBA8), &dataLayout, &writeSize);
 
     if (t.texture.GetUsage() & wgpu::TextureUsage::TextureBinding) {
diff --git a/src/dawn/tests/end2end/Texture3DTests.cpp b/src/dawn/tests/end2end/Texture3DTests.cpp
index f9696b5..b732926 100644
--- a/src/dawn/tests/end2end/Texture3DTests.cpp
+++ b/src/dawn/tests/end2end/Texture3DTests.cpp
@@ -108,10 +108,11 @@
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
 
-    wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(buffer, 0, bytesPerRow, copySize.height);
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
-    encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(buffer, 0, bytesPerRow, copySize.height);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
+    encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
 
     wgpu::BindGroup bindGroup = utils::MakeBindGroup(device, pipeline.GetBindGroupLayout(0),
                                                      {{0, sampler}, {1, textureView}});
diff --git a/src/dawn/tests/end2end/TextureCorruptionTests.cpp b/src/dawn/tests/end2end/TextureCorruptionTests.cpp
index ad5ec8b..e172910 100644
--- a/src/dawn/tests/end2end/TextureCorruptionTests.cpp
+++ b/src/dawn/tests/end2end/TextureCorruptionTests.cpp
@@ -123,12 +123,12 @@
         wgpu::Buffer buffer = device.CreateBuffer(&descriptor);
         wgpu::Buffer resultBuffer = device.CreateBuffer(&descriptor);
 
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, mipLevel, {0, 0, depthOrArrayLayer});
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(buffer, 0, bytesPerRow);
-        wgpu::ImageCopyBuffer imageCopyResult =
-            utils::CreateImageCopyBuffer(resultBuffer, 0, bytesPerRow);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, mipLevel, {0, 0, depthOrArrayLayer});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(buffer, 0, bytesPerRow);
+        wgpu::TexelCopyBufferInfo imageCopyResult =
+            utils::CreateTexelCopyBufferInfo(resultBuffer, 0, bytesPerRow);
 
         WriteType type = GetParam().mWriteType;
 
@@ -172,14 +172,14 @@
         switch (type) {
             case WriteType::B2TCopy: {
                 queue.WriteBuffer(buffer, 0, data.data(), bufferSize);
-                encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+                encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
                 break;
             }
             case WriteType::WriteTexture: {
-                wgpu::TextureDataLayout textureDataLayout =
-                    utils::CreateTextureDataLayout(0, bytesPerRow);
-                queue.WriteTexture(&imageCopyTexture, data.data(), bufferSize, &textureDataLayout,
-                                   &copySize);
+                wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+                    utils::CreateTexelCopyBufferLayout(0, bytesPerRow);
+                queue.WriteTexture(&texelCopyTextureInfo, data.data(), bufferSize,
+                                   &texelCopyBufferLayout, &copySize);
                 break;
             }
             case WriteType::RenderConstant:
@@ -190,12 +190,12 @@
                 wgpu::TextureView tempView;
                 if (type != WriteType::RenderConstant) {
                     wgpu::Texture tempTexture = Create2DTexture(copySize, format, 1, 1);
-                    wgpu::ImageCopyTexture imageCopyTempTexture =
-                        utils::CreateImageCopyTexture(tempTexture, 0, {0, 0, 0});
-                    wgpu::TextureDataLayout textureDataLayout =
-                        utils::CreateTextureDataLayout(0, bytesPerRow);
+                    wgpu::TexelCopyTextureInfo imageCopyTempTexture =
+                        utils::CreateTexelCopyTextureInfo(tempTexture, 0, {0, 0, 0});
+                    wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+                        utils::CreateTexelCopyBufferLayout(0, bytesPerRow);
                     queue.WriteTexture(&imageCopyTempTexture, data.data(), bufferSize,
-                                       &textureDataLayout, &copySize);
+                                       &texelCopyBufferLayout, &copySize);
                     tempView = tempTexture.CreateView();
                 }
 
@@ -216,7 +216,7 @@
         }
 
         // Verify the data in texture via a T2B copy and comparison
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyResult, &copySize);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &imageCopyResult, &copySize);
         wgpu::CommandBuffer commands = encoder.Finish();
         queue.Submit(1, &commands);
         return EXPECT_BUFFER_U32_RANGE_EQ(data.data(), resultBuffer, 0, elementNumInTotal);
diff --git a/src/dawn/tests/end2end/TextureFormatTests.cpp b/src/dawn/tests/end2end/TextureFormatTests.cpp
index cfffef9..f174f7c 100644
--- a/src/dawn/tests/end2end/TextureFormatTests.cpp
+++ b/src/dawn/tests/end2end/TextureFormatTests.cpp
@@ -331,9 +331,10 @@
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
 
         {
-            wgpu::ImageCopyBuffer bufferView = utils::CreateImageCopyBuffer(uploadBuffer, 0, 256);
-            wgpu::ImageCopyTexture textureView =
-                utils::CreateImageCopyTexture(sampleTexture, 0, {0, 0, 0});
+            wgpu::TexelCopyBufferInfo bufferView =
+                utils::CreateTexelCopyBufferInfo(uploadBuffer, 0, 256);
+            wgpu::TexelCopyTextureInfo textureView =
+                utils::CreateTexelCopyTextureInfo(sampleTexture, 0, {0, 0, 0});
             wgpu::Extent3D extent{width, 1, 1};
             encoder.CopyBufferToTexture(&bufferView, &textureView, &extent);
         }
@@ -346,9 +347,10 @@
         renderPass.End();
 
         {
-            wgpu::ImageCopyBuffer bufferView = utils::CreateImageCopyBuffer(readbackBuffer, 0, 256);
-            wgpu::ImageCopyTexture textureView =
-                utils::CreateImageCopyTexture(renderTarget, 0, {0, 0, 0});
+            wgpu::TexelCopyBufferInfo bufferView =
+                utils::CreateTexelCopyBufferInfo(readbackBuffer, 0, 256);
+            wgpu::TexelCopyTextureInfo textureView =
+                utils::CreateTexelCopyTextureInfo(renderTarget, 0, {0, 0, 0});
             wgpu::Extent3D extent{width, 1, 1};
             encoder.CopyTextureToBuffer(&textureView, &bufferView, &extent);
         }
diff --git a/src/dawn/tests/end2end/TextureViewTests.cpp b/src/dawn/tests/end2end/TextureViewTests.cpp
index 178a3cf..2d8d7ee 100644
--- a/src/dawn/tests/end2end/TextureViewTests.cpp
+++ b/src/dawn/tests/end2end/TextureViewTests.cpp
@@ -202,12 +202,12 @@
                 wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
                     device, data.data(), data.size() * sizeof(utils::RGBA8),
                     wgpu::BufferUsage::CopySrc);
-                wgpu::ImageCopyBuffer imageCopyBuffer =
-                    utils::CreateImageCopyBuffer(stagingBuffer, 0, kTextureBytesPerRowAlignment);
-                wgpu::ImageCopyTexture imageCopyTexture =
-                    utils::CreateImageCopyTexture(mTexture, level, {0, 0, layer});
+                wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
+                    stagingBuffer, 0, kTextureBytesPerRowAlignment);
+                wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+                    utils::CreateTexelCopyTextureInfo(mTexture, level, {0, 0, layer});
                 wgpu::Extent3D copySize = {texWidth, texHeight, 1};
-                encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+                encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
             }
         }
         wgpu::CommandBuffer copy = encoder.Finish();
@@ -571,7 +571,7 @@
     textureDesc.viewFormatCount = 1;
     wgpu::Texture texture = device.CreateTexture(&textureDesc);
 
-    wgpu::ImageCopyTexture dst = {};
+    wgpu::TexelCopyTextureInfo dst = {};
     dst.texture = texture;
     std::array<utils::RGBA8, 4> rgbaTextureData = {
         utils::RGBA8(180, 0, 0, 255),
@@ -580,7 +580,7 @@
         utils::RGBA8(62, 180, 84, 90),
     };
 
-    wgpu::TextureDataLayout dataLayout = {};
+    wgpu::TexelCopyBufferLayout dataLayout = {};
     dataLayout.bytesPerRow = textureDesc.size.width * sizeof(utils::RGBA8);
 
     queue.WriteTexture(&dst, rgbaTextureData.data(), rgbaTextureData.size() * sizeof(utils::RGBA8),
@@ -924,8 +924,8 @@
         utils::RGBA8(13, 117, 24, 90),
     };
 
-    wgpu::ImageCopyTexture dst = {};
-    wgpu::TextureDataLayout dataLayout = {};
+    wgpu::TexelCopyTextureInfo dst = {};
+    wgpu::TexelCopyBufferLayout dataLayout = {};
 
     // Upload |rgbaTextureData| into |sampledTexture|.
     dst.texture = sampledTexture;
@@ -1037,8 +1037,8 @@
         utils::RGBA8(13, 117, 24, 90),
     };
 
-    wgpu::ImageCopyTexture dst = {};
-    wgpu::TextureDataLayout dataLayout = {};
+    wgpu::TexelCopyTextureInfo dst = {};
+    wgpu::TexelCopyBufferLayout dataLayout = {};
 
     // Upload |rgbaTextureData| into |sampledTexture|.
     dst.texture = sampledTexture;
@@ -1200,8 +1200,9 @@
 
     std::array<utils::RGBA8, 4> data = {utils::RGBA8::kGreen, utils::RGBA8::kRed,
                                         utils::RGBA8::kBlue, utils::RGBA8::kWhite};
-    wgpu::ImageCopyTexture target = utils::CreateImageCopyTexture(tex, 0, {});
-    wgpu::TextureDataLayout layout = utils::CreateTextureDataLayout(0, wgpu::kCopyStrideUndefined);
+    wgpu::TexelCopyTextureInfo target = utils::CreateTexelCopyTextureInfo(tex, 0, {});
+    wgpu::TexelCopyBufferLayout layout =
+        utils::CreateTexelCopyBufferLayout(0, wgpu::kCopyStrideUndefined);
     queue.WriteTexture(&target, &data, sizeof(data), &layout, &texDesc.size);
 
     // Create a pipeline that will sample from the 1D texture and output to an attachment.
diff --git a/src/dawn/tests/end2end/TextureZeroInitTests.cpp b/src/dawn/tests/end2end/TextureZeroInitTests.cpp
index b67590c..015016a 100644
--- a/src/dawn/tests/end2end/TextureZeroInitTests.cpp
+++ b/src/dawn/tests/end2end/TextureZeroInitTests.cpp
@@ -149,15 +149,15 @@
             stencilData[i] = i % 255;
         }
 
-        wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
             depthStencilTexture, 0u, {0, 0, 0}, wgpu::TextureAspect::StencilOnly);
 
-        wgpu::TextureDataLayout textureDataLayout = {};
-        textureDataLayout.bytesPerRow = kSize;
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout = {};
+        texelCopyBufferLayout.bytesPerRow = kSize;
 
         // Write the stencil data
-        queue.WriteTexture(&imageCopyTexture, stencilData.data(), stencilData.size(),
-                           &textureDataLayout, &depthStencilDescriptor.size);
+        queue.WriteTexture(&texelCopyTextureInfo, stencilData.data(), stencilData.size(),
+                           &texelCopyBufferLayout, &depthStencilDescriptor.size);
 
         return depthStencilTexture;
     }
@@ -206,14 +206,14 @@
                                                        {kSize, kSize, kArrayLayers}, kColorFormat);
     wgpu::Buffer buffer = device.CreateBuffer(&bufferDescriptor);
 
-    const wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(buffer, 0, bytesPerRow, kSize);
-    const wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+    const wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(buffer, 0, bytesPerRow, kSize);
+    const wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
     const wgpu::Extent3D copySize = {kSize, kSize, kArrayLayers};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copySize);
+    encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copySize);
     wgpu::CommandBuffer commandBuffer = encoder.Finish();
 
     // Expect texture to be lazy initialized.
@@ -329,13 +329,14 @@
     wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
 
-    wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(stagingBuffer, 0, kSize * sizeof(uint32_t));
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, kSize * sizeof(uint32_t));
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+    encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
     wgpu::CommandBuffer commands = encoder.Finish();
     EXPECT_LAZY_CLEAR(0u, queue.Submit(1, &commands));
 
@@ -361,13 +362,14 @@
     wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
 
-    wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(stagingBuffer, 0, kSize * sizeof(uint16_t));
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, kSize * sizeof(uint16_t));
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize / 2, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+    encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
     wgpu::CommandBuffer commands = encoder.Finish();
     EXPECT_LAZY_CLEAR(1u, queue.Submit(1, &commands));
 
@@ -395,14 +397,14 @@
     wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
 
-    const wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(stagingBuffer, 0, kSize * kFormatBlockByteSize, kSize);
-    const wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(texture, 0, {0, 0, kBaseArrayLayer});
+    const wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, kSize * kFormatBlockByteSize, kSize);
+    const wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, kBaseArrayLayer});
     const wgpu::Extent3D copySize = {kSize, kSize, kCopyLayerCount};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+    encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
     wgpu::CommandBuffer commands = encoder.Finish();
 
     // The copy overwrites the whole subresources so we don't need to do lazy initialization on
@@ -425,8 +427,8 @@
         1, 1, wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::CopySrc, kColorFormat);
     wgpu::Texture srcTexture = device.CreateTexture(&srcDescriptor);
 
-    wgpu::ImageCopyTexture srcImageCopyTexture =
-        utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0});
 
     wgpu::TextureDescriptor dstDescriptor =
         CreateTextureDescriptor(1, 1,
@@ -435,13 +437,13 @@
                                 kColorFormat);
     wgpu::Texture dstTexture = device.CreateTexture(&dstDescriptor);
 
-    wgpu::ImageCopyTexture dstImageCopyTexture =
-        utils::CreateImageCopyTexture(dstTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(dstTexture, 0, {0, 0, 0});
 
     wgpu::Extent3D copySize = {kSize, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &copySize);
+    encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &copySize);
     wgpu::CommandBuffer commands = encoder.Finish();
     EXPECT_LAZY_CLEAR(1u, queue.Submit(1, &commands));
 
@@ -470,19 +472,19 @@
         std::vector<uint8_t> data(kFormatBlockByteSize * kSize * kSize, 100);
         wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
             device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(stagingBuffer, 0, kSize * kFormatBlockByteSize);
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, kSize * kFormatBlockByteSize);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0});
         wgpu::Extent3D copySize = {kSize, kSize, 1};
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+        encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
         wgpu::CommandBuffer commands = encoder.Finish();
         queue.Submit(1, &commands);
     }
 
-    wgpu::ImageCopyTexture srcImageCopyTexture =
-        utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0});
 
     wgpu::TextureDescriptor dstDescriptor =
         CreateTextureDescriptor(1, 1,
@@ -491,12 +493,12 @@
                                 kColorFormat);
     wgpu::Texture dstTexture = device.CreateTexture(&dstDescriptor);
 
-    wgpu::ImageCopyTexture dstImageCopyTexture =
-        utils::CreateImageCopyTexture(dstTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(dstTexture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize / 2, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &copySize);
+    encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &copySize);
     wgpu::CommandBuffer commands = encoder.Finish();
     EXPECT_LAZY_CLEAR(1u, queue.Submit(1, &commands));
 
@@ -870,15 +872,15 @@
             stencilData[i] = i % 255;
         }
 
-        wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
             depthStencilTexture, 0, {0, 0, 0}, wgpu::TextureAspect::StencilOnly);
 
-        wgpu::TextureDataLayout textureDataLayout = {};
-        textureDataLayout.bytesPerRow = kSize;
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout = {};
+        texelCopyBufferLayout.bytesPerRow = kSize;
 
         // Write the stencil data
-        queue.WriteTexture(&imageCopyTexture, stencilData.data(), stencilData.size(),
-                           &textureDataLayout, &depthStencilDescriptor.size);
+        queue.WriteTexture(&texelCopyTextureInfo, stencilData.data(), stencilData.size(),
+                           &texelCopyBufferLayout, &depthStencilDescriptor.size);
 
         wgpu::Texture intermediate = device.CreateTexture(&depthStencilDescriptor);
 
@@ -894,8 +896,8 @@
             wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
             auto pass = encoder.BeginRenderPass(&renderPassDescriptor);
             pass.End();
-            wgpu::ImageCopyTexture src = utils::CreateImageCopyTexture(depthStencilTexture);
-            wgpu::ImageCopyTexture dst = utils::CreateImageCopyTexture(intermediate);
+            wgpu::TexelCopyTextureInfo src = utils::CreateTexelCopyTextureInfo(depthStencilTexture);
+            wgpu::TexelCopyTextureInfo dst = utils::CreateTexelCopyTextureInfo(intermediate);
             encoder.CopyTextureToTexture(&src, &dst, &depthStencilDescriptor.size);
             wgpu::CommandBuffer commandBuffer = encoder.Finish();
             queue.Submit(1, &commandBuffer);
@@ -1192,12 +1194,14 @@
     wgpu::Buffer bufferDst = utils::CreateBufferFromData(
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
 
-    wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(bufferDst, 0, bytesPerRow);
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(bufferDst, 0, bytesPerRow);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copySize);
+    encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copySize);
     wgpu::CommandBuffer commands = encoder.Finish();
     EXPECT_LAZY_CLEAR(1u, queue.Submit(1, &commands));
 
@@ -1226,12 +1230,14 @@
     std::vector<uint8_t> data(bufferSize, 100);
     wgpu::Buffer bufferDst = utils::CreateBufferFromData(
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
-    wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(bufferDst, 0, bytesPerRow);
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(bufferDst, 0, bytesPerRow);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kUnalignedSize, kUnalignedSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copySize);
+    encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copySize);
     wgpu::CommandBuffer commands = encoder.Finish();
     EXPECT_LAZY_CLEAR(1u, queue.Submit(1, &commands));
 
@@ -1258,13 +1264,14 @@
     wgpu::Buffer bufferDst = utils::CreateBufferFromData(
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
 
-    wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(bufferDst, 0, kSize * kFormatBlockByteSize);
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 1});
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(bufferDst, 0, kSize * kFormatBlockByteSize);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 1});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copySize);
+    encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copySize);
     wgpu::CommandBuffer commands = encoder.Finish();
     EXPECT_LAZY_CLEAR(1u, queue.Submit(1, &commands));
 
@@ -1293,12 +1300,13 @@
     std::vector<uint8_t> data(kFormatBlockByteSize * kSize * kSize, 1);
     wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
-    wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(stagingBuffer, 0, kSize * kFormatBlockByteSize);
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, kSize * kFormatBlockByteSize);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+    encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
     wgpu::CommandBuffer commands = encoder.Finish();
     // Expect 0 lazy clears because the texture will be completely copied to
     EXPECT_LAZY_CLEAR(0u, queue.Submit(1, &commands));
@@ -1439,13 +1447,13 @@
     std::vector<uint8_t> data(kFormatBlockByteSize * mipSize * mipSize, 2);
     wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
-    wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(stagingBuffer, 0, mipSize * kFormatBlockByteSize);
-    wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(sampleTexture, 1, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, mipSize * kFormatBlockByteSize);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(sampleTexture, 1, {0, 0, 0});
     wgpu::Extent3D copySize = {mipSize, mipSize, 1};
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+    encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
     wgpu::CommandBuffer commands = encoder.Finish();
     // Expect 0 lazy clears because the texture subresource will be completely copied to
     EXPECT_LAZY_CLEAR(0u, queue.Submit(1, &commands));
@@ -1519,13 +1527,13 @@
     std::vector<uint8_t> data(kFormatBlockByteSize * kSize * kSize, 2);
     wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
-    wgpu::ImageCopyBuffer imageCopyBuffer =
-        utils::CreateImageCopyBuffer(stagingBuffer, 0, kSize * kFormatBlockByteSize);
-    wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(sampleTexture, 0, {0, 0, 1});
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, kSize * kFormatBlockByteSize);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(sampleTexture, 0, {0, 0, 1});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copySize);
+    encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copySize);
     wgpu::CommandBuffer commands = encoder.Finish();
     // Expect 0 lazy clears because the texture subresource will be completely copied to
     EXPECT_LAZY_CLEAR(0u, queue.Submit(1, &commands));
@@ -1606,14 +1614,14 @@
         wgpu::Buffer buffer = utils::CreateBufferFromData(device, initialBufferData.data(),
                                                           bufferSize, wgpu::BufferUsage::CopyDst);
 
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(buffer, 0, bytesPerRow);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(buffer, 0, bytesPerRow);
         wgpu::Extent3D copySize = {kUnalignedSize, kUnalignedSize, 1};
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &copySize);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &copySize);
 
         wgpu::CommandBuffer commands = encoder.Finish();
         EXPECT_LAZY_CLEAR(1u, queue.Submit(1, &commands));
@@ -1629,24 +1637,25 @@
         1, 1, wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::CopySrc, kColorFormat);
     wgpu::Texture texture = device.CreateTexture(&descriptor);
 
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
 
-    wgpu::TextureDataLayout textureDataLayout;
-    textureDataLayout.offset = 0;
-    textureDataLayout.bytesPerRow = kSize * kFormatBlockByteSize;
-    textureDataLayout.rowsPerImage = kSize;
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout;
+    texelCopyBufferLayout.offset = 0;
+    texelCopyBufferLayout.bytesPerRow = kSize * kFormatBlockByteSize;
+    texelCopyBufferLayout.rowsPerImage = kSize;
 
     std::vector<utils::RGBA8> data(
-        utils::RequiredBytesInCopy(textureDataLayout.bytesPerRow, textureDataLayout.rowsPerImage,
-                                   copySize, kColorFormat) /
+        utils::RequiredBytesInCopy(texelCopyBufferLayout.bytesPerRow,
+                                   texelCopyBufferLayout.rowsPerImage, copySize, kColorFormat) /
             sizeof(utils::RGBA8),
         {100, 100, 100, 100});
 
     // The write overwrites the whole texture so we don't need to do lazy initialization.
-    EXPECT_LAZY_CLEAR(
-        0u, queue.WriteTexture(&imageCopyTexture, data.data(), data.size() * sizeof(utils::RGBA8),
-                               &textureDataLayout, &copySize));
+    EXPECT_LAZY_CLEAR(0u, queue.WriteTexture(&texelCopyTextureInfo, data.data(),
+                                             data.size() * sizeof(utils::RGBA8),
+                                             &texelCopyBufferLayout, &copySize));
 
     // Expect texture initialized to be true
     EXPECT_TRUE(native::IsTextureSubresourceInitialized(texture.Get(), 0, 1, 0, 1));
@@ -1664,23 +1673,24 @@
                                 kColorFormat);
     wgpu::Texture texture = device.CreateTexture(&descriptor);
 
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize / 2, kSize, 1};
 
-    wgpu::TextureDataLayout textureDataLayout;
-    textureDataLayout.offset = 0;
-    textureDataLayout.bytesPerRow = kSize * kFormatBlockByteSize / 2;
-    textureDataLayout.rowsPerImage = kSize;
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout;
+    texelCopyBufferLayout.offset = 0;
+    texelCopyBufferLayout.bytesPerRow = kSize * kFormatBlockByteSize / 2;
+    texelCopyBufferLayout.rowsPerImage = kSize;
 
     std::vector<utils::RGBA8> data(
-        utils::RequiredBytesInCopy(textureDataLayout.bytesPerRow, textureDataLayout.rowsPerImage,
-                                   copySize, kColorFormat) /
+        utils::RequiredBytesInCopy(texelCopyBufferLayout.bytesPerRow,
+                                   texelCopyBufferLayout.rowsPerImage, copySize, kColorFormat) /
             sizeof(utils::RGBA8),
         {100, 100, 100, 100});
 
-    EXPECT_LAZY_CLEAR(
-        1u, queue.WriteTexture(&imageCopyTexture, data.data(), data.size() * sizeof(utils::RGBA8),
-                               &textureDataLayout, &copySize));
+    EXPECT_LAZY_CLEAR(1u, queue.WriteTexture(&texelCopyTextureInfo, data.data(),
+                                             data.size() * sizeof(utils::RGBA8),
+                                             &texelCopyBufferLayout, &copySize));
 
     // Expect texture initialized to be true
     EXPECT_EQ(true, native::IsTextureSubresourceInitialized(texture.Get(), 0, 1, 0, 1));
@@ -1702,26 +1712,26 @@
     constexpr uint32_t kBaseArrayLayer = 2u;
     constexpr uint32_t kCopyLayerCount = 3u;
 
-    wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(texture, 0, {0, 0, kBaseArrayLayer});
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, kBaseArrayLayer});
     wgpu::Extent3D copySize = {kSize, kSize, kCopyLayerCount};
 
-    wgpu::TextureDataLayout textureDataLayout;
-    textureDataLayout.offset = 0;
-    textureDataLayout.bytesPerRow = kSize * kFormatBlockByteSize;
-    textureDataLayout.rowsPerImage = kSize;
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout;
+    texelCopyBufferLayout.offset = 0;
+    texelCopyBufferLayout.bytesPerRow = kSize * kFormatBlockByteSize;
+    texelCopyBufferLayout.rowsPerImage = kSize;
 
     std::vector<utils::RGBA8> data(
-        utils::RequiredBytesInCopy(textureDataLayout.bytesPerRow, textureDataLayout.rowsPerImage,
-                                   copySize, kColorFormat) /
+        utils::RequiredBytesInCopy(texelCopyBufferLayout.bytesPerRow,
+                                   texelCopyBufferLayout.rowsPerImage, copySize, kColorFormat) /
             sizeof(utils::RGBA8),
         {100, 100, 100, 100});
 
     // The write overwrites the whole subresources so we don't need to do lazy initialization on
     // them.
-    EXPECT_LAZY_CLEAR(
-        0u, queue.WriteTexture(&imageCopyTexture, data.data(), data.size() * sizeof(utils::RGBA8),
-                               &textureDataLayout, &copySize));
+    EXPECT_LAZY_CLEAR(0u, queue.WriteTexture(&texelCopyTextureInfo, data.data(),
+                                             data.size() * sizeof(utils::RGBA8),
+                                             &texelCopyBufferLayout, &copySize));
 
     // Expect texture subresource initialized to be true
     EXPECT_TRUE(native::IsTextureSubresourceInitialized(texture.Get(), 0, 1, kBaseArrayLayer,
@@ -1745,24 +1755,24 @@
     constexpr uint32_t kBaseArrayLayer = 2u;
     constexpr uint32_t kCopyLayerCount = 3u;
 
-    wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(texture, 0, {0, 0, kBaseArrayLayer});
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, kBaseArrayLayer});
     wgpu::Extent3D copySize = {kSize / 2, kSize, kCopyLayerCount};
 
-    wgpu::TextureDataLayout textureDataLayout;
-    textureDataLayout.offset = 0;
-    textureDataLayout.bytesPerRow = kSize * kFormatBlockByteSize / 2;
-    textureDataLayout.rowsPerImage = kSize;
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout;
+    texelCopyBufferLayout.offset = 0;
+    texelCopyBufferLayout.bytesPerRow = kSize * kFormatBlockByteSize / 2;
+    texelCopyBufferLayout.rowsPerImage = kSize;
 
     std::vector<utils::RGBA8> data(
-        utils::RequiredBytesInCopy(textureDataLayout.bytesPerRow, textureDataLayout.rowsPerImage,
-                                   copySize, kColorFormat) /
+        utils::RequiredBytesInCopy(texelCopyBufferLayout.bytesPerRow,
+                                   texelCopyBufferLayout.rowsPerImage, copySize, kColorFormat) /
             sizeof(utils::RGBA8),
         {100, 100, 100, 100});
 
-    EXPECT_LAZY_CLEAR(
-        1u, queue.WriteTexture(&imageCopyTexture, data.data(), data.size() * sizeof(utils::RGBA8),
-                               &textureDataLayout, &copySize));
+    EXPECT_LAZY_CLEAR(1u, queue.WriteTexture(&texelCopyTextureInfo, data.data(),
+                                             data.size() * sizeof(utils::RGBA8),
+                                             &texelCopyBufferLayout, &copySize));
 
     // Expect texture subresource initialized to be true
     EXPECT_EQ(true, native::IsTextureSubresourceInitialized(texture.Get(), 0, 1, kBaseArrayLayer,
@@ -1786,25 +1796,25 @@
     constexpr uint32_t kMipLevel = 2;
     constexpr uint32_t kMipSize = kSize >> kMipLevel;
 
-    wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(texture, kMipLevel, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, kMipLevel, {0, 0, 0});
     wgpu::Extent3D copySize = {kMipSize, kMipSize, 1};
 
-    wgpu::TextureDataLayout textureDataLayout;
-    textureDataLayout.offset = 0;
-    textureDataLayout.bytesPerRow = kMipSize * kFormatBlockByteSize;
-    textureDataLayout.rowsPerImage = kMipSize;
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout;
+    texelCopyBufferLayout.offset = 0;
+    texelCopyBufferLayout.bytesPerRow = kMipSize * kFormatBlockByteSize;
+    texelCopyBufferLayout.rowsPerImage = kMipSize;
 
     std::vector<utils::RGBA8> data(
-        utils::RequiredBytesInCopy(textureDataLayout.bytesPerRow, textureDataLayout.rowsPerImage,
-                                   copySize, kColorFormat) /
+        utils::RequiredBytesInCopy(texelCopyBufferLayout.bytesPerRow,
+                                   texelCopyBufferLayout.rowsPerImage, copySize, kColorFormat) /
             sizeof(utils::RGBA8),
         {100, 100, 100, 100});
 
     // The write overwrites the whole texture so we don't need to do lazy initialization.
-    EXPECT_LAZY_CLEAR(
-        0u, queue.WriteTexture(&imageCopyTexture, data.data(), data.size() * sizeof(utils::RGBA8),
-                               &textureDataLayout, &copySize));
+    EXPECT_LAZY_CLEAR(0u, queue.WriteTexture(&texelCopyTextureInfo, data.data(),
+                                             data.size() * sizeof(utils::RGBA8),
+                                             &texelCopyBufferLayout, &copySize));
 
     // Expect texture initialized to be true
     EXPECT_TRUE(native::IsTextureSubresourceInitialized(texture.Get(), kMipLevel, 1, 0, 1));
@@ -1825,24 +1835,24 @@
     constexpr uint32_t kMipLevel = 2;
     constexpr uint32_t kMipSize = kSize >> kMipLevel;
 
-    wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(texture, kMipLevel, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(texture, kMipLevel, {0, 0, 0});
     wgpu::Extent3D copySize = {kMipSize / 2, kMipSize, 1};
 
-    wgpu::TextureDataLayout textureDataLayout;
-    textureDataLayout.offset = 0;
-    textureDataLayout.bytesPerRow = kMipSize * kFormatBlockByteSize / 2;
-    textureDataLayout.rowsPerImage = kMipSize;
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout;
+    texelCopyBufferLayout.offset = 0;
+    texelCopyBufferLayout.bytesPerRow = kMipSize * kFormatBlockByteSize / 2;
+    texelCopyBufferLayout.rowsPerImage = kMipSize;
 
     std::vector<utils::RGBA8> data(
-        utils::RequiredBytesInCopy(textureDataLayout.bytesPerRow, textureDataLayout.rowsPerImage,
-                                   copySize, kColorFormat) /
+        utils::RequiredBytesInCopy(texelCopyBufferLayout.bytesPerRow,
+                                   texelCopyBufferLayout.rowsPerImage, copySize, kColorFormat) /
             sizeof(utils::RGBA8),
         {100, 100, 100, 100});
 
-    EXPECT_LAZY_CLEAR(
-        1u, queue.WriteTexture(&imageCopyTexture, data.data(), data.size() * sizeof(utils::RGBA8),
-                               &textureDataLayout, &copySize));
+    EXPECT_LAZY_CLEAR(1u, queue.WriteTexture(&texelCopyTextureInfo, data.data(),
+                                             data.size() * sizeof(utils::RGBA8),
+                                             &texelCopyBufferLayout, &copySize));
 
     // Expect texture initialized to be true
     EXPECT_EQ(true, native::IsTextureSubresourceInitialized(texture.Get(), kMipLevel, 1, 0, 1));
@@ -1931,14 +1941,14 @@
         // Copy texture data from a staging buffer to the destination texture.
         wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(device, data.data(), data.size(),
                                                                  wgpu::BufferUsage::CopySrc);
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(stagingBuffer, 0, copyBytesPerRow, copyHeightInBlock);
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, copyBytesPerRow, copyHeightInBlock);
 
-        wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
             bcCompressedTexture, viewMipmapLevel, {0, 0, baseArrayLayer});
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &copyExtent3D);
+        encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &copyExtent3D);
         wgpu::CommandBuffer copy = encoder.Finish();
         EXPECT_LAZY_CLEAR(lazyClearCount, queue.Submit(1, &copy));
     }
@@ -2162,8 +2172,8 @@
     InitializeDataInCompressedTextureAndExpectLazyClear(srcTexture, srcDescriptor, copyExtent3D,
                                                         kViewMipLevel, 0, 0u);
 
-    wgpu::ImageCopyTexture srcImageCopyTexture =
-        utils::CreateImageCopyTexture(srcTexture, kViewMipLevel, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(srcTexture, kViewMipLevel, {0, 0, 0});
 
     // create dstTexture that we will copy to
     wgpu::TextureDescriptor dstDescriptor =
@@ -2173,11 +2183,11 @@
                                 utils::kBCFormats[0]);
     wgpu::Texture dstTexture = device.CreateTexture(&dstDescriptor);
 
-    wgpu::ImageCopyTexture dstImageCopyTexture =
-        utils::CreateImageCopyTexture(dstTexture, kViewMipLevel, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(dstTexture, kViewMipLevel, {0, 0, 0});
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &copyExtent3D);
+    encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &copyExtent3D);
     wgpu::CommandBuffer commands = encoder.Finish();
     // the dstTexture does not need to be lazy cleared since it's fully copied to
     EXPECT_LAZY_CLEAR(0u, queue.Submit(1, &commands));
@@ -2211,8 +2221,8 @@
     InitializeDataInCompressedTextureAndExpectLazyClear(srcTexture, srcDescriptor, copyExtent3D,
                                                         kViewMipLevel, 0, 1u);
 
-    wgpu::ImageCopyTexture srcImageCopyTexture =
-        utils::CreateImageCopyTexture(srcTexture, kViewMipLevel, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(srcTexture, kViewMipLevel, {0, 0, 0});
 
     // create dstTexture that we will copy to
     wgpu::TextureDescriptor dstDescriptor =
@@ -2222,11 +2232,11 @@
                                 utils::kBCFormats[0]);
     wgpu::Texture dstTexture = device.CreateTexture(&dstDescriptor);
 
-    wgpu::ImageCopyTexture dstImageCopyTexture =
-        utils::CreateImageCopyTexture(dstTexture, kViewMipLevel, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(dstTexture, kViewMipLevel, {0, 0, 0});
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-    encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &copyExtent3D);
+    encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &copyExtent3D);
     wgpu::CommandBuffer commands = encoder.Finish();
     // expect 1 lazy clear count since the dstTexture needs to be lazy cleared when we only copy to
     // half texture
@@ -2271,15 +2281,15 @@
     // Copy texture data from a staging buffer to the destination texture.
     wgpu::Buffer stagingBuffer =
         utils::CreateBufferFromData(device, data.data(), data.size(), wgpu::BufferUsage::CopySrc);
-    wgpu::ImageCopyBuffer imageCopyBufferSrc =
-        utils::CreateImageCopyBuffer(stagingBuffer, 0, copyBytesPerRow, copyRowsPerImage);
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfoSrc =
+        utils::CreateTexelCopyBufferInfo(stagingBuffer, 0, copyBytesPerRow, copyRowsPerImage);
 
-    wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(srcTexture, mipLevel, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(srcTexture, mipLevel, {0, 0, 0});
 
     {
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyBufferToTexture(&imageCopyBufferSrc, &imageCopyTexture, &copyExtent3D);
+        encoder.CopyBufferToTexture(&texelCopyBufferInfoSrc, &texelCopyTextureInfo, &copyExtent3D);
         wgpu::CommandBuffer copy = encoder.Finish();
         EXPECT_LAZY_CLEAR(0u, queue.Submit(1, &copy));
     }
@@ -2291,11 +2301,11 @@
     wgpu::Buffer readbackBuffer = device.CreateBuffer(&readbackDesc);
 
     // Copy the texture to the readback buffer.
-    wgpu::ImageCopyBuffer imageCopyBufferDst =
-        utils::CreateImageCopyBuffer(readbackBuffer, 0, copyBytesPerRow, copyRowsPerImage);
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfoDst =
+        utils::CreateTexelCopyBufferInfo(readbackBuffer, 0, copyBytesPerRow, copyRowsPerImage);
     {
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBufferDst, &copyExtent3D);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfoDst, &copyExtent3D);
         wgpu::CommandBuffer copy = encoder.Finish();
 
         // Expect a lazy clear because the padding in the copy is not touched.
diff --git a/src/dawn/tests/end2end/VideoViewsTests.cpp b/src/dawn/tests/end2end/VideoViewsTests.cpp
index 27bdcf1..6729be4 100644
--- a/src/dawn/tests/end2end/VideoViewsTests.cpp
+++ b/src/dawn/tests/end2end/VideoViewsTests.cpp
@@ -1281,9 +1281,11 @@
     wgpu::Texture srcTexture = platformTexture1->wgpuTexture;
     wgpu::Texture dstTexture = platformTexture2->wgpuTexture;
 
-    wgpu::ImageCopyTexture copySrc = utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo copySrc =
+        utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0});
 
-    wgpu::ImageCopyTexture copyDst = utils::CreateImageCopyTexture(dstTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo copyDst =
+        utils::CreateTexelCopyTextureInfo(dstTexture, 0, {0, 0, 0});
 
     wgpu::Extent3D copySize = {1, 1, 1};
 
@@ -1310,11 +1312,11 @@
     wgpu::Texture srcTexture = platformTexture1->wgpuTexture;
     wgpu::Texture dstTexture = platformTexture2->wgpuTexture;
 
-    wgpu::ImageCopyTexture copySrc =
-        utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
+    wgpu::TexelCopyTextureInfo copySrc = utils::CreateTexelCopyTextureInfo(
+        srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
 
-    wgpu::ImageCopyTexture copyDst =
-        utils::CreateImageCopyTexture(dstTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane1Only);
+    wgpu::TexelCopyTextureInfo copyDst = utils::CreateTexelCopyTextureInfo(
+        dstTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane1Only);
 
     wgpu::Extent3D copySize = {1, 1, 1};
 
@@ -1324,8 +1326,8 @@
         ASSERT_DEVICE_ERROR(encoder.Finish());
     }
 
-    copySrc =
-        utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane1Only);
+    copySrc = utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0},
+                                                wgpu::TextureAspect::Plane1Only);
 
     {
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -1350,9 +1352,10 @@
     bufferDescriptor.usage = wgpu::BufferUsage::CopyDst;
     wgpu::Buffer dstBuffer = device.CreateBuffer(&bufferDescriptor);
 
-    wgpu::ImageCopyTexture copySrc = utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo copySrc =
+        utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0});
 
-    wgpu::ImageCopyBuffer copyDst = utils::CreateImageCopyBuffer(dstBuffer, 0, 256);
+    wgpu::TexelCopyBufferInfo copyDst = utils::CreateTexelCopyBufferInfo(dstBuffer, 0, 256);
 
     wgpu::Extent3D copySize = {1, 1, 1};
 
@@ -1376,10 +1379,10 @@
     bufferDescriptor.usage = wgpu::BufferUsage::CopyDst;
     wgpu::Buffer dstBuffer = device.CreateBuffer(&bufferDescriptor);
 
-    wgpu::ImageCopyTexture copySrc =
-        utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
+    wgpu::TexelCopyTextureInfo copySrc = utils::CreateTexelCopyTextureInfo(
+        srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
 
-    wgpu::ImageCopyBuffer copyDst = utils::CreateImageCopyBuffer(dstBuffer, 0, 256);
+    wgpu::TexelCopyBufferInfo copyDst = utils::CreateTexelCopyBufferInfo(dstBuffer, 0, 256);
 
     wgpu::Extent3D copySize = {1, 1, 1};
 
@@ -1389,8 +1392,8 @@
         ASSERT_DEVICE_ERROR(encoder.Finish());
     }
 
-    copySrc =
-        utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane1Only);
+    copySrc = utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0},
+                                                wgpu::TextureAspect::Plane1Only);
 
     {
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -1414,9 +1417,10 @@
     wgpu::Buffer srcBuffer = utils::CreateBufferFromData(
         device, placeholderData.data(), placeholderData.size(), wgpu::BufferUsage::CopySrc);
 
-    wgpu::ImageCopyBuffer copySrc = utils::CreateImageCopyBuffer(srcBuffer, 0, 12, 4);
+    wgpu::TexelCopyBufferInfo copySrc = utils::CreateTexelCopyBufferInfo(srcBuffer, 0, 12, 4);
 
-    wgpu::ImageCopyTexture copyDst = utils::CreateImageCopyTexture(dstTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo copyDst =
+        utils::CreateTexelCopyTextureInfo(dstTexture, 0, {0, 0, 0});
 
     wgpu::Extent3D copySize = {1, 1, 1};
 
@@ -1440,10 +1444,10 @@
     wgpu::Buffer srcBuffer = utils::CreateBufferFromData(
         device, placeholderData.data(), placeholderData.size(), wgpu::BufferUsage::CopySrc);
 
-    wgpu::ImageCopyBuffer copySrc = utils::CreateImageCopyBuffer(srcBuffer, 0, 12, 4);
+    wgpu::TexelCopyBufferInfo copySrc = utils::CreateTexelCopyBufferInfo(srcBuffer, 0, 12, 4);
 
-    wgpu::ImageCopyTexture copyDst =
-        utils::CreateImageCopyTexture(dstTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
+    wgpu::TexelCopyTextureInfo copyDst = utils::CreateTexelCopyTextureInfo(
+        dstTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
 
     wgpu::Extent3D copySize = {1, 1, 1};
 
@@ -1453,8 +1457,8 @@
         ASSERT_DEVICE_ERROR(encoder.Finish());
     }
 
-    copyDst =
-        utils::CreateImageCopyTexture(dstTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane1Only);
+    copyDst = utils::CreateTexelCopyTextureInfo(dstTexture, 0, {0, 0, 0},
+                                                wgpu::TextureAspect::Plane1Only);
 
     {
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -1512,18 +1516,19 @@
                                             /*isCheckerboard*/ true,
                                             /*initialized*/ true);
 
-    wgpu::TextureDataLayout textureDataLayout = utils::CreateTextureDataLayout(0, 4, 4);
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout = utils::CreateTexelCopyBufferLayout(0, 4, 4);
 
-    wgpu::ImageCopyTexture imageCopyTexture =
-        utils::CreateImageCopyTexture(platformTexture->wgpuTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(platformTexture->wgpuTexture, 0, {0, 0, 0});
 
     std::vector<uint8_t> placeholderData(4, 0);
     wgpu::Extent3D writeSize = {1, 1, 1};
 
     wgpu::Queue queue = device.GetQueue();
 
-    ASSERT_DEVICE_ERROR(queue.WriteTexture(&imageCopyTexture, placeholderData.data(),
-                                           placeholderData.size(), &textureDataLayout, &writeSize));
+    ASSERT_DEVICE_ERROR(queue.WriteTexture(&texelCopyTextureInfo, placeholderData.data(),
+                                           placeholderData.size(), &texelCopyBufferLayout,
+                                           &writeSize));
     mBackend->DestroyVideoTextureForTest(std::move(platformTexture));
 }
 
@@ -1534,8 +1539,9 @@
                                             /*isCheckerboard*/ true,
                                             /*initialized*/ true);
 
-    wgpu::TextureDataLayout textureDataLayout = utils::CreateTextureDataLayout(0, 12, 4);
-    wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+        utils::CreateTexelCopyBufferLayout(0, 12, 4);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo = utils::CreateTexelCopyTextureInfo(
         platformTexture->wgpuTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
 
     std::vector<uint8_t> placeholderData(4, 0);
@@ -1543,8 +1549,9 @@
 
     wgpu::Queue queue = device.GetQueue();
 
-    ASSERT_DEVICE_ERROR(queue.WriteTexture(&imageCopyTexture, placeholderData.data(),
-                                           placeholderData.size(), &textureDataLayout, &writeSize));
+    ASSERT_DEVICE_ERROR(queue.WriteTexture(&texelCopyTextureInfo, placeholderData.data(),
+                                           placeholderData.size(), &texelCopyBufferLayout,
+                                           &writeSize));
     mBackend->DestroyVideoTextureForTest(std::move(platformTexture));
 }
 
@@ -1585,12 +1592,13 @@
         std::vector<T> planeSrcData = VideoViewsTestsBase::GetTestTextureDataWithPlaneIndex<T>(
             format, planeIndex, kTextureBytesPerRowAlignment,
             kYUVAImageDataHeightInTexels / subsampleFactor.verticalFactor, false, hasAlpha);
-        wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(planeTexture);
-        wgpu::TextureDataLayout textureDataLayout =
-            utils::CreateTextureDataLayout(0, kTextureBytesPerRowAlignment);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(planeTexture);
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+            utils::CreateTexelCopyBufferLayout(0, kTextureBytesPerRowAlignment);
         wgpu::Queue queue = device.GetQueue();
-        queue.WriteTexture(&imageCopyTexture, planeSrcData.data(), planeSrcData.size() * sizeof(T),
-                           &textureDataLayout, &size);
+        queue.WriteTexture(&texelCopyTextureInfo, planeSrcData.data(),
+                           planeSrcData.size() * sizeof(T), &texelCopyBufferLayout, &size);
 
         return planeTexture;
     }
@@ -1822,12 +1830,13 @@
             std::vector<T> planeSrcData = VideoViewsTestsBase::GetTestTextureDataWithPlaneIndex<T>(
                 format, planeIndex, bytesPerRow,
                 kYUVAImageDataHeightInTexels / subsampleFactor.verticalFactor, false, hasAlpha);
-            wgpu::ImageCopyTexture imageCopyTexture = utils::CreateImageCopyTexture(planeTexture);
-            wgpu::TextureDataLayout textureDataLayout =
-                utils::CreateTextureDataLayout(0, bytesPerRow);
+            wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+                utils::CreateTexelCopyTextureInfo(planeTexture);
+            wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+                utils::CreateTexelCopyBufferLayout(0, bytesPerRow);
             wgpu::Queue queue = device.GetQueue();
-            queue.WriteTexture(&imageCopyTexture, planeSrcData.data(),
-                               planeSrcData.size() * sizeof(T), &textureDataLayout, &size);
+            queue.WriteTexture(&texelCopyTextureInfo, planeSrcData.data(),
+                               planeSrcData.size() * sizeof(T), &texelCopyBufferLayout, &size);
 
             return planeTexture;
         };
@@ -2243,8 +2252,8 @@
 
                 bytesPerRow = Align(bytesPerRow, 256);
 
-                wgpu::ImageCopyTexture copyDst =
-                    utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
+                wgpu::TexelCopyTextureInfo copyDst =
+                    utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
                 copyDst.aspect = VideoViewsTestsBase::GetPlaneAspect(plane);
 
                 wgpu::Extent3D copySize{VideoViewsTestsBase::kYUVAImageDataWidthInTexels /
@@ -2270,8 +2279,8 @@
                 memcpy(buffer.GetMappedRange(), data.data(), bufferDesc.size);
                 buffer.Unmap();
 
-                wgpu::ImageCopyBuffer copySrc =
-                    utils::CreateImageCopyBuffer(buffer, 0, bytesPerRow);
+                wgpu::TexelCopyBufferInfo copySrc =
+                    utils::CreateTexelCopyBufferInfo(buffer, 0, bytesPerRow);
 
                 encoder.CopyBufferToTexture(&copySrc, &copyDst, &copySize);
             }  // for plane
@@ -2555,15 +2564,15 @@
     bufferDescriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
     wgpu::Buffer dstBuffer = device.CreateBuffer(&bufferDescriptor);
 
-    wgpu::ImageCopyBuffer copyDst = utils::CreateImageCopyBuffer(dstBuffer, 0, 256);
+    wgpu::TexelCopyBufferInfo copyDst = utils::CreateTexelCopyBufferInfo(dstBuffer, 0, 256);
 
     wgpu::Extent3D copySize = {1, 1, 1};
 
     const bool hasAlpha = utils::GetMultiPlaneTextureNumPlanes(GetFormat()) > 2;
 
     // Plane0
-    wgpu::ImageCopyTexture copySrc =
-        utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
+    wgpu::TexelCopyTextureInfo copySrc = utils::CreateTexelCopyTextureInfo(
+        srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
 
     {
         auto subsampleFactor =
@@ -2589,8 +2598,8 @@
     }
 
     // Plane1
-    copySrc =
-        utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane1Only);
+    copySrc = utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0},
+                                                wgpu::TextureAspect::Plane1Only);
     {
         auto subsampleFactor =
             utils::GetMultiPlaneTextureSubsamplingFactor(GetFormat(), kYUVAChromaPlaneIndex);
@@ -2616,8 +2625,8 @@
 
     if (hasAlpha) {
         // Plane2
-        copySrc = utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0},
-                                                wgpu::TextureAspect::Plane2Only);
+        copySrc = utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0},
+                                                    wgpu::TextureAspect::Plane2Only);
         {
             auto subsampleFactor =
                 utils::GetMultiPlaneTextureSubsamplingFactor(GetFormat(), kYUVAAlphaPlaneIndex);
@@ -2659,10 +2668,10 @@
     bufferDescriptor.usage = wgpu::BufferUsage::CopyDst;
     wgpu::Buffer dstBuffer = device.CreateBuffer(&bufferDescriptor);
 
-    wgpu::ImageCopyTexture copySrc =
-        utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::All);
+    wgpu::TexelCopyTextureInfo copySrc =
+        utils::CreateTexelCopyTextureInfo(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::All);
 
-    wgpu::ImageCopyBuffer copyDst = utils::CreateImageCopyBuffer(dstBuffer, 0, 256);
+    wgpu::TexelCopyBufferInfo copyDst = utils::CreateTexelCopyBufferInfo(dstBuffer, 0, 256);
 
     wgpu::Extent3D copySize = {1, 1, 1};
 
@@ -2687,11 +2696,11 @@
                                  /*isCheckerboard*/ false,
                                  /*initialized*/ true);
 
-    wgpu::ImageCopyTexture copySrc =
-        utils::CreateImageCopyTexture(srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
+    wgpu::TexelCopyTextureInfo copySrc = utils::CreateTexelCopyTextureInfo(
+        srcTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
 
-    wgpu::ImageCopyTexture copyDst =
-        utils::CreateImageCopyTexture(dstTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
+    wgpu::TexelCopyTextureInfo copyDst = utils::CreateTexelCopyTextureInfo(
+        dstTexture, 0, {0, 0, 0}, wgpu::TextureAspect::Plane0Only);
 
     wgpu::Extent3D copySize = {1, 1, 1};
 
diff --git a/src/dawn/tests/perf_tests/SubresourceTrackingPerf.cpp b/src/dawn/tests/perf_tests/SubresourceTrackingPerf.cpp
index 9ce3bde..ef9ded8 100644
--- a/src/dawn/tests/perf_tests/SubresourceTrackingPerf.cpp
+++ b/src/dawn/tests/perf_tests/SubresourceTrackingPerf.cpp
@@ -108,10 +108,10 @@
 
         // Copy into the layer of the material array.
         {
-            wgpu::ImageCopyTexture sourceView;
+            wgpu::TexelCopyTextureInfo sourceView;
             sourceView.texture = mUploadTexture;
 
-            wgpu::ImageCopyTexture destView;
+            wgpu::TexelCopyTextureInfo destView;
             destView.texture = mMaterials;
             destView.origin.z = layerUploaded;
 
diff --git a/src/dawn/tests/unittests/native/AllowedErrorTests.cpp b/src/dawn/tests/unittests/native/AllowedErrorTests.cpp
index b9ac911..c3fcfec 100644
--- a/src/dawn/tests/unittests/native/AllowedErrorTests.cpp
+++ b/src/dawn/tests/unittests/native/AllowedErrorTests.cpp
@@ -131,9 +131,9 @@
         .Times(1);
 
     constexpr uint8_t data[] = {1, 2, 4, 8};
-    wgpu::ImageCopyTexture dest = {};
+    wgpu::TexelCopyTextureInfo dest = {};
     dest.texture = texture;
-    wgpu::TextureDataLayout layout = {};
+    wgpu::TexelCopyBufferLayout layout = {};
     wgpu::Extent3D size = {1, 1};
     device.GetQueue().WriteTexture(&dest, &data, 4, &layout, &size);
 }
@@ -147,9 +147,9 @@
                  wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::TextureBinding;
     desc.format = wgpu::TextureFormat::RGBA8Unorm;
 
-    wgpu::ImageCopyTexture src = {};
+    wgpu::TexelCopyTextureInfo src = {};
     src.texture = device.CreateTexture(&desc);
-    wgpu::ImageCopyTexture dst = {};
+    wgpu::TexelCopyTextureInfo dst = {};
     dst.texture = device.CreateTexture(&desc);
     wgpu::Extent3D size = {4, 4};
     wgpu::CopyTextureForBrowserOptions options = {};
@@ -191,7 +191,7 @@
     wgpu::ImageCopyExternalTexture src = {};
     src.externalTexture = device.CreateExternalTexture(&externalTextureDesc);
     src.naturalSize = {4, 4};
-    wgpu::ImageCopyTexture dst = {};
+    wgpu::TexelCopyTextureInfo dst = {};
     dst.texture = device.CreateTexture(&textureDesc);
     wgpu::Extent3D size = {4, 4};
     wgpu::CopyTextureForBrowserOptions options = {};
diff --git a/src/dawn/tests/unittests/native/mocks/DeviceMock.h b/src/dawn/tests/unittests/native/mocks/DeviceMock.h
index 47ba449..c9488b5 100644
--- a/src/dawn/tests/unittests/native/mocks/DeviceMock.h
+++ b/src/dawn/tests/unittests/native/mocks/DeviceMock.h
@@ -67,10 +67,11 @@
                 CopyFromStagingToBufferImpl,
                 (BufferBase*, uint64_t, BufferBase*, uint64_t, uint64_t),
                 (override));
-    MOCK_METHOD(MaybeError,
-                CopyFromStagingToTextureImpl,
-                (const BufferBase*, const TextureDataLayout&, const TextureCopy&, const Extent3D&),
-                (override));
+    MOCK_METHOD(
+        MaybeError,
+        CopyFromStagingToTextureImpl,
+        (const BufferBase*, const TexelCopyBufferLayout&, const TextureCopy&, const Extent3D&),
+        (override));
 
     MOCK_METHOD(uint32_t, GetOptimalBytesPerRowAlignment, (), (const, override));
     MOCK_METHOD(uint64_t, GetOptimalBufferToTextureCopyOffsetAlignment, (), (const, override));
diff --git a/src/dawn/tests/unittests/native/mocks/QueueMock.h b/src/dawn/tests/unittests/native/mocks/QueueMock.h
index 4f945bd..3d961c0 100644
--- a/src/dawn/tests/unittests/native/mocks/QueueMock.h
+++ b/src/dawn/tests/unittests/native/mocks/QueueMock.h
@@ -46,11 +46,14 @@
                 WriteBufferImpl,
                 (BufferBase*, uint64_t, const void*, size_t),
                 (override));
-    MOCK_METHOD(
-        MaybeError,
-        WriteTextureImpl,
-        (const ImageCopyTexture&, const void*, size_t, const TextureDataLayout&, const Extent3D&),
-        (override));
+    MOCK_METHOD(MaybeError,
+                WriteTextureImpl,
+                (const TexelCopyTextureInfo&,
+                 const void*,
+                 size_t,
+                 const TexelCopyBufferLayout&,
+                 const Extent3D&),
+                (override));
     MOCK_METHOD(void, DestroyImpl, (), (override));
 
     MOCK_METHOD(ResultOrError<ExecutionSerial>, CheckAndUpdateCompletedSerials, (), (override));
diff --git a/src/dawn/tests/unittests/validation/CompatValidationTests.cpp b/src/dawn/tests/unittests/validation/CompatValidationTests.cpp
index 9bf7cdd..4b3c0e3 100644
--- a/src/dawn/tests/unittests/validation/CompatValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/CompatValidationTests.cpp
@@ -1542,8 +1542,8 @@
     dstDescriptor.sampleCount = 4;
     wgpu::Texture dstTexture = device.CreateTexture(&dstDescriptor);
 
-    wgpu::ImageCopyTexture source = utils::CreateImageCopyTexture(srcTexture);
-    wgpu::ImageCopyTexture destination = utils::CreateImageCopyTexture(dstTexture);
+    wgpu::TexelCopyTextureInfo source = utils::CreateTexelCopyTextureInfo(srcTexture);
+    wgpu::TexelCopyTextureInfo destination = utils::CreateTexelCopyTextureInfo(dstTexture);
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
     encoder.CopyTextureToTexture(&source, &destination, &srcDescriptor.size);
@@ -1829,8 +1829,8 @@
         bufferDescriptor.usage = wgpu::BufferUsage::CopyDst;
         wgpu::Buffer buffer = device.CreateBuffer(&bufferDescriptor);
 
-        wgpu::ImageCopyTexture source = utils::CreateImageCopyTexture(texture);
-        wgpu::ImageCopyBuffer destination = utils::CreateImageCopyBuffer(buffer, 0, 256, 4);
+        wgpu::TexelCopyTextureInfo source = utils::CreateTexelCopyTextureInfo(texture);
+        wgpu::TexelCopyBufferInfo destination = utils::CreateTexelCopyBufferInfo(buffer, 0, 256, 4);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         encoder.CopyTextureToBuffer(&source, &destination, &descriptor.size);
@@ -1854,8 +1854,8 @@
         descriptor.usage = wgpu::TextureUsage::TextureBinding | wgpu::TextureUsage::CopyDst;
         wgpu::Texture dstTexture = device.CreateTexture(&descriptor);
 
-        wgpu::ImageCopyTexture source = utils::CreateImageCopyTexture(srcTexture);
-        wgpu::ImageCopyTexture destination = utils::CreateImageCopyTexture(dstTexture);
+        wgpu::TexelCopyTextureInfo source = utils::CreateTexelCopyTextureInfo(srcTexture);
+        wgpu::TexelCopyTextureInfo destination = utils::CreateTexelCopyTextureInfo(dstTexture);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         encoder.CopyTextureToTexture(&source, &destination, &descriptor.size);
diff --git a/src/dawn/tests/unittests/validation/CopyCommandsValidationTests.cpp b/src/dawn/tests/unittests/validation/CopyCommandsValidationTests.cpp
index 23bba66..7a2d7c7 100644
--- a/src/dawn/tests/unittests/validation/CopyCommandsValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/CopyCommandsValidationTests.cpp
@@ -115,13 +115,13 @@
                      wgpu::Origin3D destOrigin,
                      wgpu::Extent3D extent3D,
                      wgpu::TextureAspect aspect = wgpu::TextureAspect::All) {
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(srcBuffer, srcOffset, srcBytesPerRow, srcRowsPerImage);
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(destTexture, destLevel, destOrigin, aspect);
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(srcBuffer, srcOffset, srcBytesPerRow, srcRowsPerImage);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(destTexture, destLevel, destOrigin, aspect);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyBufferToTexture(&imageCopyBuffer, &imageCopyTexture, &extent3D);
+        encoder.CopyBufferToTexture(&texelCopyBufferInfo, &texelCopyTextureInfo, &extent3D);
 
         ValidateExpectation(encoder, expectation);
     }
@@ -136,13 +136,13 @@
                      uint32_t destRowsPerImage,
                      wgpu::Extent3D extent3D,
                      wgpu::TextureAspect aspect = wgpu::TextureAspect::All) {
-        wgpu::ImageCopyBuffer imageCopyBuffer =
-            utils::CreateImageCopyBuffer(destBuffer, destOffset, destBytesPerRow, destRowsPerImage);
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(srcTexture, srcLevel, srcOrigin, aspect);
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo = utils::CreateTexelCopyBufferInfo(
+            destBuffer, destOffset, destBytesPerRow, destRowsPerImage);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(srcTexture, srcLevel, srcOrigin, aspect);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &imageCopyBuffer, &extent3D);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &texelCopyBufferInfo, &extent3D);
 
         ValidateExpectation(encoder, expectation);
     }
@@ -156,13 +156,13 @@
                      wgpu::Origin3D dstOrigin,
                      wgpu::Extent3D extent3D,
                      wgpu::TextureAspect aspect = wgpu::TextureAspect::All) {
-        wgpu::ImageCopyTexture srcImageCopyTexture =
-            utils::CreateImageCopyTexture(srcTexture, srcLevel, srcOrigin, aspect);
-        wgpu::ImageCopyTexture dstImageCopyTexture =
-            utils::CreateImageCopyTexture(dstTexture, dstLevel, dstOrigin, aspect);
+        wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(srcTexture, srcLevel, srcOrigin, aspect);
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dstTexture, dstLevel, dstOrigin, aspect);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &extent3D);
+        encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &extent3D);
 
         ValidateExpectation(encoder, expectation);
     }
@@ -780,20 +780,21 @@
     errorTextureDescriptor.size.depthOrArrayLayers = 0;
     ASSERT_DEVICE_ERROR(wgpu::Texture errorTexture = device.CreateTexture(&errorTextureDescriptor));
 
-    wgpu::ImageCopyBuffer errorImageCopyBuffer = utils::CreateImageCopyBuffer(errorBuffer, 0, 0, 0);
-    wgpu::ImageCopyTexture errorImageCopyTexture =
-        utils::CreateImageCopyTexture(errorTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo errorTexelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(errorBuffer, 0, 0, 0);
+    wgpu::TexelCopyTextureInfo errorTexelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(errorTexture, 0, {0, 0, 0});
 
     wgpu::Extent3D extent3D = {0, 0, 0};
 
     {
         wgpu::Texture destination = Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm,
                                                     wgpu::TextureUsage::CopyDst);
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(destination, 0, {0, 0, 0});
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(destination, 0, {0, 0, 0});
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyBufferToTexture(&errorImageCopyBuffer, &imageCopyTexture, &extent3D);
+        encoder.CopyBufferToTexture(&errorTexelCopyBufferInfo, &texelCopyTextureInfo, &extent3D);
         ASSERT_DEVICE_ERROR(encoder.Finish());
     }
 
@@ -801,10 +802,11 @@
         uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
         wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc);
 
-        wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(source, 0, 0, 0);
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(source, 0, 0, 0);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyBufferToTexture(&imageCopyBuffer, &errorImageCopyTexture, &extent3D);
+        encoder.CopyBufferToTexture(&texelCopyBufferInfo, &errorTexelCopyTextureInfo, &extent3D);
         ASSERT_DEVICE_ERROR(encoder.Finish());
     }
 }
@@ -1413,9 +1415,10 @@
     errorTextureDescriptor.size.depthOrArrayLayers = 0;
     ASSERT_DEVICE_ERROR(wgpu::Texture errorTexture = device.CreateTexture(&errorTextureDescriptor));
 
-    wgpu::ImageCopyBuffer errorImageCopyBuffer = utils::CreateImageCopyBuffer(errorBuffer, 0, 0, 0);
-    wgpu::ImageCopyTexture errorImageCopyTexture =
-        utils::CreateImageCopyTexture(errorTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo errorTexelCopyBufferInfo =
+        utils::CreateTexelCopyBufferInfo(errorBuffer, 0, 0, 0);
+    wgpu::TexelCopyTextureInfo errorTexelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(errorTexture, 0, {0, 0, 0});
 
     wgpu::Extent3D extent3D = {0, 0, 0};
 
@@ -1423,21 +1426,22 @@
         uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
         wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc);
 
-        wgpu::ImageCopyBuffer imageCopyBuffer = utils::CreateImageCopyBuffer(source, 0, 0, 0);
+        wgpu::TexelCopyBufferInfo texelCopyBufferInfo =
+            utils::CreateTexelCopyBufferInfo(source, 0, 0, 0);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyTextureToBuffer(&errorImageCopyTexture, &imageCopyBuffer, &extent3D);
+        encoder.CopyTextureToBuffer(&errorTexelCopyTextureInfo, &texelCopyBufferInfo, &extent3D);
         ASSERT_DEVICE_ERROR(encoder.Finish());
     }
 
     {
         wgpu::Texture destination = Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm,
                                                     wgpu::TextureUsage::CopyDst);
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(destination, 0, {0, 0, 0});
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(destination, 0, {0, 0, 0});
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyTextureToBuffer(&imageCopyTexture, &errorImageCopyBuffer, &extent3D);
+        encoder.CopyTextureToBuffer(&texelCopyTextureInfo, &errorTexelCopyBufferInfo, &extent3D);
         ASSERT_DEVICE_ERROR(encoder.Finish());
     }
 }
@@ -1726,13 +1730,13 @@
         TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 1}, destination, 0, {0, 0, 1},
                     {16, 16, 1});
 
-        // Copy multiple slices (srcImageCopyTexture.arrayLayer + copySize.depthOrArrayLayers ==
-        // srcImageCopyTexture.texture.arrayLayerCount)
+        // Copy multiple slices (srcTexelCopyTextureInfo.arrayLayer + copySize.depthOrArrayLayers ==
+        // srcTexelCopyTextureInfo.texture.arrayLayerCount)
         TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 2}, destination, 0, {0, 0, 0},
                     {16, 16, 2});
 
-        // Copy multiple slices (dstImageCopyTexture.arrayLayer + copySize.depthOrArrayLayers ==
-        // dstImageCopyTexture.texture.arrayLayerCount)
+        // Copy multiple slices (dstTexelCopyTextureInfo.arrayLayer + copySize.depthOrArrayLayers ==
+        // dstTexelCopyTextureInfo.texture.arrayLayerCount)
         TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, {0, 0, 2},
                     {16, 16, 2});
     }
diff --git a/src/dawn/tests/unittests/validation/CopyTextureForBrowserTests.cpp b/src/dawn/tests/unittests/validation/CopyTextureForBrowserTests.cpp
index 62a9e93..af9114a 100644
--- a/src/dawn/tests/unittests/validation/CopyTextureForBrowserTests.cpp
+++ b/src/dawn/tests/unittests/validation/CopyTextureForBrowserTests.cpp
@@ -100,17 +100,17 @@
                                    wgpu::Extent3D extent3D,
                                    wgpu::TextureAspect aspect = wgpu::TextureAspect::All,
                                    wgpu::CopyTextureForBrowserOptions options = {}) {
-        wgpu::ImageCopyTexture srcImageCopyTexture =
-            utils::CreateImageCopyTexture(srcTexture, srcLevel, srcOrigin, aspect);
-        wgpu::ImageCopyTexture dstImageCopyTexture =
-            utils::CreateImageCopyTexture(dstTexture, dstLevel, dstOrigin, aspect);
+        wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(srcTexture, srcLevel, srcOrigin, aspect);
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dstTexture, dstLevel, dstOrigin, aspect);
 
         if (expectation == utils::Expectation::Success) {
-            device.GetQueue().CopyTextureForBrowser(&srcImageCopyTexture, &dstImageCopyTexture,
-                                                    &extent3D, &options);
+            device.GetQueue().CopyTextureForBrowser(&srcTexelCopyTextureInfo,
+                                                    &dstTexelCopyTextureInfo, &extent3D, &options);
         } else {
             ASSERT_DEVICE_ERROR(device.GetQueue().CopyTextureForBrowser(
-                &srcImageCopyTexture, &dstImageCopyTexture, &extent3D, &options));
+                &srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &extent3D, &options));
         }
     }
 };
@@ -139,15 +139,15 @@
         srcImageCopyExternalTexture.origin = srcOrigin;
         srcImageCopyExternalTexture.naturalSize = srcNaturalSize;
 
-        wgpu::ImageCopyTexture dstImageCopyTexture =
-            utils::CreateImageCopyTexture(dstTexture, dstLevel, dstOrigin, aspect);
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dstTexture, dstLevel, dstOrigin, aspect);
 
         if (expectation == utils::Expectation::Success) {
             device.GetQueue().CopyExternalTextureForBrowser(
-                &srcImageCopyExternalTexture, &dstImageCopyTexture, &extent3D, &options);
+                &srcImageCopyExternalTexture, &dstTexelCopyTextureInfo, &extent3D, &options);
         } else {
             ASSERT_DEVICE_ERROR(device.GetQueue().CopyExternalTextureForBrowser(
-                &srcImageCopyExternalTexture, &dstImageCopyTexture, &extent3D, &options));
+                &srcImageCopyExternalTexture, &dstTexelCopyTextureInfo, &extent3D, &options));
         }
     }
 };
diff --git a/src/dawn/tests/unittests/validation/InternalUsageValidationTests.cpp b/src/dawn/tests/unittests/validation/InternalUsageValidationTests.cpp
index 4f3d3b8..eedcdd0 100644
--- a/src/dawn/tests/unittests/validation/InternalUsageValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/InternalUsageValidationTests.cpp
@@ -171,24 +171,27 @@
 
     // Control: src -> dst
     {
-        wgpu::ImageCopyTexture srcImageCopyTexture = utils::CreateImageCopyTexture(src, 0, {0, 0});
-        wgpu::ImageCopyTexture dstImageCopyTexture = utils::CreateImageCopyTexture(dst, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(src, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dst, 0, {0, 0});
         wgpu::Extent3D extent3D = {1, 1};
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &extent3D);
+        encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &extent3D);
         encoder.Finish();
     }
 
     // Invalid: src internal -> dst
     {
-        wgpu::ImageCopyTexture srcImageCopyTexture =
-            utils::CreateImageCopyTexture(srcInternal, 0, {0, 0});
-        wgpu::ImageCopyTexture dstImageCopyTexture = utils::CreateImageCopyTexture(dst, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(srcInternal, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dst, 0, {0, 0});
         wgpu::Extent3D extent3D = {1, 1};
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &extent3D);
+        encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &extent3D);
         ASSERT_DEVICE_ERROR(encoder.Finish());
     }
 }
@@ -231,32 +234,36 @@
 
     // Control: src -> dst
     {
-        wgpu::ImageCopyTexture srcImageCopyTexture = utils::CreateImageCopyTexture(src, 0, {0, 0});
-        wgpu::ImageCopyTexture dstImageCopyTexture = utils::CreateImageCopyTexture(dst, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(src, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dst, 0, {0, 0});
         wgpu::Extent3D extent3D = {1, 1};
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &extent3D);
+        encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &extent3D);
         encoder.Finish();
     }
 
     // Invalid: src internal -> dst
     {
-        wgpu::ImageCopyTexture srcImageCopyTexture =
-            utils::CreateImageCopyTexture(srcInternal, 0, {0, 0});
-        wgpu::ImageCopyTexture dstImageCopyTexture = utils::CreateImageCopyTexture(dst, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(srcInternal, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dst, 0, {0, 0});
         wgpu::Extent3D extent3D = {1, 1};
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
-        encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &extent3D);
+        encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &extent3D);
         ASSERT_DEVICE_ERROR(encoder.Finish());
     }
 
     // Invalid: src internal -> dst, with internal descriptor, but useInternalUsages set to false.
     {
-        wgpu::ImageCopyTexture srcImageCopyTexture =
-            utils::CreateImageCopyTexture(srcInternal, 0, {0, 0});
-        wgpu::ImageCopyTexture dstImageCopyTexture = utils::CreateImageCopyTexture(dst, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(srcInternal, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dst, 0, {0, 0});
         wgpu::Extent3D extent3D = {1, 1};
 
         wgpu::CommandEncoderDescriptor encoderDesc = {};
@@ -265,14 +272,16 @@
         encoderDesc.nextInChain = &encoderInternalDesc;
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder(&encoderDesc);
 
-        encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &extent3D);
+        encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &extent3D);
         ASSERT_DEVICE_ERROR(encoder.Finish());
     }
 
     // Control with internal copy: src -> dst
     {
-        wgpu::ImageCopyTexture srcImageCopyTexture = utils::CreateImageCopyTexture(src, 0, {0, 0});
-        wgpu::ImageCopyTexture dstImageCopyTexture = utils::CreateImageCopyTexture(dst, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(src, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dst, 0, {0, 0});
         wgpu::Extent3D extent3D = {1, 1};
 
         wgpu::CommandEncoderDescriptor encoderDesc = {};
@@ -281,15 +290,16 @@
         encoderDesc.nextInChain = &encoderInternalDesc;
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder(&encoderDesc);
 
-        encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &extent3D);
+        encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &extent3D);
         encoder.Finish();
     }
 
     // Valid with internal copy: src internal -> dst
     {
-        wgpu::ImageCopyTexture srcImageCopyTexture =
-            utils::CreateImageCopyTexture(srcInternal, 0, {0, 0});
-        wgpu::ImageCopyTexture dstImageCopyTexture = utils::CreateImageCopyTexture(dst, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo srcTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(srcInternal, 0, {0, 0});
+        wgpu::TexelCopyTextureInfo dstTexelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(dst, 0, {0, 0});
         wgpu::Extent3D extent3D = {1, 1};
 
         wgpu::CommandEncoderDescriptor encoderDesc = {};
@@ -298,7 +308,7 @@
         encoderDesc.nextInChain = &encoderInternalDesc;
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder(&encoderDesc);
 
-        encoder.CopyTextureToTexture(&srcImageCopyTexture, &dstImageCopyTexture, &extent3D);
+        encoder.CopyTextureToTexture(&srcTexelCopyTextureInfo, &dstTexelCopyTextureInfo, &extent3D);
         encoder.Finish();
     }
 }
diff --git a/src/dawn/tests/unittests/validation/QueueWriteTextureValidationTests.cpp b/src/dawn/tests/unittests/validation/QueueWriteTextureValidationTests.cpp
index 33dad3d..4a70af0 100644
--- a/src/dawn/tests/unittests/validation/QueueWriteTextureValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/QueueWriteTextureValidationTests.cpp
@@ -73,15 +73,16 @@
                           wgpu::TextureAspect aspect = wgpu::TextureAspect::All) {
         std::vector<uint8_t> data(dataSize);
 
-        wgpu::TextureDataLayout textureDataLayout;
-        textureDataLayout.offset = dataOffset;
-        textureDataLayout.bytesPerRow = dataBytesPerRow;
-        textureDataLayout.rowsPerImage = dataRowsPerImage;
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout;
+        texelCopyBufferLayout.offset = dataOffset;
+        texelCopyBufferLayout.bytesPerRow = dataBytesPerRow;
+        texelCopyBufferLayout.rowsPerImage = dataRowsPerImage;
 
-        wgpu::ImageCopyTexture imageCopyTexture =
-            utils::CreateImageCopyTexture(texture, texLevel, texOrigin, aspect);
+        wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+            utils::CreateTexelCopyTextureInfo(texture, texLevel, texOrigin, aspect);
 
-        queue.WriteTexture(&imageCopyTexture, data.data(), dataSize, &textureDataLayout, &size);
+        queue.WriteTexture(&texelCopyTextureInfo, data.data(), dataSize, &texelCopyBufferLayout,
+                           &size);
     }
 
     void TestWriteTextureExactDataSize(uint32_t bytesPerRow,
@@ -361,17 +362,18 @@
     wgpu::TextureDescriptor errorTextureDescriptor;
     errorTextureDescriptor.size.depthOrArrayLayers = 0;
     ASSERT_DEVICE_ERROR(wgpu::Texture errorTexture = device.CreateTexture(&errorTextureDescriptor));
-    wgpu::ImageCopyTexture errorImageCopyTexture =
-        utils::CreateImageCopyTexture(errorTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo errorTexelCopyTextureInfo =
+        utils::CreateTexelCopyTextureInfo(errorTexture, 0, {0, 0, 0});
 
     wgpu::Extent3D extent3D = {0, 0, 0};
 
     {
         std::vector<uint8_t> data(4);
-        wgpu::TextureDataLayout textureDataLayout = utils::CreateTextureDataLayout(0, 0, 0);
+        wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+            utils::CreateTexelCopyBufferLayout(0, 0, 0);
 
-        ASSERT_DEVICE_ERROR(queue.WriteTexture(&errorImageCopyTexture, data.data(), 4,
-                                               &textureDataLayout, &extent3D));
+        ASSERT_DEVICE_ERROR(queue.WriteTexture(&errorTexelCopyTextureInfo, data.data(), 4,
+                                               &texelCopyBufferLayout, &extent3D));
     }
 }
 
diff --git a/src/dawn/tests/unittests/validation/ResourceUsageTrackingTests.cpp b/src/dawn/tests/unittests/validation/ResourceUsageTrackingTests.cpp
index c0119d2..b19fc9e 100644
--- a/src/dawn/tests/unittests/validation/ResourceUsageTrackingTests.cpp
+++ b/src/dawn/tests/unittests/validation/ResourceUsageTrackingTests.cpp
@@ -1385,8 +1385,8 @@
     wgpu::TextureView view0 = texture0.CreateView();
     wgpu::TextureView view1 = texture1.CreateView();
 
-    wgpu::ImageCopyTexture srcView = utils::CreateImageCopyTexture(texture0, 0, {0, 0, 0});
-    wgpu::ImageCopyTexture dstView = utils::CreateImageCopyTexture(texture1, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo srcView = utils::CreateTexelCopyTextureInfo(texture0, 0, {0, 0, 0});
+    wgpu::TexelCopyTextureInfo dstView = utils::CreateTexelCopyTextureInfo(texture1, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {1, 1, 1};
 
     // Use the texture as both copy dst and render attachment in render pass
diff --git a/src/dawn/tests/white_box/SharedTextureMemoryTests.cpp b/src/dawn/tests/white_box/SharedTextureMemoryTests.cpp
index bd017dc..070abe5 100644
--- a/src/dawn/tests/white_box/SharedTextureMemoryTests.cpp
+++ b/src/dawn/tests/white_box/SharedTextureMemoryTests.cpp
@@ -327,7 +327,7 @@
 
 void SharedTextureMemoryTests::UseInCopy(wgpu::Device& deviceObj, wgpu::Texture& texture) {
     wgpu::CommandEncoder encoder = deviceObj.CreateCommandEncoder();
-    wgpu::ImageCopyTexture source;
+    wgpu::TexelCopyTextureInfo source;
     source.texture = texture;
 
     // Create a destination buffer, large enough for 1 texel of any format.
@@ -335,7 +335,7 @@
     bufferDesc.size = 128;
     bufferDesc.usage = wgpu::BufferUsage::CopyDst;
 
-    wgpu::ImageCopyBuffer destination;
+    wgpu::TexelCopyBufferInfo destination;
     destination.buffer = deviceObj.CreateBuffer(&bufferDesc);
 
     wgpu::Extent3D size = {1, 1, 1};
@@ -514,10 +514,10 @@
 
     wgpu::Extent3D writeSize = {width, height, 1};
 
-    wgpu::ImageCopyTexture dest;
+    wgpu::TexelCopyTextureInfo dest;
     dest.texture = texture;
 
-    wgpu::TextureDataLayout dataLayout = {
+    wgpu::TexelCopyBufferLayout dataLayout = {
         .offset = 0, .bytesPerRow = bytesPerRow, .rowsPerImage = height};
 
     for (uint32_t layer = 0; layer < texture.GetDepthOrArrayLayers(); ++layer) {
@@ -919,9 +919,9 @@
             UseInCopy(device, texture);
         } else if (properties.usage & wgpu::TextureUsage::CopyDst) {
             wgpu::Extent3D writeSize = {1, 1, 1};
-            wgpu::ImageCopyTexture dest = {};
+            wgpu::TexelCopyTextureInfo dest = {};
             dest.texture = texture;
-            wgpu::TextureDataLayout dataLayout = {};
+            wgpu::TexelCopyBufferLayout dataLayout = {};
             uint64_t data[2];
             device.GetQueue().WriteTexture(&dest, &data, sizeof(data), &dataLayout, &writeSize);
         }
@@ -1531,9 +1531,9 @@
         }
         if (properties.usage & wgpu::TextureUsage::CopyDst) {
             wgpu::Extent3D writeSize = {1, 1, 1};
-            wgpu::ImageCopyTexture dest = {};
+            wgpu::TexelCopyTextureInfo dest = {};
             dest.texture = texture;
-            wgpu::TextureDataLayout dataLayout = {};
+            wgpu::TexelCopyBufferLayout dataLayout = {};
             uint64_t data[2];
             ASSERT_DEVICE_ERROR_MSG(
                 device.GetQueue().WriteTexture(&dest, &data, sizeof(data), &dataLayout, &writeSize),
@@ -1788,8 +1788,8 @@
         // Copy from the source texture into `texture`.
         {
             wgpu::CommandEncoder encoder = devices[0].CreateCommandEncoder();
-            auto src = utils::CreateImageCopyTexture(srcTex);
-            auto dst = utils::CreateImageCopyTexture(texture);
+            auto src = utils::CreateTexelCopyTextureInfo(srcTex);
+            auto dst = utils::CreateTexelCopyTextureInfo(texture);
             for (uint32_t layer = 0; layer < texture.GetDepthOrArrayLayers(); ++layer) {
                 dst.origin.z = layer;
                 encoder.CopyTextureToTexture(&src, &dst, &texDesc.size);
@@ -1889,8 +1889,8 @@
         // Copy from the source texture into `texture`.
         {
             wgpu::CommandEncoder encoder = devices[0].CreateCommandEncoder();
-            auto src = utils::CreateImageCopyTexture(srcTex);
-            auto dst = utils::CreateImageCopyTexture(texture);
+            auto src = utils::CreateTexelCopyTextureInfo(srcTex);
+            auto dst = utils::CreateTexelCopyTextureInfo(texture);
             for (uint32_t layer = 0; layer < texture.GetDepthOrArrayLayers(); ++layer) {
                 dst.origin.z = layer;
                 encoder.CopyTextureToTexture(&src, &dst, &texDesc.size);
@@ -1982,8 +1982,8 @@
         // Copy from the source texture into `texture`.
         {
             wgpu::CommandEncoder encoder = devices[0].CreateCommandEncoder();
-            auto src = utils::CreateImageCopyTexture(srcTex);
-            auto dst = utils::CreateImageCopyTexture(texture);
+            auto src = utils::CreateTexelCopyTextureInfo(srcTex);
+            auto dst = utils::CreateTexelCopyTextureInfo(texture);
             for (uint32_t layer = 0; layer < texture.GetDepthOrArrayLayers(); ++layer) {
                 dst.origin.z = layer;
                 encoder.CopyTextureToTexture(&src, &dst, &texDesc.size);
diff --git a/src/dawn/tests/white_box/VulkanImageWrappingTests.cpp b/src/dawn/tests/white_box/VulkanImageWrappingTests.cpp
index 25c1409..ffb0e52 100644
--- a/src/dawn/tests/white_box/VulkanImageWrappingTests.cpp
+++ b/src/dawn/tests/white_box/VulkanImageWrappingTests.cpp
@@ -368,8 +368,10 @@
                                     wgpu::Queue dawnQueue,
                                     wgpu::Texture source,
                                     wgpu::Texture destination) {
-        wgpu::ImageCopyTexture copySrc = utils::CreateImageCopyTexture(source, 0, {0, 0, 0});
-        wgpu::ImageCopyTexture copyDst = utils::CreateImageCopyTexture(destination, 0, {0, 0, 0});
+        wgpu::TexelCopyTextureInfo copySrc =
+            utils::CreateTexelCopyTextureInfo(source, 0, {0, 0, 0});
+        wgpu::TexelCopyTextureInfo copyDst =
+            utils::CreateTexelCopyTextureInfo(destination, 0, {0, 0, 0});
 
         wgpu::Extent3D copySize = {1, 1, 1};
 
@@ -581,9 +583,9 @@
     wgpu::Buffer copyDstBuffer = device.CreateBuffer(&bufferDesc);
 
     // Copy |deviceWrappedTexture| into |copyDstBuffer|
-    wgpu::ImageCopyTexture copySrc =
-        utils::CreateImageCopyTexture(deviceWrappedTexture, 0, {0, 0, 0});
-    wgpu::ImageCopyBuffer copyDst = utils::CreateImageCopyBuffer(copyDstBuffer, 0, 256);
+    wgpu::TexelCopyTextureInfo copySrc =
+        utils::CreateTexelCopyTextureInfo(deviceWrappedTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo copyDst = utils::CreateTexelCopyBufferInfo(copyDstBuffer, 0, 256);
 
     wgpu::Extent3D copySize = {1, 1, 1};
 
@@ -632,9 +634,9 @@
         utils::CreateBufferFromData(secondDevice, wgpu::BufferUsage::CopySrc, {0x04030201});
 
     // Copy |copySrcBuffer| into |secondDeviceWrappedTexture|
-    wgpu::ImageCopyBuffer copySrc = utils::CreateImageCopyBuffer(copySrcBuffer, 0, 256);
-    wgpu::ImageCopyTexture copyDst =
-        utils::CreateImageCopyTexture(secondDeviceWrappedTexture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferInfo copySrc = utils::CreateTexelCopyBufferInfo(copySrcBuffer, 0, 256);
+    wgpu::TexelCopyTextureInfo copyDst =
+        utils::CreateTexelCopyTextureInfo(secondDeviceWrappedTexture, 0, {0, 0, 0});
 
     wgpu::Extent3D copySize = {1, 1, 1};
 
@@ -834,9 +836,10 @@
     {
         wgpu::Buffer copySrcBuffer = utils::CreateBufferFromData(
             secondDevice, data.data(), data.size(), wgpu::BufferUsage::CopySrc);
-        wgpu::ImageCopyBuffer copySrc = utils::CreateImageCopyBuffer(copySrcBuffer, 0, bytesPerRow);
-        wgpu::ImageCopyTexture copyDst =
-            utils::CreateImageCopyTexture(wrappedTexture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo copySrc =
+            utils::CreateTexelCopyBufferInfo(copySrcBuffer, 0, bytesPerRow);
+        wgpu::TexelCopyTextureInfo copyDst =
+            utils::CreateTexelCopyTextureInfo(wrappedTexture, 0, {0, 0, 0});
         wgpu::Extent3D copySize = {width, height, 1};
 
         wgpu::CommandEncoder encoder = secondDevice.CreateCommandEncoder();
@@ -858,9 +861,10 @@
     copyDesc.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
     wgpu::Buffer copyDstBuffer = device.CreateBuffer(&copyDesc);
     {
-        wgpu::ImageCopyTexture copySrc =
-            utils::CreateImageCopyTexture(nextWrappedTexture, 0, {0, 0, 0});
-        wgpu::ImageCopyBuffer copyDst = utils::CreateImageCopyBuffer(copyDstBuffer, 0, bytesPerRow);
+        wgpu::TexelCopyTextureInfo copySrc =
+            utils::CreateTexelCopyTextureInfo(nextWrappedTexture, 0, {0, 0, 0});
+        wgpu::TexelCopyBufferInfo copyDst =
+            utils::CreateTexelCopyBufferInfo(copyDstBuffer, 0, bytesPerRow);
 
         wgpu::Extent3D copySize = {width, height, 1};
 
@@ -899,7 +903,7 @@
                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
     ASSERT_NE(texture.Get(), nullptr);
 
-    wgpu::ImageCopyTexture dst = {};
+    wgpu::TexelCopyTextureInfo dst = {};
     dst.texture = texture;
     std::array<utils::RGBA8, 4> rgbaTextureData = {
         utils::RGBA8(180, 0, 0, 255),
@@ -908,7 +912,7 @@
         utils::RGBA8(62, 180, 84, 90),
     };
 
-    wgpu::TextureDataLayout dataLayout = {};
+    wgpu::TexelCopyBufferLayout dataLayout = {};
     dataLayout.bytesPerRow = textureDesc.size.width * sizeof(utils::RGBA8);
 
     queue.WriteTexture(&dst, rgbaTextureData.data(), rgbaTextureData.size() * sizeof(utils::RGBA8),
diff --git a/src/dawn/utils/TestUtils.cpp b/src/dawn/utils/TestUtils.cpp
index abafbf0..62c59c4 100644
--- a/src/dawn/utils/TestUtils.cpp
+++ b/src/dawn/utils/TestUtils.cpp
@@ -153,14 +153,14 @@
     descriptor.usage = wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::CopySrc;
     wgpu::Texture texture = device.CreateTexture(&descriptor);
 
-    wgpu::ImageCopyTexture imageCopyTexture =
-        dawn::utils::CreateImageCopyTexture(texture, 0, {0, 0, 0});
-    wgpu::TextureDataLayout textureDataLayout =
-        dawn::utils::CreateTextureDataLayout(0, wgpu::kCopyStrideUndefined);
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo =
+        dawn::utils::CreateTexelCopyTextureInfo(texture, 0, {0, 0, 0});
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout =
+        dawn::utils::CreateTexelCopyBufferLayout(0, wgpu::kCopyStrideUndefined);
     wgpu::Extent3D copyExtent = {1, 1, 1};
 
     // WriteTexture with exactly 1 byte of data.
-    device.GetQueue().WriteTexture(&imageCopyTexture, data.data(), 1, &textureDataLayout,
+    device.GetQueue().WriteTexture(&texelCopyTextureInfo, data.data(), 1, &texelCopyBufferLayout,
                                    &copyExtent);
 }
 
diff --git a/src/dawn/utils/WGPUHelpers.cpp b/src/dawn/utils/WGPUHelpers.cpp
index 4c4341a..9b2b07a 100644
--- a/src/dawn/utils/WGPUHelpers.cpp
+++ b/src/dawn/utils/WGPUHelpers.cpp
@@ -220,39 +220,39 @@
     return BasicRenderPass(width, height, color, format);
 }
 
-wgpu::ImageCopyBuffer CreateImageCopyBuffer(wgpu::Buffer buffer,
-                                            uint64_t offset,
-                                            uint32_t bytesPerRow,
-                                            uint32_t rowsPerImage) {
-    wgpu::ImageCopyBuffer imageCopyBuffer = {};
-    imageCopyBuffer.buffer = buffer;
-    imageCopyBuffer.layout = CreateTextureDataLayout(offset, bytesPerRow, rowsPerImage);
+wgpu::TexelCopyBufferInfo CreateTexelCopyBufferInfo(wgpu::Buffer buffer,
+                                                    uint64_t offset,
+                                                    uint32_t bytesPerRow,
+                                                    uint32_t rowsPerImage) {
+    wgpu::TexelCopyBufferInfo texelCopyBufferInfo = {};
+    texelCopyBufferInfo.buffer = buffer;
+    texelCopyBufferInfo.layout = CreateTexelCopyBufferLayout(offset, bytesPerRow, rowsPerImage);
 
-    return imageCopyBuffer;
+    return texelCopyBufferInfo;
 }
 
-wgpu::ImageCopyTexture CreateImageCopyTexture(wgpu::Texture texture,
-                                              uint32_t mipLevel,
-                                              wgpu::Origin3D origin,
-                                              wgpu::TextureAspect aspect) {
-    wgpu::ImageCopyTexture imageCopyTexture;
-    imageCopyTexture.texture = texture;
-    imageCopyTexture.mipLevel = mipLevel;
-    imageCopyTexture.origin = origin;
-    imageCopyTexture.aspect = aspect;
+wgpu::TexelCopyTextureInfo CreateTexelCopyTextureInfo(wgpu::Texture texture,
+                                                      uint32_t mipLevel,
+                                                      wgpu::Origin3D origin,
+                                                      wgpu::TextureAspect aspect) {
+    wgpu::TexelCopyTextureInfo texelCopyTextureInfo;
+    texelCopyTextureInfo.texture = texture;
+    texelCopyTextureInfo.mipLevel = mipLevel;
+    texelCopyTextureInfo.origin = origin;
+    texelCopyTextureInfo.aspect = aspect;
 
-    return imageCopyTexture;
+    return texelCopyTextureInfo;
 }
 
-wgpu::TextureDataLayout CreateTextureDataLayout(uint64_t offset,
-                                                uint32_t bytesPerRow,
-                                                uint32_t rowsPerImage) {
-    wgpu::TextureDataLayout textureDataLayout;
-    textureDataLayout.offset = offset;
-    textureDataLayout.bytesPerRow = bytesPerRow;
-    textureDataLayout.rowsPerImage = rowsPerImage;
+wgpu::TexelCopyBufferLayout CreateTexelCopyBufferLayout(uint64_t offset,
+                                                        uint32_t bytesPerRow,
+                                                        uint32_t rowsPerImage) {
+    wgpu::TexelCopyBufferLayout texelCopyBufferLayout;
+    texelCopyBufferLayout.offset = offset;
+    texelCopyBufferLayout.bytesPerRow = bytesPerRow;
+    texelCopyBufferLayout.rowsPerImage = rowsPerImage;
 
-    return textureDataLayout;
+    return texelCopyBufferLayout;
 }
 
 wgpu::PipelineLayout MakeBasicPipelineLayout(const wgpu::Device& device,
diff --git a/src/dawn/utils/WGPUHelpers.h b/src/dawn/utils/WGPUHelpers.h
index 1208825..0ed0522 100644
--- a/src/dawn/utils/WGPUHelpers.h
+++ b/src/dawn/utils/WGPUHelpers.h
@@ -63,18 +63,20 @@
     return CreateBufferFromData(device, data.begin(), uint32_t(sizeof(T) * data.size()), usage);
 }
 
-wgpu::ImageCopyBuffer CreateImageCopyBuffer(wgpu::Buffer buffer,
-                                            uint64_t offset = 0,
-                                            uint32_t bytesPerRow = wgpu::kCopyStrideUndefined,
-                                            uint32_t rowsPerImage = wgpu::kCopyStrideUndefined);
-wgpu::ImageCopyTexture CreateImageCopyTexture(
+wgpu::TexelCopyBufferInfo CreateTexelCopyBufferInfo(
+    wgpu::Buffer buffer,
+    uint64_t offset = 0,
+    uint32_t bytesPerRow = wgpu::kCopyStrideUndefined,
+    uint32_t rowsPerImage = wgpu::kCopyStrideUndefined);
+wgpu::TexelCopyTextureInfo CreateTexelCopyTextureInfo(
     wgpu::Texture texture,
     uint32_t level = 0,
     wgpu::Origin3D origin = {0, 0, 0},
     wgpu::TextureAspect aspect = wgpu::TextureAspect::All);
-wgpu::TextureDataLayout CreateTextureDataLayout(uint64_t offset,
-                                                uint32_t bytesPerRow,
-                                                uint32_t rowsPerImage = wgpu::kCopyStrideUndefined);
+wgpu::TexelCopyBufferLayout CreateTexelCopyBufferLayout(
+    uint64_t offset,
+    uint32_t bytesPerRow,
+    uint32_t rowsPerImage = wgpu::kCopyStrideUndefined);
 
 struct ComboRenderPassDescriptor : public wgpu::RenderPassDescriptor {
   public:
diff --git a/src/dawn/wire/client/Queue.cpp b/src/dawn/wire/client/Queue.cpp
index e5093dc..ac860d2 100644
--- a/src/dawn/wire/client/Queue.cpp
+++ b/src/dawn/wire/client/Queue.cpp
@@ -121,10 +121,10 @@
     GetClient()->SerializeCommand(cmd);
 }
 
-void Queue::WriteTexture(const WGPUImageCopyTexture* destination,
+void Queue::WriteTexture(const WGPUTexelCopyTextureInfo* destination,
                          const void* data,
                          size_t dataSize,
-                         const WGPUTextureDataLayout* dataLayout,
+                         const WGPUTexelCopyBufferLayout* dataLayout,
                          const WGPUExtent3D* writeSize) {
     QueueWriteTextureCmd cmd;
     cmd.queueId = GetWireId();
diff --git a/src/dawn/wire/client/Queue.h b/src/dawn/wire/client/Queue.h
index 0f95a42..4082934 100644
--- a/src/dawn/wire/client/Queue.h
+++ b/src/dawn/wire/client/Queue.h
@@ -45,10 +45,10 @@
     // Dawn API
     WGPUFuture OnSubmittedWorkDone(const WGPUQueueWorkDoneCallbackInfo& callbackInfo);
     void WriteBuffer(WGPUBuffer cBuffer, uint64_t bufferOffset, const void* data, size_t size);
-    void WriteTexture(const WGPUImageCopyTexture* destination,
+    void WriteTexture(const WGPUTexelCopyTextureInfo* destination,
                       const void* data,
                       size_t dataSize,
-                      const WGPUTextureDataLayout* dataLayout,
+                      const WGPUTexelCopyBufferLayout* dataLayout,
                       const WGPUExtent3D* writeSize);
 };
 
diff --git a/src/dawn/wire/server/ServerQueue.cpp b/src/dawn/wire/server/ServerQueue.cpp
index 2eba81a..6010914 100644
--- a/src/dawn/wire/server/ServerQueue.cpp
+++ b/src/dawn/wire/server/ServerQueue.cpp
@@ -70,10 +70,10 @@
 }
 
 WireResult Server::DoQueueWriteTexture(Known<WGPUQueue> queue,
-                                       const WGPUImageCopyTexture* destination,
+                                       const WGPUTexelCopyTextureInfo* destination,
                                        const uint8_t* data,
                                        uint64_t dataSize,
-                                       const WGPUTextureDataLayout* dataLayout,
+                                       const WGPUTexelCopyBufferLayout* dataLayout,
                                        const WGPUExtent3D* writeSize) {
     if (dataSize > std::numeric_limits<size_t>::max()) {
         return WireResult::FatalError;
diff --git a/third_party/emdawnwebgpu/library_webgpu.js b/third_party/emdawnwebgpu/library_webgpu.js
index 5fb6e5f..41fa5db 100644
--- a/third_party/emdawnwebgpu/library_webgpu.js
+++ b/third_party/emdawnwebgpu/library_webgpu.js
@@ -229,34 +229,34 @@
       };
     },
 
-    makeImageCopyTexture: (ptr) => {
+    makeTexelCopyTextureInfo: (ptr) => {
       {{{ gpu.makeCheck('ptr') }}}
       return {
         "texture": WebGPU.getJsObject(
-          {{{ makeGetValue('ptr', C_STRUCTS.WGPUImageCopyTexture.texture, '*') }}}),
-        "mipLevel": {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUImageCopyTexture.mipLevel) }}},
-        "origin": WebGPU.makeOrigin3D(ptr + {{{ C_STRUCTS.WGPUImageCopyTexture.origin }}}),
-        "aspect": WebGPU.TextureAspect[{{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUImageCopyTexture.aspect) }}}],
+          {{{ makeGetValue('ptr', C_STRUCTS.WGPUTexelCopyTextureInfo.texture, '*') }}}),
+        "mipLevel": {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUTexelCopyTextureInfo.mipLevel) }}},
+        "origin": WebGPU.makeOrigin3D(ptr + {{{ C_STRUCTS.WGPUTexelCopyTextureInfo.origin }}}),
+        "aspect": WebGPU.TextureAspect[{{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUTexelCopyTextureInfo.aspect) }}}],
       };
     },
 
-    makeTextureDataLayout: (ptr) => {
+    makeTexelCopyBufferLayout: (ptr) => {
       {{{ gpu.makeCheckDescriptor('ptr') }}}
-      var bytesPerRow = {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUTextureDataLayout.bytesPerRow) }}};
-      var rowsPerImage = {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUTextureDataLayout.rowsPerImage) }}};
+      var bytesPerRow = {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUTexelCopyBufferLayout.bytesPerRow) }}};
+      var rowsPerImage = {{{ gpu.makeGetU32('ptr', C_STRUCTS.WGPUTexelCopyBufferLayout.rowsPerImage) }}};
       return {
-        "offset": {{{ gpu.makeGetU64('ptr', C_STRUCTS.WGPUTextureDataLayout.offset) }}},
+        "offset": {{{ gpu.makeGetU64('ptr', C_STRUCTS.WGPUTexelCopyBufferLayout.offset) }}},
         "bytesPerRow": bytesPerRow === {{{ gpu.COPY_STRIDE_UNDEFINED }}} ? undefined : bytesPerRow,
         "rowsPerImage": rowsPerImage === {{{ gpu.COPY_STRIDE_UNDEFINED }}} ? undefined : rowsPerImage,
       };
     },
 
-    makeImageCopyBuffer: (ptr) => {
+    makeTexelCopyBufferInfo: (ptr) => {
       {{{ gpu.makeCheck('ptr') }}}
-      var layoutPtr = ptr + {{{ C_STRUCTS.WGPUImageCopyBuffer.layout }}};
-      var bufferCopyView = WebGPU.makeTextureDataLayout(layoutPtr);
+      var layoutPtr = ptr + {{{ C_STRUCTS.WGPUTexelCopyBufferInfo.layout }}};
+      var bufferCopyView = WebGPU.makeTexelCopyBufferLayout(layoutPtr);
       bufferCopyView["buffer"] = WebGPU.getJsObject(
-        {{{ makeGetValue('ptr', C_STRUCTS.WGPUImageCopyBuffer.buffer, '*') }}});
+        {{{ makeGetValue('ptr', C_STRUCTS.WGPUTexelCopyBufferInfo.buffer, '*') }}});
       return bufferCopyView;
     },
 
@@ -1169,21 +1169,21 @@
     var commandEncoder = WebGPU.getJsObject(encoderPtr);
     var copySize = WebGPU.makeExtent3D(copySizePtr);
     commandEncoder.copyBufferToTexture(
-      WebGPU.makeImageCopyBuffer(srcPtr), WebGPU.makeImageCopyTexture(dstPtr), copySize);
+      WebGPU.makeTexelCopyBufferInfo(srcPtr), WebGPU.makeTexelCopyTextureInfo(dstPtr), copySize);
   },
 
   wgpuCommandEncoderCopyTextureToBuffer: (encoderPtr, srcPtr, dstPtr, copySizePtr) => {
     var commandEncoder = WebGPU.getJsObject(encoderPtr);
     var copySize = WebGPU.makeExtent3D(copySizePtr);
     commandEncoder.copyTextureToBuffer(
-      WebGPU.makeImageCopyTexture(srcPtr), WebGPU.makeImageCopyBuffer(dstPtr), copySize);
+      WebGPU.makeTexelCopyTextureInfo(srcPtr), WebGPU.makeTexelCopyBufferInfo(dstPtr), copySize);
   },
 
   wgpuCommandEncoderCopyTextureToTexture: (encoderPtr, srcPtr, dstPtr, copySizePtr) => {
     var commandEncoder = WebGPU.getJsObject(encoderPtr);
     var copySize = WebGPU.makeExtent3D(copySizePtr);
     commandEncoder.copyTextureToTexture(
-      WebGPU.makeImageCopyTexture(srcPtr), WebGPU.makeImageCopyTexture(dstPtr), copySize);
+      WebGPU.makeTexelCopyTextureInfo(srcPtr), WebGPU.makeTexelCopyTextureInfo(dstPtr), copySize);
   },
 
   wgpuCommandEncoderFinish__deps: ['emwgpuCreateCommandBuffer'],
@@ -2056,8 +2056,8 @@
   wgpuQueueWriteTexture: (queuePtr, destinationPtr, data, dataSize, dataLayoutPtr, writeSizePtr) => {
     var queue = WebGPU.getJsObject(queuePtr);
 
-    var destination = WebGPU.makeImageCopyTexture(destinationPtr);
-    var dataLayout = WebGPU.makeTextureDataLayout(dataLayoutPtr);
+    var destination = WebGPU.makeTexelCopyTextureInfo(destinationPtr);
+    var dataLayout = WebGPU.makeTexelCopyBufferLayout(dataLayoutPtr);
     var writeSize = WebGPU.makeExtent3D(writeSizePtr);
     // This subarray isn't strictly necessary, but helps work around an issue
     // where Chromium makes a copy of the entire heap. crbug.com/1134457
diff --git a/tools/android/BUILD.gn b/tools/android/BUILD.gn
index 134c5e1..206a276 100644
--- a/tools/android/BUILD.gn
+++ b/tools/android/BUILD.gn
@@ -112,8 +112,6 @@
     "java/android/dawn/Functions.kt",
     "java/android/dawn/Future.kt",
     "java/android/dawn/FutureWaitInfo.kt",
-    "java/android/dawn/ImageCopyBuffer.kt",
-    "java/android/dawn/ImageCopyTexture.kt",
     "java/android/dawn/IndexFormat.kt",
     "java/android/dawn/Instance.kt",
     "java/android/dawn/InstanceCapabilities.kt",
@@ -191,10 +189,12 @@
     "java/android/dawn/SurfaceSourceAndroidNativeWindow.kt",
     "java/android/dawn/SurfaceTexture.kt",
     "java/android/dawn/Texture.kt",
+    "java/android/dawn/TexelCopyBufferInfo.kt",
+    "java/android/dawn/TexelCopyBufferLayout.kt",
+    "java/android/dawn/TexelCopyTextureInfo.kt",
     "java/android/dawn/TextureAspect.kt",
     "java/android/dawn/TextureBindingLayout.kt",
     "java/android/dawn/TextureBindingViewDimensionDescriptor.kt",
-    "java/android/dawn/TextureDataLayout.kt",
     "java/android/dawn/TextureDescriptor.kt",
     "java/android/dawn/TextureDimension.kt",
     "java/android/dawn/TextureFormat.kt",
diff --git a/tools/android/webgpu/src/main/java/android/dawn/helper/Textures.kt b/tools/android/webgpu/src/main/java/android/dawn/helper/Textures.kt
index 6176652..8b7f38a 100644
--- a/tools/android/webgpu/src/main/java/android/dawn/helper/Textures.kt
+++ b/tools/android/webgpu/src/main/java/android/dawn/helper/Textures.kt
@@ -17,12 +17,12 @@
         ByteBuffer.allocateDirect(height * width * Int.SIZE_BYTES).let { pixels ->
             copyPixelsToBuffer(pixels)
             device.queue.writeTexture(
-                dataLayout = TextureDataLayout(
+                dataLayout = TexelCopyBufferLayout(
                     bytesPerRow = width * Int.SIZE_BYTES,
                     rowsPerImage = height
                 ),
                 data = pixels,
-                destination = ImageCopyTexture(texture = texture),
+                destination = TexelCopyTextureInfo(texture = texture),
                 writeSize = size
             )
         }
@@ -43,9 +43,9 @@
     )
     device.queue.submit(arrayOf(device.createCommandEncoder().let {
         it.copyTextureToBuffer(
-            source = ImageCopyTexture(texture = this),
-            destination = ImageCopyBuffer(
-                layout = TextureDataLayout(
+            source = TexelCopyTextureInfo(texture = this),
+            destination = TexelCopyBufferInfo(
+                layout = TexelCopyBufferLayout(
                     offset = 0,
                     bytesPerRow = width * Int.SIZE_BYTES,
                     rowsPerImage = height