Deprecate TextureCopyView::arrayLayer -> origin.z

All existing tests and samples are updated and deprecation tests added.

CommandEncoder still encodes using arrayLayers so the backends are
unchanged. They will be handled in a follow-up CL.

Bug: dawn:22

Change-Id: Ib5346b46eb04d97349cab8f32ef8da5034726ca8
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/23104
Reviewed-by: Austin Eng <enga@chromium.org>
Reviewed-by: Jiawei Shao <jiawei.shao@intel.com>
Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
diff --git a/examples/CppHelloTriangle.cpp b/examples/CppHelloTriangle.cpp
index 44a26ca..fbc598d 100644
--- a/examples/CppHelloTriangle.cpp
+++ b/examples/CppHelloTriangle.cpp
@@ -75,7 +75,7 @@
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
     wgpu::BufferCopyView bufferCopyView =
         utils::CreateBufferCopyView(stagingBuffer, 0, 4 * 1024, 0);
-    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
+    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {1024, 1024, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
diff --git a/src/dawn_native/CommandEncoder.cpp b/src/dawn_native/CommandEncoder.cpp
index 5159d9c..b79e350 100644
--- a/src/dawn_native/CommandEncoder.cpp
+++ b/src/dawn_native/CommandEncoder.cpp
@@ -46,30 +46,26 @@
                 return DAWN_VALIDATION_ERROR("Copy mipLevel out of range");
             }
 
-            if (static_cast<uint64_t>(textureCopy.arrayLayer) +
-                    static_cast<uint64_t>(copySize.depth) >
-                static_cast<uint64_t>(texture->GetArrayLayers())) {
-                return DAWN_VALIDATION_ERROR("Copy arrayLayer out of range");
-            }
-
-            Extent3D extent = texture->GetMipLevelPhysicalSize(textureCopy.mipLevel);
+            Extent3D mipSize = texture->GetMipLevelPhysicalSize(textureCopy.mipLevel);
+            // For 2D textures, include the array layer as depth so it can be checked with other
+            // dimensions.
+            ASSERT(texture->GetDimension() == wgpu::TextureDimension::e2D);
+            mipSize.depth = texture->GetArrayLayers();
 
             // All texture dimensions are in uint32_t so by doing checks in uint64_t we avoid
             // overflows.
             if (static_cast<uint64_t>(textureCopy.origin.x) +
                         static_cast<uint64_t>(copySize.width) >
-                    static_cast<uint64_t>(extent.width) ||
+                    static_cast<uint64_t>(mipSize.width) ||
                 static_cast<uint64_t>(textureCopy.origin.y) +
                         static_cast<uint64_t>(copySize.height) >
-                    static_cast<uint64_t>(extent.height)) {
+                    static_cast<uint64_t>(mipSize.height) ||
+                static_cast<uint64_t>(textureCopy.origin.z) +
+                        static_cast<uint64_t>(copySize.depth) >
+                    static_cast<uint64_t>(mipSize.depth)) {
                 return DAWN_VALIDATION_ERROR("Copy would touch outside of the texture");
             }
 
-            // TODO(cwallez@chromium.org): Check the depth bound differently for 3D textures.
-            if (textureCopy.origin.z != 0) {
-                return DAWN_VALIDATION_ERROR("No support for z != 0 for now");
-            }
-
             return {};
         }
 
@@ -147,8 +143,8 @@
 
             ASSERT(src.texture->GetDimension() == wgpu::TextureDimension::e2D &&
                    dst.texture->GetDimension() == wgpu::TextureDimension::e2D);
-            if (dst.origin.x != 0 || dst.origin.y != 0 || dst.origin.z != 0 ||
-                srcSize.width != copySize.width || srcSize.height != copySize.height) {
+            if (dst.origin.x != 0 || dst.origin.y != 0 || srcSize.width != copySize.width ||
+                srcSize.height != copySize.height) {
                 return DAWN_VALIDATION_ERROR(
                     "The entire subresource must be copied when using a depth/stencil texture or "
                     "when samples are greater than 1.");
@@ -186,7 +182,7 @@
             if (src.texture == dst.texture && src.mipLevel == dst.mipLevel) {
                 ASSERT(src.texture->GetDimension() == wgpu::TextureDimension::e2D &&
                        dst.texture->GetDimension() == wgpu::TextureDimension::e2D);
-                if (IsRangeOverlapped(src.arrayLayer, dst.arrayLayer, copySize.depth)) {
+                if (IsRangeOverlapped(src.origin.z, dst.origin.z, copySize.depth)) {
                     return DAWN_VALIDATION_ERROR(
                         "Copy subresources cannot be overlapped when copying within the same "
                         "texture.");
@@ -497,6 +493,25 @@
             return {};
         }
 
+        ResultOrError<TextureCopyView> FixTextureCopyView(DeviceBase* device,
+                                                          const TextureCopyView* view) {
+            TextureCopyView fixedView = *view;
+
+            if (view->arrayLayer != 0) {
+                if (view->origin.z != 0) {
+                    return DAWN_VALIDATION_ERROR("arrayLayer and origin.z cannot both be != 0");
+                } else {
+                    fixedView.origin.z = fixedView.arrayLayer;
+                    fixedView.arrayLayer = 1;
+                    device->EmitDeprecationWarning(
+                        "wgpu::TextureCopyView::arrayLayer is deprecated in favor of "
+                        "::origin::z");
+                }
+            }
+
+            return fixedView;
+        }
+
     }  // namespace
 
     CommandEncoder::CommandEncoder(DeviceBase* device, const CommandEncoderDescriptor*)
@@ -657,6 +672,12 @@
                                              const TextureCopyView* destination,
                                              const Extent3D* copySize) {
         mEncodingContext.TryEncode(this, [&](CommandAllocator* allocator) -> MaybeError {
+            // TODO(dawn:22): Remove once migration from GPUTextureCopyView.arrayLayer to
+            // GPUTextureCopyView.origin.z is done.
+            TextureCopyView fixedDest;
+            DAWN_TRY_ASSIGN(fixedDest, FixTextureCopyView(GetDevice(), destination));
+            destination = &fixedDest;
+
             // Validate objects before doing the defaulting.
             if (GetDevice()->IsValidationEnabled()) {
                 DAWN_TRY(GetDevice()->ValidateObject(source->buffer));
@@ -711,6 +732,10 @@
             copy->destination.mipLevel = destination->mipLevel;
             copy->destination.arrayLayer = destination->arrayLayer;
 
+            // TODO(cwallez@chromium.org): Make backends use origin.z instead of arrayLayer
+            copy->destination.arrayLayer = copy->destination.origin.z;
+            copy->destination.origin.z = 0;
+
             return {};
         });
     }
@@ -719,6 +744,12 @@
                                              const BufferCopyView* destination,
                                              const Extent3D* copySize) {
         mEncodingContext.TryEncode(this, [&](CommandAllocator* allocator) -> MaybeError {
+            // TODO(dawn:22): Remove once migration from GPUTextureCopyView.arrayLayer to
+            // GPUTextureCopyView.origin.z is done.
+            TextureCopyView fixedSrc;
+            DAWN_TRY_ASSIGN(fixedSrc, FixTextureCopyView(GetDevice(), source));
+            source = &fixedSrc;
+
             // Validate objects before doing the defaulting.
             if (GetDevice()->IsValidationEnabled()) {
                 DAWN_TRY(GetDevice()->ValidateObject(source->texture));
@@ -771,6 +802,10 @@
             copy->destination.bytesPerRow = destination->bytesPerRow;
             copy->destination.rowsPerImage = defaultedRowsPerImage;
 
+            // TODO(cwallez@chromium.org): Make backends use origin.z instead of arrayLayer
+            copy->source.arrayLayer = copy->source.origin.z;
+            copy->source.origin.z = 0;
+
             return {};
         });
     }
@@ -779,6 +814,15 @@
                                               const TextureCopyView* destination,
                                               const Extent3D* copySize) {
         mEncodingContext.TryEncode(this, [&](CommandAllocator* allocator) -> MaybeError {
+            // TODO(dawn:22): Remove once migration from GPUTextureCopyView.arrayLayer to
+            // GPUTextureCopyView.origin.z is done.
+            TextureCopyView fixedSrc;
+            DAWN_TRY_ASSIGN(fixedSrc, FixTextureCopyView(GetDevice(), source));
+            source = &fixedSrc;
+            TextureCopyView fixedDest;
+            DAWN_TRY_ASSIGN(fixedDest, FixTextureCopyView(GetDevice(), destination));
+            destination = &fixedDest;
+
             if (GetDevice()->IsValidationEnabled()) {
                 DAWN_TRY(GetDevice()->ValidateObject(source->texture));
                 DAWN_TRY(GetDevice()->ValidateObject(destination->texture));
@@ -814,6 +858,12 @@
             copy->destination.arrayLayer = destination->arrayLayer;
             copy->copySize = *copySize;
 
+            // TODO(cwallez@chromium.org): Make backends use origin.z instead of arrayLayer
+            copy->source.arrayLayer = copy->source.origin.z;
+            copy->source.origin.z = 0;
+            copy->destination.arrayLayer = copy->destination.origin.z;
+            copy->destination.origin.z = 0;
+
             return {};
         });
     }
diff --git a/src/tests/DawnTest.cpp b/src/tests/DawnTest.cpp
index 09848de..3a14dbf 100644
--- a/src/tests/DawnTest.cpp
+++ b/src/tests/DawnTest.cpp
@@ -932,7 +932,7 @@
     // We need to enqueue the copy immediately because by the time we resolve the expectation,
     // the texture might have been modified.
     wgpu::TextureCopyView textureCopyView =
-        utils::CreateTextureCopyView(texture, level, slice, {x, y, 0});
+        utils::CreateTextureCopyView(texture, level, {x, y, slice});
     wgpu::BufferCopyView bufferCopyView =
         utils::CreateBufferCopyView(readback.buffer, readback.offset, bytesPerRow, 0);
     wgpu::Extent3D copySize = {width, height, 1};
diff --git a/src/tests/end2end/BindGroupTests.cpp b/src/tests/end2end/BindGroupTests.cpp
index 0f48c8d..118a4ee 100644
--- a/src/tests/end2end/BindGroupTests.cpp
+++ b/src/tests/end2end/BindGroupTests.cpp
@@ -305,7 +305,7 @@
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
     wgpu::BufferCopyView bufferCopyView =
         utils::CreateBufferCopyView(stagingBuffer, 0, widthInBytes, 0);
-    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
+    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {width, height, 1};
     encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copySize);
     wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass.renderPassInfo);
diff --git a/src/tests/end2end/CompressedTextureFormatTests.cpp b/src/tests/end2end/CompressedTextureFormatTests.cpp
index 857ecd2..80c2e2a 100644
--- a/src/tests/end2end/CompressedTextureFormatTests.cpp
+++ b/src/tests/end2end/CompressedTextureFormatTests.cpp
@@ -91,9 +91,12 @@
         wgpu::BufferCopyView bufferCopyView =
             utils::CreateBufferCopyView(stagingBuffer, copyConfig.bufferOffset,
                                         copyConfig.bytesPerRowAlignment, copyConfig.rowsPerImage);
-        wgpu::TextureCopyView textureCopyView =
-            utils::CreateTextureCopyView(bcCompressedTexture, copyConfig.viewMipmapLevel,
-                                         copyConfig.viewArrayLayer, copyConfig.copyOrigin3D);
+
+        ASSERT(copyConfig.copyOrigin3D.z == 0);
+        wgpu::Origin3D copyOrigin = copyConfig.copyOrigin3D;
+        copyOrigin.z = copyConfig.viewArrayLayer;
+        wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(
+            bcCompressedTexture, copyConfig.viewMipmapLevel, copyOrigin);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copyConfig.copyExtent3D);
@@ -237,12 +240,17 @@
                                     wgpu::Texture dstTexture,
                                     CopyConfig srcConfig,
                                     CopyConfig dstConfig) {
+        ASSERT(srcConfig.copyOrigin3D.z == 0);
+        wgpu::Origin3D srcCopyOrigin = srcConfig.copyOrigin3D;
+        srcCopyOrigin.z = srcConfig.viewArrayLayer;
         wgpu::TextureCopyView textureCopyViewSrc =
-            utils::CreateTextureCopyView(srcTexture, srcConfig.viewMipmapLevel,
-                                         srcConfig.viewArrayLayer, srcConfig.copyOrigin3D);
+            utils::CreateTextureCopyView(srcTexture, srcConfig.viewMipmapLevel, srcCopyOrigin);
+
+        ASSERT(dstConfig.copyOrigin3D.z == 0);
+        wgpu::Origin3D dstCopyOrigin = dstConfig.copyOrigin3D;
+        dstCopyOrigin.z = dstConfig.viewArrayLayer;
         wgpu::TextureCopyView textureCopyViewDst =
-            utils::CreateTextureCopyView(dstTexture, dstConfig.viewMipmapLevel,
-                                         dstConfig.viewArrayLayer, dstConfig.copyOrigin3D);
+            utils::CreateTextureCopyView(dstTexture, dstConfig.viewMipmapLevel, dstCopyOrigin);
         encoder.CopyTextureToTexture(&textureCopyViewSrc, &textureCopyViewDst,
                                      &dstConfig.copyExtent3D);
     }
@@ -631,9 +639,8 @@
         srcConfig.textureDescriptor.usage =
             wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst;
         wgpu::Texture bcTextureSrc = CreateTextureWithCompressedData(srcConfig);
-        wgpu::TextureCopyView textureCopyViewSrc =
-            utils::CreateTextureCopyView(bcTextureSrc, srcConfig.viewMipmapLevel,
-                                         srcConfig.viewArrayLayer, srcConfig.copyOrigin3D);
+        wgpu::TextureCopyView textureCopyViewSrc = utils::CreateTextureCopyView(
+            bcTextureSrc, srcConfig.viewMipmapLevel, srcConfig.copyOrigin3D);
 
         // Create bcTexture and copy from the content in bcTextureSrc into it.
         dstConfig.textureDescriptor.format = format;
diff --git a/src/tests/end2end/CopyTests.cpp b/src/tests/end2end/CopyTests.cpp
index 95a8aac..857faa0 100644
--- a/src/tests/end2end/CopyTests.cpp
+++ b/src/tests/end2end/CopyTests.cpp
@@ -109,7 +109,7 @@
                 wgpu::BufferCopyView bufferCopyView =
                     utils::CreateBufferCopyView(uploadBuffer, 0, bytesPerRow, 0);
                 wgpu::TextureCopyView textureCopyView =
-                    utils::CreateTextureCopyView(texture, textureSpec.level, slice, {0, 0, 0});
+                    utils::CreateTextureCopyView(texture, textureSpec.level, {0, 0, slice});
                 wgpu::Extent3D copySize = {width, height, 1};
                 encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copySize);
             }
@@ -131,7 +131,7 @@
                 // Copy the region [(`x`, `y`), (`x + copyWidth, `y + copyWidth`)] from the `level`
                 // mip into the buffer at `offset + bufferSpec.size * slice` and `bytesPerRow`
                 wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(
-                    texture, textureSpec.level, slice, {textureSpec.x, textureSpec.y, 0});
+                    texture, textureSpec.level, {textureSpec.x, textureSpec.y, slice});
                 wgpu::BufferCopyView bufferCopyView =
                     utils::CreateBufferCopyView(buffer, bufferOffset, bufferSpec.bytesPerRow, 0);
                 wgpu::Extent3D copySize = {textureSpec.copyWidth, textureSpec.copyHeight, 1};
@@ -229,7 +229,7 @@
             wgpu::BufferCopyView bufferCopyView =
                 utils::CreateBufferCopyView(uploadBuffer, 0, bytesPerRow, 0);
             wgpu::TextureCopyView textureCopyView =
-                utils::CreateTextureCopyView(texture, textureSpec.level, 0, {0, 0, 0});
+                utils::CreateTextureCopyView(texture, textureSpec.level, {0, 0, 0});
             wgpu::Extent3D copySize = {width, height, 1};
             encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copySize);
         }
@@ -240,7 +240,7 @@
             wgpu::BufferCopyView bufferCopyView =
                 utils::CreateBufferCopyView(buffer, bufferSpec.offset, bufferSpec.bytesPerRow, 0);
             wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(
-                texture, textureSpec.level, 0, {textureSpec.x, textureSpec.y, 0});
+                texture, textureSpec.level, {textureSpec.x, textureSpec.y, 0});
             wgpu::Extent3D copySize = {textureSpec.copyWidth, textureSpec.copyHeight, 1};
             encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copySize);
         }
@@ -345,7 +345,7 @@
             wgpu::BufferCopyView bufferCopyView =
                 utils::CreateBufferCopyView(uploadBuffer, 0, bytesPerRow, 0);
             wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(
-                srcTexture, srcSpec.level, srcSpec.baseArrayLayer + slice, {0, 0, 0});
+                srcTexture, srcSpec.level, {0, 0, srcSpec.baseArrayLayer + slice});
             wgpu::Extent3D bufferCopySize = {width, height, 1};
 
             encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &bufferCopySize);
@@ -353,9 +353,9 @@
 
         // Perform the texture to texture copy
         wgpu::TextureCopyView srcTextureCopyView = utils::CreateTextureCopyView(
-            srcTexture, srcSpec.level, srcSpec.baseArrayLayer, {srcSpec.x, srcSpec.y, 0});
+            srcTexture, srcSpec.level, {srcSpec.x, srcSpec.y, srcSpec.baseArrayLayer});
         wgpu::TextureCopyView dstTextureCopyView = utils::CreateTextureCopyView(
-            dstTexture, dstSpec.level, dstSpec.baseArrayLayer, {dstSpec.x, dstSpec.y, 0});
+            dstTexture, dstSpec.level, {dstSpec.x, dstSpec.y, dstSpec.baseArrayLayer});
         wgpu::Extent3D copySize = {copy.width, copy.height, copy.arrayLayerCount};
         encoder.CopyTextureToTexture(&srcTextureCopyView, &dstTextureCopyView, &copySize);
 
diff --git a/src/tests/end2end/DeprecatedAPITests.cpp b/src/tests/end2end/DeprecatedAPITests.cpp
index 693e0c7..2c95929 100644
--- a/src/tests/end2end/DeprecatedAPITests.cpp
+++ b/src/tests/end2end/DeprecatedAPITests.cpp
@@ -138,3 +138,116 @@
                       NullBackend(),
                       OpenGLBackend(),
                       VulkanBackend());
+
+class TextureCopyViewArrayLayerDeprecationTests : public DeprecationTests {
+  protected:
+    wgpu::TextureCopyView MakeOldTextureCopyView() {
+        wgpu::TextureDescriptor desc;
+        desc.usage = wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst;
+        desc.dimension = wgpu::TextureDimension::e2D;
+        desc.size = {1, 1, 2};
+        desc.format = wgpu::TextureFormat::RGBA8Unorm;
+
+        wgpu::TextureCopyView copy;
+        copy.texture = device.CreateTexture(&desc);
+        copy.arrayLayer = 1;
+        copy.origin = {0, 0, 0};
+        return copy;
+    }
+
+    wgpu::TextureCopyView MakeNewTextureCopyView() {
+        wgpu::TextureCopyView copy = MakeOldTextureCopyView();
+        copy.arrayLayer = 0;
+        copy.origin.z = 1;
+        return copy;
+    }
+
+    wgpu::TextureCopyView MakeErrorTextureCopyView() {
+        wgpu::TextureCopyView copy = MakeOldTextureCopyView();
+        copy.origin.z = 1;
+        return copy;
+    }
+
+    wgpu::BufferCopyView MakeBufferCopyView() const {
+        wgpu::BufferDescriptor desc;
+        desc.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
+        desc.size = 4;
+
+        wgpu::BufferCopyView copy;
+        copy.buffer = device.CreateBuffer(&desc);
+        copy.bytesPerRow = kTextureBytesPerRowAlignment;
+        return copy;
+    }
+
+    wgpu::Extent3D copySize = {1, 1, 1};
+};
+
+// Test that using TextureCopyView::arrayLayer emits a warning.
+TEST_P(TextureCopyViewArrayLayerDeprecationTests, DeprecationWarning) {
+    wgpu::TextureCopyView texOldCopy = MakeOldTextureCopyView();
+    wgpu::TextureCopyView texNewCopy = MakeNewTextureCopyView();
+    wgpu::BufferCopyView bufCopy = MakeBufferCopyView();
+
+    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+    EXPECT_DEPRECATION_WARNING(encoder.CopyBufferToTexture(&bufCopy, &texOldCopy, &copySize));
+    EXPECT_DEPRECATION_WARNING(encoder.CopyTextureToTexture(&texNewCopy, &texOldCopy, &copySize));
+    EXPECT_DEPRECATION_WARNING(encoder.CopyTextureToBuffer(&texOldCopy, &bufCopy, &copySize));
+    EXPECT_DEPRECATION_WARNING(encoder.CopyTextureToTexture(&texOldCopy, &texNewCopy, &copySize));
+    wgpu::CommandBuffer command = encoder.Finish();
+
+    queue.Submit(1, &command);
+}
+
+// Test that using both TextureCopyView::arrayLayer and origin.z is an error.
+TEST_P(TextureCopyViewArrayLayerDeprecationTests, BothArrayLayerAndOriginZIsError) {
+    wgpu::TextureCopyView texErrorCopy = MakeErrorTextureCopyView();
+    wgpu::TextureCopyView texNewCopy = MakeNewTextureCopyView();
+    wgpu::BufferCopyView bufCopy = MakeBufferCopyView();
+
+    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+    encoder.CopyBufferToTexture(&bufCopy, &texErrorCopy, &copySize);
+    ASSERT_DEVICE_ERROR(encoder.Finish());
+
+    encoder = device.CreateCommandEncoder();
+    encoder.CopyTextureToTexture(&texNewCopy, &texErrorCopy, &copySize);
+    ASSERT_DEVICE_ERROR(encoder.Finish());
+
+    encoder = device.CreateCommandEncoder();
+    encoder.CopyTextureToBuffer(&texErrorCopy, &bufCopy, &copySize);
+    ASSERT_DEVICE_ERROR(encoder.Finish());
+
+    encoder = device.CreateCommandEncoder();
+    encoder.CopyTextureToTexture(&texErrorCopy, &texNewCopy, &copySize);
+    ASSERT_DEVICE_ERROR(encoder.Finish());
+}
+
+// Test that using TextureCopyView::arrayLayer is correctly taken into account
+TEST_P(TextureCopyViewArrayLayerDeprecationTests, StateTracking) {
+    wgpu::TextureCopyView texOOBCopy = MakeErrorTextureCopyView();
+    texOOBCopy.arrayLayer = 2;  // Oh no, it is OOB!
+    wgpu::TextureCopyView texNewCopy = MakeNewTextureCopyView();
+    wgpu::BufferCopyView bufCopy = MakeBufferCopyView();
+
+    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+    encoder.CopyBufferToTexture(&bufCopy, &texOOBCopy, &copySize);
+    ASSERT_DEVICE_ERROR(encoder.Finish());
+
+    encoder = device.CreateCommandEncoder();
+    encoder.CopyTextureToTexture(&texNewCopy, &texOOBCopy, &copySize);
+    ASSERT_DEVICE_ERROR(encoder.Finish());
+
+    encoder = device.CreateCommandEncoder();
+    encoder.CopyTextureToBuffer(&texOOBCopy, &bufCopy, &copySize);
+    ASSERT_DEVICE_ERROR(encoder.Finish());
+
+    encoder = device.CreateCommandEncoder();
+    encoder.CopyTextureToTexture(&texOOBCopy, &texNewCopy, &copySize);
+    ASSERT_DEVICE_ERROR(encoder.Finish());
+}
+
+DAWN_INSTANTIATE_TEST(TextureCopyViewArrayLayerDeprecationTests,
+                      D3D12Backend(),
+                      MetalBackend(),
+                      NullBackend(),
+                      OpenGLBackend(),
+                      VulkanBackend());
diff --git a/src/tests/end2end/NonzeroTextureCreationTests.cpp b/src/tests/end2end/NonzeroTextureCreationTests.cpp
index cce7f5f..9ee9e80 100644
--- a/src/tests/end2end/NonzeroTextureCreationTests.cpp
+++ b/src/tests/end2end/NonzeroTextureCreationTests.cpp
@@ -137,7 +137,7 @@
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
 
     wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(bufferDst, 0, kSize * 4, 0);
-    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
+    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -170,7 +170,7 @@
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
 
     wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(bufferDst, 0, kSize * 4, 0);
-    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 1, {0, 0, 0});
+    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 1});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
diff --git a/src/tests/end2end/SamplerTests.cpp b/src/tests/end2end/SamplerTests.cpp
index a6385c2..d40f099 100644
--- a/src/tests/end2end/SamplerTests.cpp
+++ b/src/tests/end2end/SamplerTests.cpp
@@ -105,8 +105,7 @@
         wgpu::Buffer stagingBuffer =
             utils::CreateBufferFromData(device, data, sizeof(data), wgpu::BufferUsage::CopySrc);
         wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(stagingBuffer, 0, 256, 0);
-        wgpu::TextureCopyView textureCopyView =
-            utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
+        wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 0});
         wgpu::Extent3D copySize = {2, 2, 1};
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
diff --git a/src/tests/end2end/StorageTextureTests.cpp b/src/tests/end2end/StorageTextureTests.cpp
index f90f5ee..d384d3f 100644
--- a/src/tests/end2end/StorageTextureTests.cpp
+++ b/src/tests/end2end/StorageTextureTests.cpp
@@ -473,7 +473,7 @@
 
             wgpu::TextureCopyView textureCopyView;
             textureCopyView.texture = outputTexture;
-            textureCopyView.arrayLayer = layer;
+            textureCopyView.origin.z = layer;
 
             encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copyExtent);
         }
@@ -652,7 +652,7 @@
         for (uint32_t layer = 0; layer < arrayLayerCount; ++layer) {
             wgpu::TextureCopyView textureCopyView;
             textureCopyView.texture = writeonlyStorageTexture;
-            textureCopyView.arrayLayer = layer;
+            textureCopyView.origin.z = layer;
 
             const uint64_t bufferOffset = kTextureBytesPerRowAlignment * kHeight * layer;
             wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(
diff --git a/src/tests/end2end/TextureFormatTests.cpp b/src/tests/end2end/TextureFormatTests.cpp
index b6fbdb1..06f70a5 100644
--- a/src/tests/end2end/TextureFormatTests.cpp
+++ b/src/tests/end2end/TextureFormatTests.cpp
@@ -269,7 +269,7 @@
         {
             wgpu::BufferCopyView bufferView = utils::CreateBufferCopyView(uploadBuffer, 0, 256, 0);
             wgpu::TextureCopyView textureView =
-                utils::CreateTextureCopyView(sampleTexture, 0, 0, {0, 0, 0});
+                utils::CreateTextureCopyView(sampleTexture, 0, {0, 0, 0});
             wgpu::Extent3D extent{width, 1, 1};
             encoder.CopyBufferToTexture(&bufferView, &textureView, &extent);
         }
@@ -285,7 +285,7 @@
             wgpu::BufferCopyView bufferView =
                 utils::CreateBufferCopyView(readbackBuffer, 0, 256, 0);
             wgpu::TextureCopyView textureView =
-                utils::CreateTextureCopyView(renderTarget, 0, 0, {0, 0, 0});
+                utils::CreateTextureCopyView(renderTarget, 0, {0, 0, 0});
             wgpu::Extent3D extent{width, 1, 1};
             encoder.CopyTextureToBuffer(&textureView, &bufferView, &extent);
         }
diff --git a/src/tests/end2end/TextureViewTests.cpp b/src/tests/end2end/TextureViewTests.cpp
index c20d0af..acab158 100644
--- a/src/tests/end2end/TextureViewTests.cpp
+++ b/src/tests/end2end/TextureViewTests.cpp
@@ -136,7 +136,7 @@
                 wgpu::BufferCopyView bufferCopyView =
                     utils::CreateBufferCopyView(stagingBuffer, 0, kTextureBytesPerRowAlignment, 0);
                 wgpu::TextureCopyView textureCopyView =
-                    utils::CreateTextureCopyView(mTexture, level, layer, {0, 0, 0});
+                    utils::CreateTextureCopyView(mTexture, level, {0, 0, layer});
                 wgpu::Extent3D copySize = {texWidth, texHeight, 1};
                 encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copySize);
             }
diff --git a/src/tests/end2end/TextureZeroInitTests.cpp b/src/tests/end2end/TextureZeroInitTests.cpp
index 4588e36..d145161 100644
--- a/src/tests/end2end/TextureZeroInitTests.cpp
+++ b/src/tests/end2end/TextureZeroInitTests.cpp
@@ -232,7 +232,7 @@
 
     wgpu::BufferCopyView bufferCopyView =
         utils::CreateBufferCopyView(stagingBuffer, 0, kSize * sizeof(uint32_t), 0);
-    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
+    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -263,7 +263,7 @@
 
     wgpu::BufferCopyView bufferCopyView =
         utils::CreateBufferCopyView(stagingBuffer, 0, kSize * sizeof(uint16_t), 0);
-    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
+    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize / 2, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -289,7 +289,7 @@
     wgpu::Texture srcTexture = device.CreateTexture(&srcDescriptor);
 
     wgpu::TextureCopyView srcTextureCopyView =
-        utils::CreateTextureCopyView(srcTexture, 0, 0, {0, 0, 0});
+        utils::CreateTextureCopyView(srcTexture, 0, {0, 0, 0});
 
     wgpu::TextureDescriptor dstDescriptor =
         CreateTextureDescriptor(1, 1,
@@ -299,7 +299,7 @@
     wgpu::Texture dstTexture = device.CreateTexture(&dstDescriptor);
 
     wgpu::TextureCopyView dstTextureCopyView =
-        utils::CreateTextureCopyView(dstTexture, 0, 0, {0, 0, 0});
+        utils::CreateTextureCopyView(dstTexture, 0, {0, 0, 0});
 
     wgpu::Extent3D copySize = {kSize, kSize, 1};
 
@@ -335,7 +335,7 @@
         wgpu::BufferCopyView bufferCopyView =
             utils::CreateBufferCopyView(stagingBuffer, 0, kSize * kFormatBlockByteSize, 0);
         wgpu::TextureCopyView textureCopyView =
-            utils::CreateTextureCopyView(srcTexture, 0, 0, {0, 0, 0});
+            utils::CreateTextureCopyView(srcTexture, 0, {0, 0, 0});
         wgpu::Extent3D copySize = {kSize, kSize, 1};
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copySize);
@@ -344,7 +344,7 @@
     }
 
     wgpu::TextureCopyView srcTextureCopyView =
-        utils::CreateTextureCopyView(srcTexture, 0, 0, {0, 0, 0});
+        utils::CreateTextureCopyView(srcTexture, 0, {0, 0, 0});
 
     wgpu::TextureDescriptor dstDescriptor =
         CreateTextureDescriptor(1, 1,
@@ -354,7 +354,7 @@
     wgpu::Texture dstTexture = device.CreateTexture(&dstDescriptor);
 
     wgpu::TextureCopyView dstTextureCopyView =
-        utils::CreateTextureCopyView(dstTexture, 0, 0, {0, 0, 0});
+        utils::CreateTextureCopyView(dstTexture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize / 2, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -647,7 +647,7 @@
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
 
     wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(bufferDst, 0, bytesPerRow, 0);
-    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
+    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -678,7 +678,7 @@
     wgpu::Buffer bufferDst = utils::CreateBufferFromData(
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
     wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(bufferDst, 0, bytesPerRow, 0);
-    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
+    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kUnalignedSize, kUnalignedSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -708,7 +708,7 @@
 
     wgpu::BufferCopyView bufferCopyView =
         utils::CreateBufferCopyView(bufferDst, 0, kSize * kFormatBlockByteSize, 0);
-    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 1, {0, 0, 0});
+    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 1});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
 
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -746,7 +746,7 @@
         device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
     wgpu::BufferCopyView bufferCopyView =
         utils::CreateBufferCopyView(stagingBuffer, 0, kSize * kFormatBlockByteSize, 0);
-    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
+    wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 0});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
     encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copySize);
@@ -895,7 +895,7 @@
     wgpu::BufferCopyView bufferCopyView =
         utils::CreateBufferCopyView(stagingBuffer, 0, mipSize * kFormatBlockByteSize, 0);
     wgpu::TextureCopyView textureCopyView =
-        utils::CreateTextureCopyView(sampleTexture, 1, 0, {0, 0, 0});
+        utils::CreateTextureCopyView(sampleTexture, 1, {0, 0, 0});
     wgpu::Extent3D copySize = {mipSize, mipSize, 1};
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
     encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copySize);
@@ -973,7 +973,7 @@
     wgpu::BufferCopyView bufferCopyView =
         utils::CreateBufferCopyView(stagingBuffer, 0, kSize * kFormatBlockByteSize, 0);
     wgpu::TextureCopyView textureCopyView =
-        utils::CreateTextureCopyView(sampleTexture, 0, 1, {0, 0, 0});
+        utils::CreateTextureCopyView(sampleTexture, 0, {0, 0, 1});
     wgpu::Extent3D copySize = {kSize, kSize, 1};
     wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
     encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &copySize);
@@ -1052,8 +1052,7 @@
         bufferDesc.usage = wgpu::BufferUsage::CopyDst;
         wgpu::Buffer buffer = device.CreateBuffer(&bufferDesc);
 
-        wgpu::TextureCopyView textureCopyView =
-            utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
+        wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, {0, 0, 0});
         wgpu::BufferCopyView bufferCopyView =
             utils::CreateBufferCopyView(buffer, 0, bytesPerRow, 0);
         wgpu::Extent3D copySize = {kUnalignedSize, kUnalignedSize, 1};
diff --git a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
index cbaee72..634dfb6 100644
--- a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
+++ b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
@@ -86,13 +86,12 @@
                      uint32_t srcRowsPerImage,
                      wgpu::Texture destTexture,
                      uint32_t destLevel,
-                     uint32_t destSlice,
                      wgpu::Origin3D destOrigin,
                      wgpu::Extent3D extent3D) {
         wgpu::BufferCopyView bufferCopyView =
             utils::CreateBufferCopyView(srcBuffer, srcOffset, srcBytesPerRow, srcRowsPerImage);
         wgpu::TextureCopyView textureCopyView =
-            utils::CreateTextureCopyView(destTexture, destLevel, destSlice, destOrigin);
+            utils::CreateTextureCopyView(destTexture, destLevel, destOrigin);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         encoder.CopyBufferToTexture(&bufferCopyView, &textureCopyView, &extent3D);
@@ -103,7 +102,6 @@
     void TestT2BCopy(utils::Expectation expectation,
                      wgpu::Texture srcTexture,
                      uint32_t srcLevel,
-                     uint32_t srcSlice,
                      wgpu::Origin3D srcOrigin,
                      wgpu::Buffer destBuffer,
                      uint64_t destOffset,
@@ -113,7 +111,7 @@
         wgpu::BufferCopyView bufferCopyView =
             utils::CreateBufferCopyView(destBuffer, destOffset, destBytesPerRow, destRowsPerImage);
         wgpu::TextureCopyView textureCopyView =
-            utils::CreateTextureCopyView(srcTexture, srcLevel, srcSlice, srcOrigin);
+            utils::CreateTextureCopyView(srcTexture, srcLevel, srcOrigin);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         encoder.CopyTextureToBuffer(&textureCopyView, &bufferCopyView, &extent3D);
@@ -124,17 +122,15 @@
     void TestT2TCopy(utils::Expectation expectation,
                      wgpu::Texture srcTexture,
                      uint32_t srcLevel,
-                     uint32_t srcSlice,
                      wgpu::Origin3D srcOrigin,
                      wgpu::Texture dstTexture,
                      uint32_t dstLevel,
-                     uint32_t dstSlice,
                      wgpu::Origin3D dstOrigin,
                      wgpu::Extent3D extent3D) {
         wgpu::TextureCopyView srcTextureCopyView =
-            utils::CreateTextureCopyView(srcTexture, srcLevel, srcSlice, srcOrigin);
+            utils::CreateTextureCopyView(srcTexture, srcLevel, srcOrigin);
         wgpu::TextureCopyView dstTextureCopyView =
-            utils::CreateTextureCopyView(dstTexture, dstLevel, dstSlice, dstOrigin);
+            utils::CreateTextureCopyView(dstTexture, dstLevel, dstOrigin);
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         encoder.CopyTextureToTexture(&srcTextureCopyView, &dstTextureCopyView, &extent3D);
@@ -328,45 +324,45 @@
     // Different copies, including some that touch the OOB condition
     {
         // Copy 4x4 block in corner of first mip.
-        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
+        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, {0, 0, 0},
                     {4, 4, 1});
         // Copy 4x4 block in opposite corner of first mip.
-        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, 0, {12, 12, 0},
+        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, {12, 12, 0},
                     {4, 4, 1});
         // Copy 4x4 block in the 4x4 mip.
-        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 2, 0, {0, 0, 0},
+        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 2, {0, 0, 0},
                     {4, 4, 1});
         // Copy with a buffer offset
-        TestB2TCopy(utils::Expectation::Success, source, bufferSize - 4, 256, 0, destination, 0, 0,
+        TestB2TCopy(utils::Expectation::Success, source, bufferSize - 4, 256, 0, destination, 0,
                     {0, 0, 0}, {1, 1, 1});
     }
 
     // Copies with a 256-byte aligned bytes per row but unaligned texture region
     {
         // Unaligned region
-        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
+        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, {0, 0, 0},
                     {3, 4, 1});
         // Unaligned region with texture offset
-        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, 0, {5, 7, 0},
+        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, {5, 7, 0},
                     {2, 3, 1});
         // Unaligned region, with buffer offset
-        TestB2TCopy(utils::Expectation::Success, source, 31 * 4, 256, 0, destination, 0, 0,
-                    {0, 0, 0}, {3, 3, 1});
+        TestB2TCopy(utils::Expectation::Success, source, 31 * 4, 256, 0, destination, 0, {0, 0, 0},
+                    {3, 3, 1});
     }
 
     // Empty copies are valid
     {
         // An empty copy
-        TestB2TCopy(utils::Expectation::Success, source, 0, 0, 0, destination, 0, 0, {0, 0, 0},
+        TestB2TCopy(utils::Expectation::Success, source, 0, 0, 0, destination, 0, {0, 0, 0},
                     {0, 0, 1});
         // An empty copy with depth = 0
-        TestB2TCopy(utils::Expectation::Success, source, 0, 0, 0, destination, 0, 0, {0, 0, 0},
+        TestB2TCopy(utils::Expectation::Success, source, 0, 0, 0, destination, 0, {0, 0, 0},
                     {0, 0, 0});
         // An empty copy touching the end of the buffer
-        TestB2TCopy(utils::Expectation::Success, source, bufferSize, 0, 0, destination, 0, 0,
+        TestB2TCopy(utils::Expectation::Success, source, bufferSize, 0, 0, destination, 0,
                     {0, 0, 0}, {0, 0, 1});
         // An empty copy touching the side of the texture
-        TestB2TCopy(utils::Expectation::Success, source, 0, 0, 0, destination, 0, 0, {16, 16, 0},
+        TestB2TCopy(utils::Expectation::Success, source, 0, 0, 0, destination, 0, {16, 16, 0},
                     {0, 0, 1});
     }
 }
@@ -379,16 +375,16 @@
         Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst);
 
     // OOB on the buffer because we copy too many pixels
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, {0, 0, 0},
                 {4, 5, 1});
 
     // OOB on the buffer because of the offset
-    TestB2TCopy(utils::Expectation::Failure, source, 4, 256, 0, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Failure, source, 4, 256, 0, destination, 0, {0, 0, 0},
                 {4, 4, 1});
 
     // OOB on the buffer because (bytes per row * (height - 1) + width * bytesPerPixel) * depth
     // overflows
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 512, 0, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 512, 0, destination, 0, {0, 0, 0},
                 {4, 3, 1});
 
     // Not OOB on the buffer although bytes per row * height overflows
@@ -398,7 +394,7 @@
         ASSERT_TRUE(256 * 3 > sourceBufferSize) << "bytes per row * height should overflow buffer";
         wgpu::Buffer sourceBuffer = CreateBuffer(sourceBufferSize, wgpu::BufferUsage::CopySrc);
 
-        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
+        TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, {0, 0, 0},
                     {7, 3, 1});
     }
 }
@@ -411,39 +407,32 @@
         Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst);
 
     // OOB on the texture because x + width overflows
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, 0, {13, 12, 0},
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, {13, 12, 0},
                 {4, 4, 1});
 
     // OOB on the texture because y + width overflows
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, 0, {12, 13, 0},
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, {12, 13, 0},
                 {4, 4, 1});
 
     // OOB on the texture because we overflow a non-zero mip
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 2, 0, {1, 0, 0},
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 2, {1, 0, 0},
                 {4, 4, 1});
 
     // OOB on the texture even on an empty copy when we copy to a non-existent mip.
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 5, 0, {0, 0, 0},
-                {0, 0, 1});
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 5, {0, 0, 0}, {0, 0, 1});
 
     // OOB on the texture because slice overflows
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, 2, {0, 0, 0},
-                {0, 0, 1});
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, {0, 0, 2}, {0, 0, 1});
 }
 
-// Test that we force Z=0 and Depth=1 on copies to 2D textures
-TEST_F(CopyCommandTest_B2T, ZDepthConstraintFor2DTextures) {
+// Test that we force Depth=1 on copies to 2D textures
+TEST_F(CopyCommandTest_B2T, DepthConstraintFor2DTextures) {
     wgpu::Buffer source = CreateBuffer(16 * 4, wgpu::BufferUsage::CopySrc);
     wgpu::Texture destination =
         Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst);
 
-    // Z=1 on an empty copy still errors
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, 0, {0, 0, 1},
-                {0, 0, 1});
-
     // Depth > 1 on an empty copy still errors
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, 0, {0, 0, 0},
-                {0, 0, 2});
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, {0, 0, 0}, {0, 0, 2});
 }
 
 // Test B2T copies with incorrect buffer usage
@@ -456,12 +445,11 @@
         Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::Sampled);
 
     // Incorrect source usage
-    TestB2TCopy(utils::Expectation::Failure, vertex, 0, 256, 0, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Failure, vertex, 0, 256, 0, destination, 0, {0, 0, 0},
                 {4, 4, 1});
 
     // Incorrect destination usage
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, sampled, 0, 0, {0, 0, 0},
-                {4, 4, 1});
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, sampled, 0, {0, 0, 0}, {4, 4, 1});
 }
 
 TEST_F(CopyCommandTest_B2T, IncorrectBytesPerRow) {
@@ -471,15 +459,15 @@
                                                 wgpu::TextureUsage::CopyDst);
 
     // bytes per row is 0
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, {0, 0, 0},
                 {64, 4, 1});
 
     // bytes per row is not 256-byte aligned
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 128, 0, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 128, 0, destination, 0, {0, 0, 0},
                 {4, 4, 1});
 
     // bytes per row is less than width * bytesPerPixel
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, {0, 0, 0},
                 {65, 1, 1});
 }
 
@@ -490,19 +478,19 @@
         Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst);
 
     // Image height is zero (Valid)
-    TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, {0, 0, 0},
                 {4, 4, 1});
 
     // Image height is equal to copy height (Valid)
-    TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, 0, {0, 0, 0},
                 {4, 4, 1});
 
     // Image height is larger than copy height (Valid)
-    TestB2TCopy(utils::Expectation::Success, source, 0, 256, 4, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Success, source, 0, 256, 4, destination, 0, {0, 0, 0},
                 {4, 4, 1});
 
     // Image height is less than copy height (Invalid)
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 3, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 3, destination, 0, {0, 0, 0},
                 {4, 4, 1});
 }
 
@@ -514,16 +502,16 @@
         Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst);
 
     // Correct usage
-    TestB2TCopy(utils::Expectation::Success, source, bufferSize - 4, 256, 0, destination, 0, 0,
+    TestB2TCopy(utils::Expectation::Success, source, bufferSize - 4, 256, 0, destination, 0,
                 {0, 0, 0}, {1, 1, 1});
 
     // Incorrect usages
     {
-        TestB2TCopy(utils::Expectation::Failure, source, bufferSize - 5, 256, 0, destination, 0, 0,
+        TestB2TCopy(utils::Expectation::Failure, source, bufferSize - 5, 256, 0, destination, 0,
                     {0, 0, 0}, {1, 1, 1});
-        TestB2TCopy(utils::Expectation::Failure, source, bufferSize - 6, 256, 0, destination, 0, 0,
+        TestB2TCopy(utils::Expectation::Failure, source, bufferSize - 6, 256, 0, destination, 0,
                     {0, 0, 0}, {1, 1, 1});
-        TestB2TCopy(utils::Expectation::Failure, source, bufferSize - 7, 256, 0, destination, 0, 0,
+        TestB2TCopy(utils::Expectation::Failure, source, bufferSize - 7, 256, 0, destination, 0,
                     {0, 0, 0}, {1, 1, 1});
     }
 }
@@ -535,7 +523,7 @@
     wgpu::Texture destination = Create2DTexture(2, 2, 1, 1, wgpu::TextureFormat::RGBA8Unorm,
                                                 wgpu::TextureUsage::CopyDst, 4);
 
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, 0, {0, 0, 0},
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, 0, {0, 0, 0},
                 {2, 2, 1});
 }
 
@@ -552,7 +540,7 @@
 
     wgpu::BufferCopyView errorBufferCopyView = utils::CreateBufferCopyView(errorBuffer, 0, 0, 0);
     wgpu::TextureCopyView errorTextureCopyView =
-        utils::CreateTextureCopyView(errorTexture, 0, 0, {1, 1, 1});
+        utils::CreateTextureCopyView(errorTexture, 0, {0, 0, 0});
 
     wgpu::Extent3D extent3D = {1, 1, 1};
 
@@ -560,7 +548,7 @@
         wgpu::Texture destination = Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm,
                                                     wgpu::TextureUsage::CopyDst);
         wgpu::TextureCopyView textureCopyView =
-            utils::CreateTextureCopyView(destination, 0, 0, {1, 1, 1});
+            utils::CreateTextureCopyView(destination, 0, {0, 0, 0});
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         encoder.CopyBufferToTexture(&errorBufferCopyView, &textureCopyView, &extent3D);
@@ -597,7 +585,7 @@
             wgpu::Buffer source = CreateBuffer(kInvalidBufferSize, wgpu::BufferUsage::CopySrc);
             wgpu::Texture destination =
                 Create2DTexture(kWidth, kHeight, 1, 1, format, wgpu::TextureUsage::CopyDst);
-            TestB2TCopy(utils::Expectation::Failure, source, 0, kBytesPerRow, 0, destination, 0, 0,
+            TestB2TCopy(utils::Expectation::Failure, source, 0, kBytesPerRow, 0, destination, 0,
                         {0, 0, 0}, {kWidth, kHeight, 1});
         }
     }
@@ -614,13 +602,13 @@
                 uint32_t invalidBuffferSize = validBufferSize - 1;
                 wgpu::Buffer source = CreateBuffer(invalidBuffferSize, wgpu::BufferUsage::CopySrc);
                 TestB2TCopy(utils::Expectation::Failure, source, 0, kBytesPerRow, 0, destination, 0,
-                            0, {0, 0, 0}, {kWidth, kHeight, 1});
+                            {0, 0, 0}, {kWidth, kHeight, 1});
             }
 
             {
                 wgpu::Buffer source = CreateBuffer(validBufferSize, wgpu::BufferUsage::CopySrc);
                 TestB2TCopy(utils::Expectation::Success, source, 0, kBytesPerRow, 0, destination, 0,
-                            0, {0, 0, 0}, {kWidth, kHeight, 1});
+                            {0, 0, 0}, {kWidth, kHeight, 1});
             }
         }
     }
@@ -635,19 +623,19 @@
         4, 2, maxMipmapLevel, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst);
 
     // Copy to top level mip map
-    TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, maxMipmapLevel - 1, 0,
+    TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, maxMipmapLevel - 1,
                 {0, 0, 0}, {1, 1, 1});
     // Copy to high level mip map
-    TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, maxMipmapLevel - 2, 0,
+    TestB2TCopy(utils::Expectation::Success, source, 0, 256, 0, destination, maxMipmapLevel - 2,
                 {0, 0, 0}, {2, 1, 1});
     // Mip level out of range
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, maxMipmapLevel, 0,
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, maxMipmapLevel,
                 {0, 0, 0}, {1, 1, 1});
     // Copy origin out of range
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, maxMipmapLevel - 2, 0,
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, maxMipmapLevel - 2,
                 {1, 0, 0}, {2, 1, 1});
     // Copy size out of range
-    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, maxMipmapLevel - 2, 0,
+    TestB2TCopy(utils::Expectation::Failure, source, 0, 256, 0, destination, maxMipmapLevel - 2,
                 {0, 0, 0}, {2, 2, 1});
 }
 
@@ -663,45 +651,45 @@
     // Different copies, including some that touch the OOB condition
     {
         // Copy from 4x4 block in corner of first mip.
-        TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
+        TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, 256, 0,
                     {4, 4, 1});
         // Copy from 4x4 block in opposite corner of first mip.
-        TestT2BCopy(utils::Expectation::Success, source, 0, 0, {12, 12, 0}, destination, 0, 256, 0,
+        TestT2BCopy(utils::Expectation::Success, source, 0, {12, 12, 0}, destination, 0, 256, 0,
                     {4, 4, 1});
         // Copy from 4x4 block in the 4x4 mip.
-        TestT2BCopy(utils::Expectation::Success, source, 2, 0, {0, 0, 0}, destination, 0, 256, 0,
+        TestT2BCopy(utils::Expectation::Success, source, 2, {0, 0, 0}, destination, 0, 256, 0,
                     {4, 4, 1});
         // Copy with a buffer offset
-        TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination,
-                    bufferSize - 4, 256, 0, {1, 1, 1});
+        TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, bufferSize - 4,
+                    256, 0, {1, 1, 1});
     }
 
     // Copies with a 256-byte aligned bytes per row but unaligned texture region
     {
         // Unaligned region
-        TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
+        TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, 256, 0,
                     {3, 4, 1});
         // Unaligned region with texture offset
-        TestT2BCopy(utils::Expectation::Success, source, 0, 0, {5, 7, 0}, destination, 0, 256, 0,
+        TestT2BCopy(utils::Expectation::Success, source, 0, {5, 7, 0}, destination, 0, 256, 0,
                     {2, 3, 1});
         // Unaligned region, with buffer offset
-        TestT2BCopy(utils::Expectation::Success, source, 2, 0, {0, 0, 0}, destination, 31 * 4, 256,
-                    0, {3, 3, 1});
+        TestT2BCopy(utils::Expectation::Success, source, 2, {0, 0, 0}, destination, 31 * 4, 256, 0,
+                    {3, 3, 1});
     }
 
     // Empty copies are valid
     {
         // An empty copy
-        TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 0, 0,
+        TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, 0, 0,
                     {0, 0, 1});
         // An empty copy with depth = 0
-        TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 0, 0,
+        TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, 0, 0,
                     {0, 0, 0});
         // An empty copy touching the end of the buffer
-        TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, bufferSize,
-                    0, 0, {0, 0, 1});
+        TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, bufferSize, 0,
+                    0, {0, 0, 1});
         // An empty copy touching the side of the texture
-        TestT2BCopy(utils::Expectation::Success, source, 0, 0, {16, 16, 0}, destination, 0, 0, 0,
+        TestT2BCopy(utils::Expectation::Success, source, 0, {16, 16, 0}, destination, 0, 0, 0,
                     {0, 0, 1});
     }
 }
@@ -714,20 +702,19 @@
     wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst);
 
     // OOB on the texture because x + width overflows
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {13, 12, 0}, destination, 0, 256, 0,
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {13, 12, 0}, destination, 0, 256, 0,
                 {4, 4, 1});
 
     // OOB on the texture because y + width overflows
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {12, 13, 0}, destination, 0, 256, 0,
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {12, 13, 0}, destination, 0, 256, 0,
                 {4, 4, 1});
 
     // OOB on the texture because we overflow a non-zero mip
-    TestT2BCopy(utils::Expectation::Failure, source, 2, 0, {1, 0, 0}, destination, 0, 256, 0,
+    TestT2BCopy(utils::Expectation::Failure, source, 2, {1, 0, 0}, destination, 0, 256, 0,
                 {4, 4, 1});
 
     // OOB on the texture even on an empty copy when we copy from a non-existent mip.
-    TestT2BCopy(utils::Expectation::Failure, source, 5, 0, {0, 0, 0}, destination, 0, 0, 0,
-                {0, 0, 1});
+    TestT2BCopy(utils::Expectation::Failure, source, 5, {0, 0, 0}, destination, 0, 0, 0, {0, 0, 1});
 }
 
 // Test OOB conditions on the buffer
@@ -738,16 +725,16 @@
     wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst);
 
     // OOB on the buffer because we copy too many pixels
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, 256, 0,
                 {4, 5, 1});
 
     // OOB on the buffer because of the offset
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 4, 256, 0,
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 4, 256, 0,
                 {4, 4, 1});
 
     // OOB on the buffer because (bytes per row * (height - 1) + width * bytesPerPixel) * depth
     // overflows
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 512, 0,
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, 512, 0,
                 {4, 3, 1});
 
     // Not OOB on the buffer although bytes per row * height overflows
@@ -758,25 +745,20 @@
             << "bytes per row * height should overflow buffer";
         wgpu::Buffer destinationBuffer =
             CreateBuffer(destinationBufferSize, wgpu::BufferUsage::CopyDst);
-        TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destinationBuffer, 0, 256,
-                    0, {7, 3, 1});
+        TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destinationBuffer, 0, 256, 0,
+                    {7, 3, 1});
     }
 }
 
-// Test that we force Z=0 and Depth=1 on copies from to 2D textures
-TEST_F(CopyCommandTest_T2B, ZDepthConstraintFor2DTextures) {
+// Test that we force Depth=1 on copies from to 2D textures
+TEST_F(CopyCommandTest_T2B, DepthConstraintFor2DTextures) {
     uint64_t bufferSize = BufferSizeForTextureCopy(4, 4, 1);
     wgpu::Texture source =
         Create2DTexture(16, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc);
     wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst);
 
-    // Z=1 on an empty copy still errors
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 1}, destination, 0, 0, 0,
-                {0, 0, 1});
-
     // Depth > 1 on an empty copy still errors
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 0, 0,
-                {0, 0, 2});
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, 0, 0, {0, 0, 2});
 }
 
 // Test T2B copies with incorrect buffer usage
@@ -790,11 +772,11 @@
     wgpu::Buffer vertex = CreateBuffer(bufferSize, wgpu::BufferUsage::Vertex);
 
     // Incorrect source usage
-    TestT2BCopy(utils::Expectation::Failure, sampled, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
+    TestT2BCopy(utils::Expectation::Failure, sampled, 0, {0, 0, 0}, destination, 0, 256, 0,
                 {4, 4, 1});
 
     // Incorrect destination usage
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, vertex, 0, 256, 0, {4, 4, 1});
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, vertex, 0, 256, 0, {4, 4, 1});
 }
 
 TEST_F(CopyCommandTest_T2B, IncorrectBytesPerRow) {
@@ -804,15 +786,15 @@
     wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc);
 
     // bytes per row is 0
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, 256, 0,
                 {64, 4, 1});
 
     // bytes per row is not 256-byte aligned
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 257, 0,
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, 257, 0,
                 {4, 4, 1});
 
     // bytes per row is less than width * bytesPerPixel
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, 256, 0,
                 {65, 1, 1});
 }
 
@@ -823,19 +805,19 @@
     wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst);
 
     // Image height is zero (Valid)
-    TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
+    TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, 256, 0,
                 {4, 4, 1});
 
     // Image height is equal to copy height (Valid)
-    TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 256, 4,
+    TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, 256, 4,
                 {4, 4, 1});
 
     // Image height exceeds copy height (Valid)
-    TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 256, 5,
+    TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, 256, 5,
                 {4, 4, 1});
 
     // Image height is less than copy height (Invalid)
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 3,
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, 256, 3,
                 {4, 4, 1});
 }
 
@@ -847,16 +829,16 @@
     wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst);
 
     // Correct usage
-    TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, bufferSize - 4,
-                256, 0, {1, 1, 1});
+    TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, bufferSize - 4, 256,
+                0, {1, 1, 1});
 
     // Incorrect usages
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, bufferSize - 5,
-                256, 0, {1, 1, 1});
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, bufferSize - 6,
-                256, 0, {1, 1, 1});
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, bufferSize - 7,
-                256, 0, {1, 1, 1});
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, bufferSize - 5, 256,
+                0, {1, 1, 1});
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, bufferSize - 6, 256,
+                0, {1, 1, 1});
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, bufferSize - 7, 256,
+                0, {1, 1, 1});
 }
 
 // Test multisampled textures cannot be used in T2B copies.
@@ -866,7 +848,7 @@
     uint64_t bufferSize = BufferSizeForTextureCopy(16, 16, 1);
     wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst);
 
-    TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
+    TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, 256, 0,
                 {2, 2, 1});
 }
 
@@ -883,7 +865,7 @@
 
     wgpu::BufferCopyView errorBufferCopyView = utils::CreateBufferCopyView(errorBuffer, 0, 0, 0);
     wgpu::TextureCopyView errorTextureCopyView =
-        utils::CreateTextureCopyView(errorTexture, 0, 0, {1, 1, 1});
+        utils::CreateTextureCopyView(errorTexture, 0, {0, 0, 0});
 
     wgpu::Extent3D extent3D = {1, 1, 1};
 
@@ -902,7 +884,7 @@
         wgpu::Texture destination = Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm,
                                                     wgpu::TextureUsage::CopyDst);
         wgpu::TextureCopyView textureCopyView =
-            utils::CreateTextureCopyView(destination, 0, 0, {1, 1, 1});
+            utils::CreateTextureCopyView(destination, 0, {0, 0, 0});
 
         wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
         encoder.CopyTextureToBuffer(&textureCopyView, &errorBufferCopyView, &extent3D);
@@ -929,7 +911,7 @@
                 Create2DTexture(kWidth, kHeight, 1, 1, format, wgpu::TextureUsage::CopyDst);
 
             wgpu::Buffer destination = CreateBuffer(kInvalidBufferSize, wgpu::BufferUsage::CopySrc);
-            TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0,
+            TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0,
                         kBytesPerRow, 0, {kWidth, kHeight, 1});
         }
     }
@@ -946,14 +928,14 @@
                 uint32_t invalidBufferSize = validBufferSize - 1;
                 wgpu::Buffer destination =
                     CreateBuffer(invalidBufferSize, wgpu::BufferUsage::CopyDst);
-                TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0,
+                TestT2BCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0,
                             kBytesPerRow, 0, {kWidth, kHeight, 1});
             }
 
             {
                 wgpu::Buffer destination =
                     CreateBuffer(validBufferSize, wgpu::BufferUsage::CopyDst);
-                TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0,
+                TestT2BCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0,
                             kBytesPerRow, 0, {kWidth, kHeight, 1});
             }
         }
@@ -969,20 +951,20 @@
     wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopyDst);
 
     // Copy from top level mip map
-    TestT2BCopy(utils::Expectation::Success, source, maxMipmapLevel - 1, 0, {0, 0, 0}, destination,
-                0, 256, 0, {1, 1, 1});
+    TestT2BCopy(utils::Expectation::Success, source, maxMipmapLevel - 1, {0, 0, 0}, destination, 0,
+                256, 0, {1, 1, 1});
     // Copy from high level mip map
-    TestT2BCopy(utils::Expectation::Success, source, maxMipmapLevel - 2, 0, {0, 0, 0}, destination,
-                0, 256, 0, {2, 1, 1});
-    // Mip level out of range
-    TestT2BCopy(utils::Expectation::Failure, source, maxMipmapLevel, 0, {0, 0, 0}, destination, 0,
+    TestT2BCopy(utils::Expectation::Success, source, maxMipmapLevel - 2, {0, 0, 0}, destination, 0,
                 256, 0, {2, 1, 1});
+    // Mip level out of range
+    TestT2BCopy(utils::Expectation::Failure, source, maxMipmapLevel, {0, 0, 0}, destination, 0, 256,
+                0, {2, 1, 1});
     // Copy origin out of range
-    TestT2BCopy(utils::Expectation::Failure, source, maxMipmapLevel - 2, 0, {2, 0, 0}, destination,
-                0, 256, 0, {2, 1, 1});
+    TestT2BCopy(utils::Expectation::Failure, source, maxMipmapLevel - 2, {2, 0, 0}, destination, 0,
+                256, 0, {2, 1, 1});
     // Copy size out of range
-    TestT2BCopy(utils::Expectation::Failure, source, maxMipmapLevel - 2, 0, {1, 0, 0}, destination,
-                0, 256, 0, {2, 1, 1});
+    TestT2BCopy(utils::Expectation::Failure, source, maxMipmapLevel - 2, {1, 0, 0}, destination, 0,
+                256, 0, {2, 1, 1});
 }
 
 class CopyCommandTest_T2T : public CopyCommandTest {};
@@ -996,57 +978,57 @@
     // Different copies, including some that touch the OOB condition
     {
         // Copy a region along top left boundary
-        TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 0,
-                    {0, 0, 0}, {4, 4, 1});
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, {0, 0, 0},
+                    {4, 4, 1});
 
         // Copy entire texture
-        TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 0,
-                    {0, 0, 0}, {16, 16, 1});
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, {0, 0, 0},
+                    {16, 16, 1});
 
         // Copy a region along bottom right boundary
-        TestT2TCopy(utils::Expectation::Success, source, 0, 0, {8, 8, 0}, destination, 0, 0,
-                    {8, 8, 0}, {8, 8, 1});
+        TestT2TCopy(utils::Expectation::Success, source, 0, {8, 8, 0}, destination, 0, {8, 8, 0},
+                    {8, 8, 1});
 
         // Copy region into mip
-        TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 2, 0,
-                    {0, 0, 0}, {4, 4, 1});
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 2, {0, 0, 0},
+                    {4, 4, 1});
 
         // Copy mip into region
-        TestT2TCopy(utils::Expectation::Success, source, 2, 0, {0, 0, 0}, destination, 0, 0,
-                    {0, 0, 0}, {4, 4, 1});
+        TestT2TCopy(utils::Expectation::Success, source, 2, {0, 0, 0}, destination, 0, {0, 0, 0},
+                    {4, 4, 1});
 
         // Copy between slices
-        TestT2TCopy(utils::Expectation::Success, source, 0, 1, {0, 0, 0}, destination, 0, 1,
-                    {0, 0, 0}, {16, 16, 1});
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 1}, destination, 0, {0, 0, 1},
+                    {16, 16, 1});
 
         // Copy multiple slices (srcTextureCopyView.arrayLayer + copySize.depth ==
         // srcTextureCopyView.texture.arrayLayerCount)
-        TestT2TCopy(utils::Expectation::Success, source, 0, 2, {0, 0, 0}, destination, 0, 0,
-                    {0, 0, 0}, {16, 16, 2});
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 2}, destination, 0, {0, 0, 0},
+                    {16, 16, 2});
 
         // Copy multiple slices (dstTextureCopyView.arrayLayer + copySize.depth ==
         // dstTextureCopyView.texture.arrayLayerCount)
-        TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 2,
-                    {0, 0, 0}, {16, 16, 2});
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, {0, 0, 2},
+                    {16, 16, 2});
     }
 
     // Empty copies are valid
     {
         // An empty copy
-        TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 0,
-                    {0, 0, 0}, {0, 0, 1});
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, {0, 0, 0},
+                    {0, 0, 1});
 
         // An empty copy with depth = 0
-        TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 0,
-                    {0, 0, 0}, {0, 0, 0});
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, {0, 0, 0},
+                    {0, 0, 0});
 
         // An empty copy touching the side of the source texture
-        TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 0,
-                    {16, 16, 0}, {0, 0, 1});
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, {16, 16, 0},
+                    {0, 0, 1});
 
         // An empty copy touching the side of the destination texture
-        TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 0,
-                    {16, 16, 0}, {0, 0, 1});
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, {16, 16, 0},
+                    {0, 0, 1});
     }
 }
 
@@ -1057,11 +1039,11 @@
         Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst);
 
     // Incorrect source usage causes failure
-    TestT2TCopy(utils::Expectation::Failure, destination, 0, 0, {0, 0, 0}, destination, 0, 0,
-                {0, 0, 0}, {16, 16, 1});
+    TestT2TCopy(utils::Expectation::Failure, destination, 0, {0, 0, 0}, destination, 0, {0, 0, 0},
+                {16, 16, 1});
 
     // Incorrect destination usage causes failure
-    TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, source, 0, 0, {0, 0, 0},
+    TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, source, 0, {0, 0, 0},
                 {16, 16, 1});
 }
 
@@ -1074,73 +1056,58 @@
     // OOB on source
     {
         // x + width overflows
-        TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {1, 0, 0}, destination, 0, 0,
-                    {0, 0, 0}, {16, 16, 1});
+        TestT2TCopy(utils::Expectation::Failure, source, 0, {1, 0, 0}, destination, 0, {0, 0, 0},
+                    {16, 16, 1});
 
         // y + height overflows
-        TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 1, 0}, destination, 0, 0,
-                    {0, 0, 0}, {16, 16, 1});
+        TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 1, 0}, destination, 0, {0, 0, 0},
+                    {16, 16, 1});
 
         // non-zero mip overflows
-        TestT2TCopy(utils::Expectation::Failure, source, 1, 0, {0, 0, 0}, destination, 0, 0,
-                    {0, 0, 0}, {9, 9, 1});
+        TestT2TCopy(utils::Expectation::Failure, source, 1, {0, 0, 0}, destination, 0, {0, 0, 0},
+                    {9, 9, 1});
 
         // arrayLayer + depth OOB
-        TestT2TCopy(utils::Expectation::Failure, source, 0, 3, {0, 0, 0}, destination, 0, 0,
-                    {0, 0, 0}, {16, 16, 2});
+        TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 0, 3}, destination, 0, {0, 0, 0},
+                    {16, 16, 2});
 
         // empty copy on non-existent mip fails
-        TestT2TCopy(utils::Expectation::Failure, source, 6, 0, {0, 0, 0}, destination, 0, 0,
-                    {0, 0, 0}, {0, 0, 1});
+        TestT2TCopy(utils::Expectation::Failure, source, 6, {0, 0, 0}, destination, 0, {0, 0, 0},
+                    {0, 0, 1});
 
         // empty copy from non-existent slice fails
-        TestT2TCopy(utils::Expectation::Failure, source, 0, 4, {0, 0, 0}, destination, 0, 0,
-                    {0, 0, 0}, {0, 0, 1});
+        TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 0, 4}, destination, 0, {0, 0, 0},
+                    {0, 0, 1});
     }
 
     // OOB on destination
     {
         // x + width overflows
-        TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 0,
-                    {1, 0, 0}, {16, 16, 1});
+        TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, {1, 0, 0},
+                    {16, 16, 1});
 
         // y + height overflows
-        TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 0,
-                    {0, 1, 0}, {16, 16, 1});
+        TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, {0, 1, 0},
+                    {16, 16, 1});
 
         // non-zero mip overflows
-        TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 1, 0,
-                    {0, 0, 0}, {9, 9, 1});
+        TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 1, {0, 0, 0},
+                    {9, 9, 1});
 
         // arrayLayer + depth OOB
-        TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 3,
-                    {0, 0, 0}, {16, 16, 2});
+        TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, {0, 0, 3},
+                    {16, 16, 2});
 
         // empty copy on non-existent mip fails
-        TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 6, 0,
-                    {0, 0, 0}, {0, 0, 1});
+        TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 6, {0, 0, 0},
+                    {0, 0, 1});
 
         // empty copy on non-existent slice fails
-        TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 4,
-                    {0, 0, 0}, {0, 0, 1});
+        TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, {0, 0, 4},
+                    {0, 0, 1});
     }
 }
 
-TEST_F(CopyCommandTest_T2T, 2DTextureDepthConstraints) {
-    wgpu::Texture source =
-        Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc);
-    wgpu::Texture destination =
-        Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst);
-
-    // Empty copy on source with z > 0 fails
-    TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 1}, destination, 0, 0, {0, 0, 0},
-                {0, 0, 1});
-
-    // Empty copy on destination with z > 0 fails
-    TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 0, {0, 0, 1},
-                {0, 0, 1});
-}
-
 TEST_F(CopyCommandTest_T2T, 2DTextureDepthStencil) {
     wgpu::Texture source = Create2DTexture(16, 16, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8,
                                            wgpu::TextureUsage::CopySrc);
@@ -1148,11 +1115,11 @@
         16, 16, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureUsage::CopyDst);
 
     // Success when entire depth stencil subresource is copied
-    TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 0, {0, 0, 0},
+    TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, {0, 0, 0},
                 {16, 16, 1});
 
     // Failure when depth stencil subresource is partially copied
-    TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 0, {0, 0, 0},
+    TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, {0, 0, 0},
                 {15, 15, 1});
 }
 
@@ -1164,7 +1131,7 @@
             16, 16, 1, 1, wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureUsage::CopyDst);
 
         // Success when entire depth stencil subresource (layer) is the copy source
-        TestT2TCopy(utils::Expectation::Success, source, 0, 1, {0, 0, 0}, destination, 0, 0, {0, 0, 0},
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 1}, destination, 0, {0, 0, 0},
                     {16, 16, 1});
     }
 
@@ -1175,7 +1142,7 @@
             16, 16, 1, 3, wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureUsage::CopyDst);
 
         // Success when entire depth stencil subresource (layer) is the copy destination
-        TestT2TCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0, 1, {0, 0, 0},
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, {0, 0, 1},
                     {16, 16, 1});
     }
 
@@ -1186,11 +1153,11 @@
             16, 16, 1, 3, wgpu::TextureFormat::Depth24PlusStencil8, wgpu::TextureUsage::CopyDst);
 
         // Success when src and dst are an entire depth stencil subresource (layer)
-        TestT2TCopy(utils::Expectation::Success, source, 0, 2, {0, 0, 0}, destination, 0, 1, {0, 0, 0},
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 2}, destination, 0, {0, 0, 1},
                     {16, 16, 1});
 
         // Success when src and dst are an array of entire depth stencil subresources
-        TestT2TCopy(utils::Expectation::Success, source, 0, 1, {0, 0, 0}, destination, 0, 0, {0, 0, 0},
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 1}, destination, 0, {0, 0, 0},
                     {16, 16, 2});
     }
 }
@@ -1202,7 +1169,7 @@
         Create2DTexture(16, 16, 5, 2, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst);
 
     // Failure when formats don't match
-    TestT2TCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 0, {0, 0, 0},
+    TestT2TCopy(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0, {0, 0, 0},
                 {0, 0, 1});
 }
 
@@ -1216,19 +1183,19 @@
 
     // Success when entire multisampled subresource is copied
     {
-        TestT2TCopy(utils::Expectation::Success, sourceMultiSampled4x, 0, 0, {0, 0, 0},
-                    destinationMultiSampled4x, 0, 0, {0, 0, 0}, {16, 16, 1});
+        TestT2TCopy(utils::Expectation::Success, sourceMultiSampled4x, 0, {0, 0, 0},
+                    destinationMultiSampled4x, 0, {0, 0, 0}, {16, 16, 1});
     }
 
     // Failures
     {
         // An empty copy with mismatched samples fails
-        TestT2TCopy(utils::Expectation::Failure, sourceMultiSampled1x, 0, 0, {0, 0, 0},
-                    destinationMultiSampled4x, 0, 0, {0, 0, 0}, {0, 0, 1});
+        TestT2TCopy(utils::Expectation::Failure, sourceMultiSampled1x, 0, {0, 0, 0},
+                    destinationMultiSampled4x, 0, {0, 0, 0}, {0, 0, 1});
 
         // A copy fails when samples are greater than 1, and entire subresource isn't copied
-        TestT2TCopy(utils::Expectation::Failure, sourceMultiSampled4x, 0, 0, {0, 0, 0},
-                    destinationMultiSampled4x, 0, 0, {0, 0, 0}, {15, 15, 1});
+        TestT2TCopy(utils::Expectation::Failure, sourceMultiSampled4x, 0, {0, 0, 0},
+                    destinationMultiSampled4x, 0, {0, 0, 0}, {15, 15, 1});
     }
 }
 
@@ -1240,20 +1207,20 @@
     wgpu::Texture destination = Create2DTexture(
         4, 2, maxMipmapLevel, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopyDst);
     // Copy to top level mip map
-    TestT2TCopy(utils::Expectation::Success, source, maxMipmapLevel - 1, 0, {0, 0, 0}, destination,
-                maxMipmapLevel - 1, 0, {0, 0, 0}, {1, 1, 1});
+    TestT2TCopy(utils::Expectation::Success, source, maxMipmapLevel - 1, {0, 0, 0}, destination,
+                maxMipmapLevel - 1, {0, 0, 0}, {1, 1, 1});
     // Copy to high level mip map
-    TestT2TCopy(utils::Expectation::Success, source, maxMipmapLevel - 2, 0, {0, 0, 0}, destination,
-                maxMipmapLevel - 2, 0, {0, 0, 0}, {2, 1, 1});
+    TestT2TCopy(utils::Expectation::Success, source, maxMipmapLevel - 2, {0, 0, 0}, destination,
+                maxMipmapLevel - 2, {0, 0, 0}, {2, 1, 1});
     // Mip level out of range
-    TestT2TCopy(utils::Expectation::Failure, source, maxMipmapLevel, 0, {0, 0, 0}, destination,
-                maxMipmapLevel, 0, {0, 0, 0}, {2, 1, 1});
+    TestT2TCopy(utils::Expectation::Failure, source, maxMipmapLevel, {0, 0, 0}, destination,
+                maxMipmapLevel, {0, 0, 0}, {2, 1, 1});
     // Copy origin out of range
-    TestT2TCopy(utils::Expectation::Failure, source, maxMipmapLevel - 2, 0, {2, 0, 0}, destination,
-                maxMipmapLevel - 2, 0, {2, 0, 0}, {2, 1, 1});
+    TestT2TCopy(utils::Expectation::Failure, source, maxMipmapLevel - 2, {2, 0, 0}, destination,
+                maxMipmapLevel - 2, {2, 0, 0}, {2, 1, 1});
     // Copy size out of range
-    TestT2TCopy(utils::Expectation::Failure, source, maxMipmapLevel - 2, 0, {1, 0, 0}, destination,
-                maxMipmapLevel - 2, 0, {0, 0, 0}, {2, 1, 1});
+    TestT2TCopy(utils::Expectation::Failure, source, maxMipmapLevel - 2, {1, 0, 0}, destination,
+                maxMipmapLevel - 2, {0, 0, 0}, {2, 1, 1});
 }
 
 // Test copy within the same texture
@@ -1270,15 +1237,15 @@
         // copyExtent.z == 1
         {
             constexpr uint32_t kCopyArrayLayerCount = 1;
-            TestT2TCopy(utils::Expectation::Failure, texture, 0, kBaseArrayLayer, {0, 0, 0},
-                        texture, 0, kBaseArrayLayer, {2, 2, 0}, {1, 1, kCopyArrayLayerCount});
+            TestT2TCopy(utils::Expectation::Failure, texture, 0, {0, 0, kBaseArrayLayer}, texture,
+                        0, {2, 2, kBaseArrayLayer}, {1, 1, kCopyArrayLayerCount});
         }
 
         // copyExtent.z > 1
         {
             constexpr uint32_t kCopyArrayLayerCount = 2;
-            TestT2TCopy(utils::Expectation::Failure, texture, 0, kBaseArrayLayer, {0, 0, 0},
-                        texture, 0, kBaseArrayLayer, {2, 2, 0}, {1, 1, kCopyArrayLayerCount});
+            TestT2TCopy(utils::Expectation::Failure, texture, 0, {0, 0, kBaseArrayLayer}, texture,
+                        0, {2, 2, kBaseArrayLayer}, {1, 1, kCopyArrayLayerCount});
         }
     }
 
@@ -1292,16 +1259,16 @@
             constexpr uint32_t kSrcBaseArrayLayer = 0;
             constexpr uint32_t kDstBaseArrayLayer = kSrcBaseArrayLayer + kCopyArrayLayerCount;
 
-            TestT2TCopy(utils::Expectation::Success, texture, 0, kSrcBaseArrayLayer, {0, 0, 0},
-                        texture, 0, kDstBaseArrayLayer, {0, 0, 0}, {1, 1, kCopyArrayLayerCount});
+            TestT2TCopy(utils::Expectation::Success, texture, 0, {0, 0, kSrcBaseArrayLayer},
+                        texture, 0, {0, 0, kDstBaseArrayLayer}, {1, 1, kCopyArrayLayerCount});
         }
 
         // srcBaseArrayLayer > dstBaseArrayLayer
         {
             constexpr uint32_t kSrcBaseArrayLayer = 2;
             constexpr uint32_t kDstBaseArrayLayer = kSrcBaseArrayLayer - kCopyArrayLayerCount;
-            TestT2TCopy(utils::Expectation::Success, texture, 0, kSrcBaseArrayLayer, {0, 0, 0},
-                        texture, 0, kDstBaseArrayLayer, {0, 0, 0}, {1, 1, kCopyArrayLayerCount});
+            TestT2TCopy(utils::Expectation::Success, texture, 0, {0, 0, kSrcBaseArrayLayer},
+                        texture, 0, {0, 0, kDstBaseArrayLayer}, {1, 1, kCopyArrayLayerCount});
         }
     }
 
@@ -1313,8 +1280,8 @@
         // Copy one slice
         {
             constexpr uint32_t kCopyArrayLayerCount = 1;
-            TestT2TCopy(utils::Expectation::Success, texture, kSrcMipLevel, 0, {0, 0, 0}, texture,
-                        kDstMipLevel, 0, {1, 1, 0}, {1, 1, kCopyArrayLayerCount});
+            TestT2TCopy(utils::Expectation::Success, texture, kSrcMipLevel, {0, 0, 0}, texture,
+                        kDstMipLevel, {1, 1, 0}, {1, 1, kCopyArrayLayerCount});
         }
 
         // The base array layer of the copy source is equal to that of the copy destination.
@@ -1322,8 +1289,8 @@
             constexpr uint32_t kCopyArrayLayerCount = 2;
             constexpr uint32_t kBaseArrayLayer = 0;
 
-            TestT2TCopy(utils::Expectation::Success, texture, kSrcMipLevel, kBaseArrayLayer,
-                        {0, 0, 0}, texture, kDstMipLevel, kBaseArrayLayer, {1, 1, 0},
+            TestT2TCopy(utils::Expectation::Success, texture, kSrcMipLevel, {0, 0, kBaseArrayLayer},
+                        texture, kDstMipLevel, {1, 1, kBaseArrayLayer},
                         {1, 1, kCopyArrayLayerCount});
         }
 
@@ -1336,12 +1303,11 @@
             constexpr uint32_t kDstBaseArrayLayer = 1;
             ASSERT(kSrcBaseArrayLayer + kCopyArrayLayerCount > kDstBaseArrayLayer);
 
-            constexpr wgpu::Origin3D kCopyOrigin = {0, 0, 0};
             constexpr wgpu::Extent3D kCopyExtent = {1, 1, kCopyArrayLayerCount};
 
-            TestT2TCopy(utils::Expectation::Success, texture, kSrcMipLevel, kSrcBaseArrayLayer,
-                        kCopyOrigin, texture, kDstMipLevel, kDstBaseArrayLayer, kCopyOrigin,
-                        kCopyExtent);
+            TestT2TCopy(utils::Expectation::Success, texture, kSrcMipLevel,
+                        {0, 0, kSrcBaseArrayLayer}, texture, kDstMipLevel,
+                        {0, 0, kDstBaseArrayLayer}, kCopyExtent);
         }
     }
 
@@ -1356,14 +1322,14 @@
 
         constexpr wgpu::Extent3D kCopyExtent = {4, 4, kCopyArrayLayerCount};
 
-        const wgpu::Origin3D srcOrigin = {0, 0, 0};
-        const wgpu::Origin3D dstOrigin = {4, 4, 0};
-        TestT2TCopy(utils::Expectation::Failure, texture, kMipmapLevel, kMinBaseArrayLayer,
-                    srcOrigin, texture, kMipmapLevel, kMaxBaseArrayLayer, dstOrigin, kCopyExtent);
+        const wgpu::Origin3D srcOrigin = {0, 0, kMinBaseArrayLayer};
+        const wgpu::Origin3D dstOrigin = {4, 4, kMaxBaseArrayLayer};
+        TestT2TCopy(utils::Expectation::Failure, texture, kMipmapLevel, srcOrigin, texture,
+                    kMipmapLevel, dstOrigin, kCopyExtent);
     }
 
     // Copy between different mipmap levels and array slices is allowed.
-    TestT2TCopy(utils::Expectation::Success, texture, 0, 1, {0, 0, 0}, texture, 1, 0, {1, 1, 0},
+    TestT2TCopy(utils::Expectation::Success, texture, 0, {0, 0, 1}, texture, 1, {1, 1, 0},
                 {1, 1, 1});
 }
 
@@ -1416,29 +1382,24 @@
                           uint32_t rowsPerImage,
                           wgpu::Texture texture,
                           uint32_t level,
-                          uint32_t arraySlice,
                           wgpu::Origin3D origin,
                           wgpu::Extent3D extent3D) {
         TestB2TCopy(expectation, buffer, bufferOffset, bufferBytesPerRow, rowsPerImage, texture,
-                    level, arraySlice, origin, extent3D);
-        TestT2BCopy(expectation, texture, level, arraySlice, origin, buffer, bufferOffset,
-                    bufferBytesPerRow, rowsPerImage, extent3D);
+                    level, origin, extent3D);
+        TestT2BCopy(expectation, texture, level, origin, buffer, bufferOffset, bufferBytesPerRow,
+                    rowsPerImage, extent3D);
     }
 
     void TestBothT2TCopies(utils::Expectation expectation,
                            wgpu::Texture texture1,
                            uint32_t level1,
-                           uint32_t slice1,
                            wgpu::Origin3D origin1,
                            wgpu::Texture texture2,
                            uint32_t level2,
-                           uint32_t slice2,
                            wgpu::Origin3D origin2,
                            wgpu::Extent3D extent3D) {
-        TestT2TCopy(expectation, texture1, level1, slice1, origin1, texture2, level2, slice2,
-                    origin2, extent3D);
-        TestT2TCopy(expectation, texture2, level2, slice2, origin2, texture1, level1, slice1,
-                    origin1, extent3D);
+        TestT2TCopy(expectation, texture1, level1, origin1, texture2, level2, origin2, extent3D);
+        TestT2TCopy(expectation, texture2, level2, origin2, texture1, level1, origin1, extent3D);
     }
 
     static constexpr uint32_t kWidth = 16;
@@ -1467,14 +1428,14 @@
         {
             uint32_t validBufferOffset = CompressedFormatBlockSizeInBytes(bcFormat);
             TestBothTBCopies(utils::Expectation::Success, buffer, validBufferOffset, 256, 4,
-                             texture, 0, 0, {0, 0, 0}, {4, 4, 1});
+                             texture, 0, {0, 0, 0}, {4, 4, 1});
         }
 
         // Failures on invalid bufferOffset.
         {
             uint32_t kInvalidBufferOffset = CompressedFormatBlockSizeInBytes(bcFormat) / 2;
             TestBothTBCopies(utils::Expectation::Failure, buffer, kInvalidBufferOffset, 256, 4,
-                             texture, 0, 0, {0, 0, 0}, {4, 4, 1});
+                             texture, 0, {0, 0, 0}, {4, 4, 1});
         }
     }
 }
@@ -1496,7 +1457,7 @@
             for (wgpu::TextureFormat bcFormat : kBCFormats) {
                 wgpu::Texture texture = Create2DTexture(bcFormat, 1, kTestWidth, kTestHeight);
                 TestBothTBCopies(utils::Expectation::Failure, buffer, 0, kSmallBytesPerRow, 4,
-                                 texture, 0, 0, {0, 0, 0}, {kTestWidth, 4, 1});
+                                 texture, 0, {0, 0, 0}, {kTestWidth, 4, 1});
             }
         }
 
@@ -1508,7 +1469,7 @@
                     kTestWidth / 4 * CompressedFormatBlockSizeInBytes(bcFormat);
                 ASSERT_NE(0u, inValidBytesPerRow % 256);
                 TestBothTBCopies(utils::Expectation::Failure, buffer, 0, inValidBytesPerRow, 4,
-                                 texture, 0, 0, {0, 0, 0}, {kTestWidth, 4, 1});
+                                 texture, 0, {0, 0, 0}, {kTestWidth, 4, 1});
             }
         }
 
@@ -1519,7 +1480,7 @@
                 uint32_t smallestValidBytesPerRow =
                     Align(kTestWidth / 4 * CompressedFormatBlockSizeInBytes(bcFormat), 256);
                 TestBothTBCopies(utils::Expectation::Success, buffer, 0, smallestValidBytesPerRow,
-                                 4, texture, 0, 0, {0, 0, 0}, {kTestWidth, 4, 1});
+                                 4, texture, 0, {0, 0, 0}, {kTestWidth, 4, 1});
             }
         }
     }
@@ -1538,14 +1499,14 @@
         {
             constexpr uint32_t kValidImageHeight = 8;
             TestBothTBCopies(utils::Expectation::Success, buffer, 0, 256, kValidImageHeight,
-                             texture, 0, 0, {0, 0, 0}, {4, 4, 1});
+                             texture, 0, {0, 0, 0}, {4, 4, 1});
         }
 
         // Failures on invalid rowsPerImage.
         {
             constexpr uint32_t kInvalidImageHeight = 3;
             TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, kInvalidImageHeight,
-                             texture, 0, 0, {0, 0, 0}, {4, 4, 1});
+                             texture, 0, {0, 0, 0}, {4, 4, 1});
         }
     }
 }
@@ -1565,9 +1526,9 @@
 
         // Valid usages of ImageOffset in B2T, T2B and T2T copies with compressed texture formats.
         {
-            TestBothTBCopies(utils::Expectation::Success, buffer, 0, 256, 4, texture, 0, 0,
+            TestBothTBCopies(utils::Expectation::Success, buffer, 0, 256, 4, texture, 0,
                              kSmallestValidOrigin3D, {4, 4, 1});
-            TestBothT2TCopies(utils::Expectation::Success, texture, 0, 0, {0, 0, 0}, texture2, 0, 0,
+            TestBothT2TCopies(utils::Expectation::Success, texture, 0, {0, 0, 0}, texture2, 0,
                               kSmallestValidOrigin3D, {4, 4, 1});
         }
 
@@ -1575,20 +1536,20 @@
         {
             constexpr wgpu::Origin3D kInvalidOrigin3D = {kSmallestValidOrigin3D.x - 1,
                                                          kSmallestValidOrigin3D.y, 0};
-            TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0, 0,
+            TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0,
                              kInvalidOrigin3D, {4, 4, 1});
-            TestBothT2TCopies(utils::Expectation::Failure, texture, 0, 0, kInvalidOrigin3D,
-                              texture2, 0, 0, {0, 0, 0}, {4, 4, 1});
+            TestBothT2TCopies(utils::Expectation::Failure, texture, 0, kInvalidOrigin3D, texture2,
+                              0, {0, 0, 0}, {4, 4, 1});
         }
 
         // Failures on invalid ImageOffset.y.
         {
             constexpr wgpu::Origin3D kInvalidOrigin3D = {kSmallestValidOrigin3D.x,
                                                          kSmallestValidOrigin3D.y - 1, 0};
-            TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0, 0,
+            TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0,
                              kInvalidOrigin3D, {4, 4, 1});
-            TestBothT2TCopies(utils::Expectation::Failure, texture, 0, 0, kInvalidOrigin3D,
-                              texture2, 0, 0, {0, 0, 0}, {4, 4, 1});
+            TestBothT2TCopies(utils::Expectation::Failure, texture, 0, kInvalidOrigin3D, texture2,
+                              0, {0, 0, 0}, {4, 4, 1});
         }
     }
 }
@@ -1612,9 +1573,9 @@
 
         // Valid usages of ImageExtent in B2T, T2B and T2T copies with compressed texture formats.
         {
-            TestBothTBCopies(utils::Expectation::Success, buffer, 0, 256, 8, texture, 0, 0,
-                             {0, 0, 0}, kSmallestValidExtent3D);
-            TestBothT2TCopies(utils::Expectation::Success, texture, 0, 0, {0, 0, 0}, texture2, 0, 0,
+            TestBothTBCopies(utils::Expectation::Success, buffer, 0, 256, 8, texture, 0, {0, 0, 0},
+                             kSmallestValidExtent3D);
+            TestBothT2TCopies(utils::Expectation::Success, texture, 0, {0, 0, 0}, texture2, 0,
                               {0, 0, 0}, kSmallestValidExtent3D);
         }
 
@@ -1627,18 +1588,18 @@
                 (kTestHeight >> kTestMipmapLevel) - kSmallestValidExtent3D.height + 1, 0};
 
             TestBothTBCopies(utils::Expectation::Success, buffer, 0, 256, 4, texture,
-                             kTestMipmapLevel, 0, kTestOrigin, kSmallestValidExtent3D);
-            TestBothT2TCopies(utils::Expectation::Success, texture, kTestMipmapLevel, 0,
-                              kTestOrigin, texture2, 0, 0, {0, 0, 0}, kSmallestValidExtent3D);
+                             kTestMipmapLevel, kTestOrigin, kSmallestValidExtent3D);
+            TestBothT2TCopies(utils::Expectation::Success, texture, kTestMipmapLevel, kTestOrigin,
+                              texture2, 0, {0, 0, 0}, kSmallestValidExtent3D);
         }
 
         // Failures on invalid ImageExtent.x.
         {
             constexpr wgpu::Extent3D kInValidExtent3D = {kSmallestValidExtent3D.width - 1,
                                                          kSmallestValidExtent3D.height, 1};
-            TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0, 0,
-                             {0, 0, 0}, kInValidExtent3D);
-            TestBothT2TCopies(utils::Expectation::Failure, texture, 0, 0, {0, 0, 0}, texture2, 0, 0,
+            TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0, {0, 0, 0},
+                             kInValidExtent3D);
+            TestBothT2TCopies(utils::Expectation::Failure, texture, 0, {0, 0, 0}, texture2, 0,
                               {0, 0, 0}, kInValidExtent3D);
         }
 
@@ -1646,9 +1607,9 @@
         {
             constexpr wgpu::Extent3D kInValidExtent3D = {kSmallestValidExtent3D.width,
                                                          kSmallestValidExtent3D.height - 1, 1};
-            TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0, 0,
-                             {0, 0, 0}, kInValidExtent3D);
-            TestBothT2TCopies(utils::Expectation::Failure, texture, 0, 0, {0, 0, 0}, texture2, 0, 0,
+            TestBothTBCopies(utils::Expectation::Failure, buffer, 0, 256, 4, texture, 0, {0, 0, 0},
+                             kInValidExtent3D);
+            TestBothT2TCopies(utils::Expectation::Failure, texture, 0, {0, 0, 0}, texture2, 0,
                               {0, 0, 0}, kInValidExtent3D);
         }
     }
diff --git a/src/tests/unittests/validation/ResourceUsageTrackingTests.cpp b/src/tests/unittests/validation/ResourceUsageTrackingTests.cpp
index 2590240..2e5c049 100644
--- a/src/tests/unittests/validation/ResourceUsageTrackingTests.cpp
+++ b/src/tests/unittests/validation/ResourceUsageTrackingTests.cpp
@@ -1316,8 +1316,8 @@
         wgpu::TextureView view0 = texture0.CreateView();
         wgpu::TextureView view1 = texture1.CreateView();
 
-        wgpu::TextureCopyView srcView = utils::CreateTextureCopyView(texture0, 0, 0, {0, 0, 0});
-        wgpu::TextureCopyView dstView = utils::CreateTextureCopyView(texture1, 0, 0, {0, 0, 0});
+        wgpu::TextureCopyView srcView = utils::CreateTextureCopyView(texture0, 0, {0, 0, 0});
+        wgpu::TextureCopyView dstView = utils::CreateTextureCopyView(texture1, 0, {0, 0, 0});
         wgpu::Extent3D copySize = {1, 1, 1};
 
         // Use the texture as both copy dst and output attachment in render pass
diff --git a/src/tests/white_box/VulkanImageWrappingTestsDmaBuf.cpp b/src/tests/white_box/VulkanImageWrappingTestsDmaBuf.cpp
index 3fc0660..95d69c1 100644
--- a/src/tests/white_box/VulkanImageWrappingTestsDmaBuf.cpp
+++ b/src/tests/white_box/VulkanImageWrappingTestsDmaBuf.cpp
@@ -808,7 +808,7 @@
             wgpu::BufferCopyView copySrc =
                 utils::CreateBufferCopyView(copySrcBuffer, 0, bytesPerRow, 0);
             wgpu::TextureCopyView copyDst =
-                utils::CreateTextureCopyView(wrappedTexture, 0, 0, {0, 0, 0});
+                utils::CreateTextureCopyView(wrappedTexture, 0, {0, 0, 0});
             wgpu::Extent3D copySize = {width, height, 1};
 
             wgpu::CommandEncoder encoder = secondDevice.CreateCommandEncoder();
@@ -832,7 +832,7 @@
         wgpu::Buffer copyDstBuffer = device.CreateBuffer(&copyDesc);
         {
             wgpu::TextureCopyView copySrc =
-                utils::CreateTextureCopyView(nextWrappedTexture, 0, 0, {0, 0, 0});
+                utils::CreateTextureCopyView(nextWrappedTexture, 0, {0, 0, 0});
             wgpu::BufferCopyView copyDst =
                 utils::CreateBufferCopyView(copyDstBuffer, 0, bytesPerRow, 0);
 
diff --git a/src/tests/white_box/VulkanImageWrappingTestsOpaqueFD.cpp b/src/tests/white_box/VulkanImageWrappingTestsOpaqueFD.cpp
index b96fbcf..9647152 100644
--- a/src/tests/white_box/VulkanImageWrappingTestsOpaqueFD.cpp
+++ b/src/tests/white_box/VulkanImageWrappingTestsOpaqueFD.cpp
@@ -986,7 +986,7 @@
             wgpu::BufferCopyView copySrc =
                 utils::CreateBufferCopyView(copySrcBuffer, 0, bytesPerRow, 0);
             wgpu::TextureCopyView copyDst =
-                utils::CreateTextureCopyView(wrappedTexture, 0, 0, {0, 0, 0});
+                utils::CreateTextureCopyView(wrappedTexture, 0, {0, 0, 0});
             wgpu::Extent3D copySize = {width, height, 1};
 
             wgpu::CommandEncoder encoder = secondDevice.CreateCommandEncoder();
@@ -1010,7 +1010,7 @@
         wgpu::Buffer copyDstBuffer = device.CreateBuffer(&copyDesc);
         {
             wgpu::TextureCopyView copySrc =
-                utils::CreateTextureCopyView(nextWrappedTexture, 0, 0, {0, 0, 0});
+                utils::CreateTextureCopyView(nextWrappedTexture, 0, {0, 0, 0});
             wgpu::BufferCopyView copyDst =
                 utils::CreateBufferCopyView(copyDstBuffer, 0, bytesPerRow, 0);
 
diff --git a/src/utils/WGPUHelpers.cpp b/src/utils/WGPUHelpers.cpp
index 5b703ea..d3ee2c0 100644
--- a/src/utils/WGPUHelpers.cpp
+++ b/src/utils/WGPUHelpers.cpp
@@ -276,12 +276,10 @@
 
     wgpu::TextureCopyView CreateTextureCopyView(wgpu::Texture texture,
                                                 uint32_t mipLevel,
-                                                uint32_t arrayLayer,
                                                 wgpu::Origin3D origin) {
         wgpu::TextureCopyView textureCopyView;
         textureCopyView.texture = texture;
         textureCopyView.mipLevel = mipLevel;
-        textureCopyView.arrayLayer = arrayLayer;
         textureCopyView.origin = origin;
 
         return textureCopyView;
diff --git a/src/utils/WGPUHelpers.h b/src/utils/WGPUHelpers.h
index 92bd518..8c756bc 100644
--- a/src/utils/WGPUHelpers.h
+++ b/src/utils/WGPUHelpers.h
@@ -53,7 +53,6 @@
                                               uint32_t rowsPerImage);
     wgpu::TextureCopyView CreateTextureCopyView(wgpu::Texture texture,
                                                 uint32_t level,
-                                                uint32_t slice,
                                                 wgpu::Origin3D origin);
 
     struct ComboRenderPassDescriptor : public wgpu::RenderPassDescriptor {