diff --git a/src/dawn/native/BlockInfo.h b/src/dawn/native/BlockInfo.h
index 153307b..27d5dbe 100644
--- a/src/dawn/native/BlockInfo.h
+++ b/src/dawn/native/BlockInfo.h
@@ -54,17 +54,17 @@
 
     // Construct from input values
     // NOLINTNEXTLINE: allow implicit constructor
-    TexelOrigin3D(TexelCount x = TexelCount{0},
-                  TexelCount y = TexelCount{0},
-                  TexelCount z = TexelCount{0})
+    constexpr TexelOrigin3D(TexelCount x = TexelCount{0},
+                            TexelCount y = TexelCount{0},
+                            TexelCount z = TexelCount{0})
         : x(x), y(y), z(z) {}
 
     // Implicitly convert from Origin3D as Origin3D is always in texel space
     // NOLINTNEXTLINE: allow implicit constructor
-    TexelOrigin3D(const Origin3D& o) : x(o.x), y(o.y), z(o.z) {}
+    constexpr TexelOrigin3D(const Origin3D& o) : x(o.x), y(o.y), z(o.z) {}
 
     // Convert to Origin3D
-    Origin3D ToOrigin3D() const {
+    constexpr Origin3D ToOrigin3D() const {
         return {static_cast<uint32_t>(x), static_cast<uint32_t>(y), static_cast<uint32_t>(z)};
     }
 };
@@ -77,9 +77,9 @@
 
     // Construct from input values
     // NOLINTNEXTLINE: allow implicit constructor
-    BlockOrigin3D(BlockCount x = BlockCount{0},
-                  BlockCount y = BlockCount{0},
-                  BlockCount z = BlockCount{0})
+    constexpr BlockOrigin3D(BlockCount x = BlockCount{0},
+                            BlockCount y = BlockCount{0},
+                            BlockCount z = BlockCount{0})
         : x(x), y(y), z(z) {}
 };
 
@@ -90,22 +90,22 @@
     TexelCount depthOrArrayLayers{1};
 
     // Default constructor
-    TexelExtent3D() = default;
+    constexpr TexelExtent3D() = default;
 
     // Construct from input values
     // NOLINTNEXTLINE: allow implicit constructor
-    TexelExtent3D(TexelCount width,
-                  TexelCount height = TexelCount{1},
-                  TexelCount depthOrArrayLayers = TexelCount{1})
+    constexpr TexelExtent3D(TexelCount width,
+                            TexelCount height = TexelCount{1},
+                            TexelCount depthOrArrayLayers = TexelCount{1})
         : width(width), height(height), depthOrArrayLayers(depthOrArrayLayers) {}
 
     // Implicitly convert from Extent3D as Extent3D is always in texel space
     // NOLINTNEXTLINE: allow implicit constructor
-    TexelExtent3D(const Extent3D& e)
+    constexpr TexelExtent3D(const Extent3D& e)
         : width(e.width), height(e.height), depthOrArrayLayers(e.depthOrArrayLayers) {}
 
     // Convert to Extent3D
-    Extent3D ToExtent3D() const {
+    constexpr Extent3D ToExtent3D() const {
         return {static_cast<uint32_t>(width), static_cast<uint32_t>(height),
                 static_cast<uint32_t>(depthOrArrayLayers)};
     }
@@ -118,13 +118,13 @@
     BlockCount depthOrArrayLayers{1};
 
     // Default constructor
-    BlockExtent3D() = default;
+    constexpr BlockExtent3D() = default;
 
     // Construct from input values
     // NOLINTNEXTLINE: allow implicit constructor
-    BlockExtent3D(BlockCount width,
-                  BlockCount height = BlockCount{1},
-                  BlockCount depthOrArrayLayers = BlockCount{1})
+    constexpr BlockExtent3D(BlockCount width,
+                            BlockCount height = BlockCount{1},
+                            BlockCount depthOrArrayLayers = BlockCount{1})
         : width(width), height(height), depthOrArrayLayers(depthOrArrayLayers) {}
 };
 
@@ -136,81 +136,88 @@
     TexelCount height;
 
     // Default constructor
-    TypedTexelBlockInfo() = default;
+    constexpr TypedTexelBlockInfo() = default;
+
+    // Construct from input values
+    // NOLINTNEXTLINE: allow implicit constructor
+    constexpr TypedTexelBlockInfo(uint32_t byteSize, TexelCount width, TexelCount height)
+        : byteSize(byteSize), width(width), height(height) {}
 
     // Convert from TexelBlockInfo
     // NOLINTNEXTLINE: allow implicit constructor
-    TypedTexelBlockInfo(const TexelBlockInfo& blockInfo)
+    constexpr TypedTexelBlockInfo(const TexelBlockInfo& blockInfo)
         : byteSize(blockInfo.byteSize), width(blockInfo.width), height(blockInfo.height) {}
 
     // Convert to TexelBlockInfo
-    TexelBlockInfo ToTexelBlockInfo() const {
+    constexpr TexelBlockInfo ToTexelBlockInfo() const {
         return {byteSize, static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
     }
 
     // Convert blocks to bytes
-    uint64_t ToBytes(BlockCount value) const { return static_cast<uint64_t>(value) * byteSize; }
+    constexpr uint64_t ToBytes(BlockCount value) const {
+        return static_cast<uint64_t>(value) * byteSize;
+    }
 
     // Convert bytes to blocks
-    BlockCount BytesToBlocks(uint64_t bytes) const {
+    constexpr BlockCount BytesToBlocks(uint64_t bytes) const {
         DAWN_ASSERT(bytes % byteSize == 0);
         return BlockCount{bytes / byteSize};
     }
 
     // Convert texel height to block height
-    BlockCount ToBlockHeight(TexelCount value) const {
+    constexpr BlockCount ToBlockHeight(TexelCount value) const {
         DAWN_ASSERT(value % height == TexelCount{0});
         return BlockCount{static_cast<uint64_t>(value / height)};
     }
 
     // Convert from texel width to block width
-    BlockCount ToBlockWidth(TexelCount value) const {
+    constexpr BlockCount ToBlockWidth(TexelCount value) const {
         DAWN_ASSERT(value % width == TexelCount{0});
         return BlockCount{static_cast<uint64_t>(value / width)};
     }
 
     // Convert from texel depth to block depth
-    BlockCount ToBlockDepth(TexelCount value) const {
+    constexpr BlockCount ToBlockDepth(TexelCount value) const {
         // TODO(amaiorano): When we add block 'depth' for 3D block support, divide this value by
         // 'depth'
         return BlockCount{static_cast<uint64_t>(value)};
     }
 
     // Convert from block width to texel width
-    TexelCount ToTexelWidth(BlockCount value) const {
+    constexpr TexelCount ToTexelWidth(BlockCount value) const {
         return TexelCount{static_cast<uint64_t>(value)} * width;
     }
 
     // Convert from block height to texel height
-    TexelCount ToTexelHeight(BlockCount value) const {
+    constexpr TexelCount ToTexelHeight(BlockCount value) const {
         return TexelCount{static_cast<uint64_t>(value)} * height;
     }
 
     // Convert from block depth to texel depth
-    TexelCount ToTexelDepth(BlockCount value) const {
+    constexpr TexelCount ToTexelDepth(BlockCount value) const {
         // TODO(amaiorano): When we add block 'depth' for 3D block support, multiply this value by
         // 'depth'
         return TexelCount{static_cast<uint64_t>(value)};
     }
 
     // Convert from TexelOrigin3D to BlockOrigin3D
-    BlockOrigin3D ToBlock(const TexelOrigin3D& origin) const {
+    constexpr BlockOrigin3D ToBlock(const TexelOrigin3D& origin) const {
         return {ToBlockWidth(origin.x), ToBlockHeight(origin.y), ToBlockDepth(origin.z)};
     }
 
     // Convert from TexelExtent3D to BlockExtent3D
-    BlockExtent3D ToBlock(const TexelExtent3D& extent) const {
+    constexpr BlockExtent3D ToBlock(const TexelExtent3D& extent) const {
         return {ToBlockWidth(extent.width), ToBlockHeight(extent.height),
                 ToBlockDepth(extent.depthOrArrayLayers)};
     }
 
     // Convert from BlockOrigin3D to TexelOrigin3D
-    TexelOrigin3D ToTexel(const BlockOrigin3D& origin) const {
+    constexpr TexelOrigin3D ToTexel(const BlockOrigin3D& origin) const {
         return {ToTexelWidth(origin.x), ToTexelHeight(origin.y), ToTexelDepth(origin.z)};
     }
 
     // Convert from BlockExtent3D to TexelExtent3D
-    TexelExtent3D ToTexel(const BlockExtent3D& extent) const {
+    constexpr TexelExtent3D ToTexel(const BlockExtent3D& extent) const {
         return {ToTexelWidth(extent.width), ToTexelHeight(extent.height),
                 ToTexelDepth(extent.depthOrArrayLayers)};
     }
diff --git a/src/dawn/tests/unittests/d3d12/CopySplitTests.cpp b/src/dawn/tests/unittests/d3d12/CopySplitTests.cpp
index a7cfc43..002175d 100644
--- a/src/dawn/tests/unittests/d3d12/CopySplitTests.cpp
+++ b/src/dawn/tests/unittests/d3d12/CopySplitTests.cpp
@@ -51,15 +51,9 @@
 }
 
 struct TextureSpec {
-    TexelCount x;                    // origin.x in texels
-    TexelCount y;                    // origin.y in texels
-    TexelCount z;                    // origin.z in texels
-    TexelCount width;                // copySize.width in texels
-    TexelCount height;               // copySize.height in texels
-    TexelCount depthOrArrayLayers;   // copy size depth or array layers
-    uint32_t texelBlockSizeInBytes;  // bytes per block
-    TexelCount blockWidth{1};        // texel width per block
-    TexelCount blockHeight{1};       // texel height per block
+    TexelOrigin3D origin;
+    TexelExtent3D copySize;
+    TypedTexelBlockInfo blockInfo;
 };
 
 struct BufferSpec {
@@ -68,39 +62,12 @@
     BlockCount rowsPerImage;  // bock rows per image slice (user-defined)
 };
 
-// TODO(425944899): Store TypedTexelBlockInfo in TextureSpec
-TypedTexelBlockInfo ToTypedTexelBlockInfo(const TextureSpec& textureSpec) {
-    TypedTexelBlockInfo blockInfo;
-    blockInfo.byteSize = textureSpec.texelBlockSizeInBytes;
-    blockInfo.width = TexelCount{textureSpec.blockWidth};
-    blockInfo.height = TexelCount{textureSpec.blockHeight};
-    return blockInfo;
-}
-
-// TODO(425944899): Store TexelOrigin3D in TextureSpec
-TexelOrigin3D ToTexelOrigin3D(const TextureSpec& textureSpec) {
-    return TexelOrigin3D{textureSpec.x, textureSpec.y, textureSpec.z};
-}
-
-// TODO(425944899): Store TexelExtent3D in TextureSpec
-TexelExtent3D ToTexelExtent3D(const TextureSpec& textureSpec) {
-    return TexelExtent3D{textureSpec.width, textureSpec.height, textureSpec.depthOrArrayLayers};
-}
-
-BlockOrigin3D ToBlockOrigin3D(const TextureSpec& textureSpec) {
-    return ToTypedTexelBlockInfo(textureSpec).ToBlock(ToTexelOrigin3D(textureSpec));
-}
-
-BlockExtent3D ToBlockExtent3D(const TextureSpec& textureSpec) {
-    return ToTypedTexelBlockInfo(textureSpec).ToBlock(ToTexelExtent3D(textureSpec));
-}
-
 // Check that each copy region fits inside the buffer footprint
 void ValidateFootprints(const TextureSpec& textureSpec,
                         const BufferSpec& bufferSpec,
                         const TextureCopySubresource& copySplit,
                         wgpu::TextureDimension dimension) {
-    TypedTexelBlockInfo blockInfo = ToTypedTexelBlockInfo(textureSpec);
+    const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo;
     for (uint32_t i = 0; i < copySplit.count; ++i) {
         const auto& copy = copySplit.copies[i];
         // TODO(425944899): Rework this function to work in blocks, not texels
@@ -118,31 +85,32 @@
         // current 2D texture splitter is doing, although Compute2DTextureCopySubresource
         // forwards "copySize.depthOrArrayLayers" to the copy region it generated. So skip
         // the test below for 2D textures with multiple layers.
-        if (textureSpec.depthOrArrayLayers <= 1_tc || dimension == wgpu::TextureDimension::e3D) {
-            BlockCount widthInBlocks = blockInfo.ToBlockWidth(textureSpec.width);
-            BlockCount heightInBlocks = blockInfo.ToBlockHeight(textureSpec.height);
+        if (textureSpec.copySize.depthOrArrayLayers <= 1_tc ||
+            dimension == wgpu::TextureDimension::e3D) {
+            BlockCount widthInBlocks = blockInfo.ToBlockWidth(textureSpec.copySize.width);
+            BlockCount heightInBlocks = blockInfo.ToBlockHeight(textureSpec.copySize.height);
             uint64_t minimumRequiredBufferSize =
                 bufferSpec.offset +
                 // TOOD(425944899): add overload of RequiredBytesInCopy that accepts strong types
                 utils::RequiredBytesInCopy(
                     bufferSpec.bytesPerRow, static_cast<uint32_t>(bufferSpec.rowsPerImage),
                     static_cast<uint32_t>(widthInBlocks), static_cast<uint32_t>(heightInBlocks),
-                    static_cast<uint32_t>(textureSpec.depthOrArrayLayers),
-                    textureSpec.texelBlockSizeInBytes);
+                    static_cast<uint32_t>(textureSpec.copySize.depthOrArrayLayers),
+                    blockInfo.byteSize);
 
             // The last pixel (buffer footprint) of each copy region depends on its
             // bufferOffset and copySize. It is not the last pixel where the bufferSize
             // ends.
-            ASSERT_EQ(bufferOffset.x % textureSpec.blockWidth, 0_tc);
-            ASSERT_EQ(copySize.width % textureSpec.blockWidth, 0_tc);
+            ASSERT_EQ(bufferOffset.x % blockInfo.width, 0_tc);
+            ASSERT_EQ(copySize.width % blockInfo.width, 0_tc);
             TexelCount footprintWidth = bufferOffset.x + copySize.width;
-            ASSERT_EQ(footprintWidth % textureSpec.blockWidth, 0_tc);
+            ASSERT_EQ(footprintWidth % blockInfo.width, 0_tc);
             BlockCount footprintWidthInBlocks = blockInfo.ToBlockWidth(footprintWidth);
 
-            ASSERT_EQ(bufferOffset.y % textureSpec.blockHeight, 0_tc);
-            ASSERT_EQ(copySize.height % textureSpec.blockHeight, 0_tc);
+            ASSERT_EQ(bufferOffset.y % blockInfo.height, 0_tc);
+            ASSERT_EQ(copySize.height % blockInfo.height, 0_tc);
             TexelCount footprintHeight = bufferOffset.y + copySize.height;
-            ASSERT_EQ(footprintHeight % textureSpec.blockHeight, 0_tc);
+            ASSERT_EQ(footprintHeight % blockInfo.height, 0_tc);
             BlockCount footprintHeightInBlocks = blockInfo.ToBlockHeight(footprintHeight);
 
             uint64_t bufferSizeForFootprint =
@@ -153,7 +121,7 @@
                     static_cast<uint32_t>(footprintWidthInBlocks),
                     static_cast<uint32_t>(footprintHeightInBlocks),
                     static_cast<uint32_t>(blockInfo.ToBlockDepth(bufferSize.depthOrArrayLayers)),
-                    textureSpec.texelBlockSizeInBytes);
+                    blockInfo.byteSize);
 
             // The buffer footprint of each copy region should not exceed the minimum
             // required buffer size. Otherwise, pixels accessed by copy may be OOB.
@@ -180,7 +148,7 @@
 
 // Check that no pair of copy regions intersect each other
 void ValidateDisjoint(const TextureSpec& textureSpec, const TextureCopySubresource& copySplit) {
-    TypedTexelBlockInfo blockInfo = ToTypedTexelBlockInfo(textureSpec);
+    const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo;
     for (uint32_t i = 0; i < copySplit.count; ++i) {
         const auto& a = copySplit.copies[i];
         // TODO(425944899): Rework this function to work in blocks, not texels
@@ -212,7 +180,7 @@
 void ValidateTextureBounds(const TextureSpec& textureSpec,
                            const TextureCopySubresource& copySplit) {
     ASSERT_GT(copySplit.count, 0u);
-    TypedTexelBlockInfo blockInfo = ToTypedTexelBlockInfo(textureSpec);
+    const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo;
 
     // TODO(425944899): Rework this function to work in blocks, not texels
     const TexelExtent3D& copySize0 = blockInfo.ToTexel(copySplit.copies[0].copySize);
@@ -236,18 +204,18 @@
         maxZ = std::max(maxZ, textureOffset.z + copySize.depthOrArrayLayers);
     }
 
-    ASSERT_EQ(minX, textureSpec.x);
-    ASSERT_EQ(minY, textureSpec.y);
-    ASSERT_EQ(minZ, textureSpec.z);
-    ASSERT_EQ(maxX, textureSpec.x + textureSpec.width);
-    ASSERT_EQ(maxY, textureSpec.y + textureSpec.height);
-    ASSERT_EQ(maxZ, textureSpec.z + textureSpec.depthOrArrayLayers);
+    ASSERT_EQ(minX, textureSpec.origin.x);
+    ASSERT_EQ(minY, textureSpec.origin.y);
+    ASSERT_EQ(minZ, textureSpec.origin.z);
+    ASSERT_EQ(maxX, textureSpec.origin.x + textureSpec.copySize.width);
+    ASSERT_EQ(maxY, textureSpec.origin.y + textureSpec.copySize.height);
+    ASSERT_EQ(maxZ, textureSpec.origin.z + textureSpec.copySize.depthOrArrayLayers);
 }
 
 // Validate that the number of pixels copied is exactly equal to the number of pixels in the
 // texture region
 void ValidatePixelCount(const TextureSpec& textureSpec, const TextureCopySubresource& copySplit) {
-    TypedTexelBlockInfo blockInfo = ToTypedTexelBlockInfo(textureSpec);
+    const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo;
     TexelCount totalCopiedTexels{0};
     for (uint32_t i = 0; i < copySplit.count; ++i) {
         const auto& copy = copySplit.copies[i];
@@ -257,8 +225,8 @@
         ASSERT_GT(copiedTexels, 0_tc);
         totalCopiedTexels += copiedTexels;
     }
-    ASSERT_EQ(totalCopiedTexels,
-              textureSpec.width * textureSpec.height * textureSpec.depthOrArrayLayers);
+    ASSERT_EQ(totalCopiedTexels, textureSpec.copySize.width * textureSpec.copySize.height *
+                                     textureSpec.copySize.depthOrArrayLayers);
 }
 
 // Check that every buffer offset is at the correct pixel location
@@ -268,7 +236,7 @@
                           wgpu::TextureDimension dimension,
                           bool relaxed) {
     ASSERT_GT(copySplit.count, 0u);
-    TypedTexelBlockInfo blockInfo = ToTypedTexelBlockInfo(textureSpec);
+    const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo;
 
     for (uint32_t i = 0; i < copySplit.count; ++i) {
         const auto& copy = copySplit.copies[i];
@@ -298,9 +266,9 @@
         BlockCount yBlocks = (relativeOffsetInBlocks % slicePitchInBlocks) / rowPitchInBlocks;
         BlockCount xBlocks = relativeOffsetInBlocks % rowPitchInBlocks;
 
-        ASSERT_EQ(textureOffset.x - blockInfo.ToBlockWidth(textureSpec.x), xBlocks);
-        ASSERT_EQ(textureOffset.y - blockInfo.ToBlockHeight(textureSpec.y), yBlocks);
-        ASSERT_EQ(textureOffset.z - blockInfo.ToBlockDepth(textureSpec.z), z);
+        ASSERT_EQ(textureOffset.x - blockInfo.ToBlockWidth(textureSpec.origin.x), xBlocks);
+        ASSERT_EQ(textureOffset.y - blockInfo.ToBlockHeight(textureSpec.origin.y), yBlocks);
+        ASSERT_EQ(textureOffset.z - blockInfo.ToBlockDepth(textureSpec.origin.z), z);
     }
 }
 
@@ -318,12 +286,12 @@
 }
 
 std::ostream& operator<<(std::ostream& os, const TextureSpec& textureSpec) {
-    os << "TextureSpec(" << "[origin=(" << textureSpec.x << ", " << textureSpec.y << ", "
-       << textureSpec.z << "), copySize=(" << textureSpec.width << ", " << textureSpec.height
-       << ", " << textureSpec.depthOrArrayLayers
-       << ")], blockBytes=" << textureSpec.texelBlockSizeInBytes
-       << ", blockWidth=" << textureSpec.blockWidth << ", blockHeight=" << textureSpec.blockHeight
-       << ")";
+    os << "TextureSpec(" << "[origin=(" << textureSpec.origin.x << ", " << textureSpec.origin.y
+       << ", " << textureSpec.origin.z << "), copySize=(" << textureSpec.copySize.width << ", "
+       << textureSpec.copySize.height << ", " << textureSpec.copySize.depthOrArrayLayers
+       << ")], blockBytes=" << textureSpec.blockInfo.byteSize
+       << ", blockWidth=" << textureSpec.blockInfo.width
+       << ", blockHeight=" << textureSpec.blockInfo.height << ")";
     return os;
 }
 
@@ -352,395 +320,119 @@
 // Define base texture sizes and offsets to test with: some aligned, some unaligned
 constexpr TextureSpec kBaseTextureSpecs[] = {
     // 1x1 2D copies
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 1_tc,
-     .height = 1_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 64_tc,
-     .height = 1_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 128_tc,
-     .height = 1_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 192_tc,
-     .height = 1_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 31_tc,
-     .y = 16_tc,
-     .z = 0_tc,
-     .width = 1_tc,
-     .height = 1_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 64_tc,
-     .y = 16_tc,
-     .z = 0_tc,
-     .width = 1_tc,
-     .height = 1_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 64_tc,
-     .y = 16_tc,
-     .z = 8_tc,
-     .width = 1_tc,
-     .height = 1_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {1_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {128_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {192_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {31_tc, 16_tc, 0_tc}, .copySize = {1_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {64_tc, 16_tc, 0_tc}, .copySize = {1_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {64_tc, 16_tc, 8_tc}, .copySize = {1_tc, 1_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
     // 2x1, 1x2, and 2x2
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 64_tc,
-     .height = 2_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 64_tc,
-     .height = 1_tc,
-     .depthOrArrayLayers = 2_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 64_tc,
-     .height = 2_tc,
-     .depthOrArrayLayers = 2_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 128_tc,
-     .height = 2_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 128_tc,
-     .height = 1_tc,
-     .depthOrArrayLayers = 2_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 128_tc,
-     .height = 2_tc,
-     .depthOrArrayLayers = 2_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 192_tc,
-     .height = 2_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 192_tc,
-     .height = 1_tc,
-     .depthOrArrayLayers = 2_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 192_tc,
-     .height = 2_tc,
-     .depthOrArrayLayers = 2_tc,
-     .texelBlockSizeInBytes = 4},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 2_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 1_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 2_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {128_tc, 2_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {128_tc, 1_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {128_tc, 2_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {192_tc, 2_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {192_tc, 1_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {192_tc, 2_tc, 2_tc}, .blockInfo = {4, 1_tc, 1_tc}},
     // 1024x1024 2D and 3D
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 256_tc,
-     .y = 512_tc,
-     .z = 0_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 64_tc,
-     .y = 48_tc,
-     .z = 0_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 64_tc,
-     .y = 48_tc,
-     .z = 16_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1024_tc,
-     .texelBlockSizeInBytes = 4},
+    {.origin = {0_tc, 0_tc, 0_tc},
+     .copySize = {1024_tc, 1024_tc, 1_tc},
+     .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {256_tc, 512_tc, 0_tc},
+     .copySize = {1024_tc, 1024_tc, 1_tc},
+     .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {64_tc, 48_tc, 0_tc},
+     .copySize = {1024_tc, 1024_tc, 1_tc},
+     .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {64_tc, 48_tc, 16_tc},
+     .copySize = {1024_tc, 1024_tc, 1024_tc},
+     .blockInfo = {4, 1_tc, 1_tc}},
     // Non-power of two texture dims
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 257_tc,
-     .height = 31_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 17_tc,
-     .height = 93_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 59_tc,
-     .y = 13_tc,
-     .z = 0_tc,
-     .width = 257_tc,
-     .height = 31_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 17_tc,
-     .y = 73_tc,
-     .z = 0_tc,
-     .width = 17_tc,
-     .height = 93_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4},
-    {.x = 17_tc,
-     .y = 73_tc,
-     .z = 59_tc,
-     .width = 17_tc,
-     .height = 93_tc,
-     .depthOrArrayLayers = 99_tc,
-     .texelBlockSizeInBytes = 4},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {257_tc, 31_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {17_tc, 93_tc, 1_tc}, .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {59_tc, 13_tc, 0_tc},
+     .copySize = {257_tc, 31_tc, 1_tc},
+     .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {17_tc, 73_tc, 0_tc},
+     .copySize = {17_tc, 93_tc, 1_tc},
+     .blockInfo = {4, 1_tc, 1_tc}},
+    {.origin = {17_tc, 73_tc, 59_tc},
+     .copySize = {17_tc, 93_tc, 99_tc},
+     .blockInfo = {4, 1_tc, 1_tc}},
     // 4x4 block size 2D copies
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 4_tc,
-     .height = 4_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 8,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 64_tc,
-     .y = 16_tc,
-     .z = 0_tc,
-     .width = 4_tc,
-     .height = 4_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 8,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 64_tc,
-     .y = 16_tc,
-     .z = 8_tc,
-     .width = 4_tc,
-     .height = 4_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 8,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 4_tc,
-     .height = 4_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 16,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 64_tc,
-     .y = 16_tc,
-     .z = 0_tc,
-     .width = 4_tc,
-     .height = 4_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 16,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 64_tc,
-     .y = 16_tc,
-     .z = 8_tc,
-     .width = 4_tc,
-     .height = 4_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 16,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {8, 4_tc, 4_tc}},
+    {.origin = {64_tc, 16_tc, 0_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {8, 4_tc, 4_tc}},
+    {.origin = {64_tc, 16_tc, 8_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {8, 4_tc, 4_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {16, 4_tc, 4_tc}},
+    {.origin = {64_tc, 16_tc, 0_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {16, 4_tc, 4_tc}},
+    {.origin = {64_tc, 16_tc, 8_tc}, .copySize = {4_tc, 4_tc, 1_tc}, .blockInfo = {16, 4_tc, 4_tc}},
     // 4x4 block size 2D copies of 1024x1024 textures
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 8,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 256_tc,
-     .y = 512_tc,
-     .z = 0_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 8,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 64_tc,
-     .y = 48_tc,
-     .z = 0_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 8,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 64_tc,
-     .y = 48_tc,
-     .z = 16_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 8,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 16,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 256_tc,
-     .y = 512_tc,
-     .z = 0_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 16,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 64_tc,
-     .y = 48_tc,
-     .z = 0_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 4,
-     .blockWidth = 16_tc,
-     .blockHeight = 4_tc},
-    {.x = 64_tc,
-     .y = 48_tc,
-     .z = 16_tc,
-     .width = 1024_tc,
-     .height = 1024_tc,
-     .depthOrArrayLayers = 1_tc,
-     .texelBlockSizeInBytes = 16,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
+    {.origin = {0_tc, 0_tc, 0_tc},
+     .copySize = {1024_tc, 1024_tc, 1_tc},
+     .blockInfo = {8, 4_tc, 4_tc}},
+    {.origin = {256_tc, 512_tc, 0_tc},
+     .copySize = {1024_tc, 1024_tc, 1_tc},
+     .blockInfo = {8, 4_tc, 4_tc}},
+    {.origin = {64_tc, 48_tc, 0_tc},
+     .copySize = {1024_tc, 1024_tc, 1_tc},
+     .blockInfo = {8, 4_tc, 4_tc}},
+    {.origin = {64_tc, 48_tc, 16_tc},
+     .copySize = {1024_tc, 1024_tc, 1_tc},
+     .blockInfo = {8, 4_tc, 4_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc},
+     .copySize = {1024_tc, 1024_tc, 1_tc},
+     .blockInfo = {16, 4_tc, 4_tc}},
+    {.origin = {256_tc, 512_tc, 0_tc},
+     .copySize = {1024_tc, 1024_tc, 1_tc},
+     .blockInfo = {16, 4_tc, 4_tc}},
+    {.origin = {64_tc, 48_tc, 0_tc},
+     .copySize = {1024_tc, 1024_tc, 1_tc},
+     .blockInfo = {4, 16_tc, 4_tc}},
+    {.origin = {64_tc, 48_tc, 16_tc},
+     .copySize = {1024_tc, 1024_tc, 1_tc},
+     .blockInfo = {16, 4_tc, 4_tc}},
     // 4x4 block size 3D copies
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 64_tc,
-     .height = 4_tc,
-     .depthOrArrayLayers = 2_tc,
-     .texelBlockSizeInBytes = 8,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 64_tc,
-     .height = 4_tc,
-     .depthOrArrayLayers = 2_tc,
-     .texelBlockSizeInBytes = 16,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 64_tc,
-     .height = 4_tc,
-     .depthOrArrayLayers = 8_tc,
-     .texelBlockSizeInBytes = 16,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
-    {.x = 0_tc,
-     .y = 0_tc,
-     .z = 0_tc,
-     .width = 128_tc,
-     .height = 4_tc,
-     .depthOrArrayLayers = 8_tc,
-     .texelBlockSizeInBytes = 8,
-     .blockWidth = 4_tc,
-     .blockHeight = 4_tc},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 4_tc, 2_tc}, .blockInfo = {8, 4_tc, 4_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 4_tc, 2_tc}, .blockInfo = {16, 4_tc, 4_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {64_tc, 4_tc, 8_tc}, .blockInfo = {16, 4_tc, 4_tc}},
+    {.origin = {0_tc, 0_tc, 0_tc}, .copySize = {128_tc, 4_tc, 8_tc}, .blockInfo = {8, 4_tc, 4_tc}},
 };
 
 // Define base buffer sizes to work with: some offsets aligned, some unaligned. bytesPerRow
 // is the minimum required
 std::array<BufferSpec, 15> BaseBufferSpecs(const TextureSpec& textureSpec) {
-    TypedTexelBlockInfo blockInfo = ToTypedTexelBlockInfo(textureSpec);
-    uint32_t bytesPerRow = Align(blockInfo.ToBytes(blockInfo.ToBlockWidth(textureSpec.width)),
-                                 kTextureBytesPerRowAlignment);
+    const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo;
+    uint32_t bytesPerRow =
+        Align(blockInfo.ToBytes(blockInfo.ToBlockWidth(textureSpec.copySize.width)),
+              kTextureBytesPerRowAlignment);
 
     auto alignNonPow2 = [](uint32_t value, uint32_t size) -> uint32_t {
         return value == 0 ? 0 : ((value - 1) / size + 1) * size;
     };
 
+    BlockCount copyHeight = blockInfo.ToBlockHeight(textureSpec.copySize.height);
+
     return {
-        BufferSpec{alignNonPow2(0, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(256, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(512, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(1024, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(1024, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height) * 2_bc},
+        BufferSpec{alignNonPow2(0, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(256, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(512, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(1024, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(1024, blockInfo.byteSize), bytesPerRow, copyHeight * 2_bc},
 
-        BufferSpec{alignNonPow2(32, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(64, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(64, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height) * 2_bc},
+        BufferSpec{alignNonPow2(32, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(64, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(64, blockInfo.byteSize), bytesPerRow, copyHeight * 2_bc},
 
-        BufferSpec{alignNonPow2(31, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(257, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(384, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(511, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(513, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(1023, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height)},
-        BufferSpec{alignNonPow2(1023, textureSpec.texelBlockSizeInBytes), bytesPerRow,
-                   blockInfo.ToBlockHeight(textureSpec.height) * 2_bc},
+        BufferSpec{alignNonPow2(31, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(257, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(384, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(511, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(513, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(1023, blockInfo.byteSize), bytesPerRow, copyHeight},
+        BufferSpec{alignNonPow2(1023, blockInfo.byteSize), bytesPerRow, copyHeight * 2_bc},
     };
 }
 
@@ -761,14 +453,15 @@
                 const BufferSpec& bufferSpec,
                 wgpu::TextureDimension dimension,
                 bool relaxed) {
-        DAWN_ASSERT(textureSpec.width % textureSpec.blockWidth == 0_tc &&
-                    textureSpec.height % textureSpec.blockHeight == 0_tc);
+        const TypedTexelBlockInfo& blockInfo = textureSpec.blockInfo;
+        DAWN_ASSERT(textureSpec.copySize.width % blockInfo.width == 0_tc &&
+                    textureSpec.copySize.height % blockInfo.height == 0_tc);
+
         // Add trace so that failures emit the input test specs
         std::stringstream trace;
         trace << textureSpec << ", " << bufferSpec;
         SCOPED_TRACE(trace.str());
 
-        TypedTexelBlockInfo blockInfo = ToTypedTexelBlockInfo(textureSpec);
         BlockCount blocksPerRow = blockInfo.BytesToBlocks(bufferSpec.bytesPerRow);
         BlockCount rowsPerImage{bufferSpec.rowsPerImage};
 
@@ -780,29 +473,33 @@
                 // these cases before reaching the TextureCopySplitter.
                 // TODO(425944899): Test Compute2DTextureCopySplits to cover e2D and
                 // depthOrArrayLayers>1
-                if (textureSpec.z > 0_tc || textureSpec.depthOrArrayLayers > 1_tc) {
+                if (textureSpec.origin.z > 0_tc || textureSpec.copySize.depthOrArrayLayers > 1_tc) {
                     return;
                 }
                 if (relaxed) {
                     copySplit = Compute2DTextureCopySubresourceWithRelaxedRowPitchAndOffset(
-                        ToBlockOrigin3D(textureSpec), ToBlockExtent3D(textureSpec), blockInfo,
-                        bufferSpec.offset, blocksPerRow);
+                        blockInfo.ToBlock(textureSpec.origin),
+                        blockInfo.ToBlock(textureSpec.copySize), blockInfo, bufferSpec.offset,
+                        blocksPerRow);
                 } else {
-                    copySplit = Compute2DTextureCopySubresource(
-                        ToBlockOrigin3D(textureSpec), ToBlockExtent3D(textureSpec), blockInfo,
-                        bufferSpec.offset, blocksPerRow);
+                    copySplit =
+                        Compute2DTextureCopySubresource(blockInfo.ToBlock(textureSpec.origin),
+                                                        blockInfo.ToBlock(textureSpec.copySize),
+                                                        blockInfo, bufferSpec.offset, blocksPerRow);
                 }
                 break;
             }
             case wgpu::TextureDimension::e3D: {
                 if (relaxed) {
                     copySplit = Compute3DTextureCopySubresourceWithRelaxedRowPitchAndOffset(
-                        ToBlockOrigin3D(textureSpec), ToBlockExtent3D(textureSpec), blockInfo,
-                        bufferSpec.offset, blocksPerRow, rowsPerImage);
+                        blockInfo.ToBlock(textureSpec.origin),
+                        blockInfo.ToBlock(textureSpec.copySize), blockInfo, bufferSpec.offset,
+                        blocksPerRow, rowsPerImage);
                 } else {
-                    copySplit = Compute3DTextureCopySplits(
-                        ToBlockOrigin3D(textureSpec), ToBlockExtent3D(textureSpec), blockInfo,
-                        bufferSpec.offset, blocksPerRow, rowsPerImage);
+                    copySplit = Compute3DTextureCopySplits(blockInfo.ToBlock(textureSpec.origin),
+                                                           blockInfo.ToBlock(textureSpec.copySize),
+                                                           blockInfo, bufferSpec.offset,
+                                                           blocksPerRow, rowsPerImage);
                 }
                 break;
             }
@@ -840,10 +537,10 @@
 TEST_P(CopySplitTest, TextureWidth) {
     for (TextureSpec textureSpec : kBaseTextureSpecs) {
         for (uint32_t val : kCheckValues) {
-            if (TexelCount{val} % textureSpec.blockWidth != 0_tc) {
+            if (TexelCount{val} % textureSpec.blockInfo.width != 0_tc) {
                 continue;
             }
-            textureSpec.width = TexelCount{val};
+            textureSpec.copySize.width = TexelCount{val};
             for (const BufferSpec& bufferSpec : BaseBufferSpecs(textureSpec)) {
                 DoTest(textureSpec, bufferSpec);
             }
@@ -854,10 +551,10 @@
 TEST_P(CopySplitTest, TextureHeight) {
     for (TextureSpec textureSpec : kBaseTextureSpecs) {
         for (uint32_t val : kCheckValues) {
-            if (TexelCount{val} % textureSpec.blockHeight != 0_tc) {
+            if (TexelCount{val} % textureSpec.blockInfo.height != 0_tc) {
                 continue;
             }
-            textureSpec.height = TexelCount{val};
+            textureSpec.copySize.height = TexelCount{val};
             for (const BufferSpec& bufferSpec : BaseBufferSpecs(textureSpec)) {
                 DoTest(textureSpec, bufferSpec);
             }
@@ -868,10 +565,10 @@
 TEST_P(CopySplitTest, TextureX) {
     for (TextureSpec textureSpec : kBaseTextureSpecs) {
         for (uint32_t val : kCheckValues) {
-            if (TexelCount{val} % textureSpec.blockWidth != 0_tc) {
+            if (TexelCount{val} % textureSpec.blockInfo.width != 0_tc) {
                 continue;
             }
-            textureSpec.x = TexelCount{val};
+            textureSpec.origin.x = TexelCount{val};
             for (const BufferSpec& bufferSpec : BaseBufferSpecs(textureSpec)) {
                 DoTest(textureSpec, bufferSpec);
             }
@@ -882,10 +579,10 @@
 TEST_P(CopySplitTest, TextureY) {
     for (TextureSpec textureSpec : kBaseTextureSpecs) {
         for (uint32_t val : kCheckValues) {
-            if (TexelCount{val} % textureSpec.blockHeight != 0_tc) {
+            if (TexelCount{val} % textureSpec.blockInfo.height != 0_tc) {
                 continue;
             }
-            textureSpec.y = TexelCount{val};
+            textureSpec.origin.y = TexelCount{val};
             for (const BufferSpec& bufferSpec : BaseBufferSpecs(textureSpec)) {
                 DoTest(textureSpec, bufferSpec);
             }
@@ -896,7 +593,7 @@
 TEST_P(CopySplitTest, TexelSize) {
     for (TextureSpec textureSpec : kBaseTextureSpecs) {
         for (uint32_t texelSize : {4, 8, 16, 32, 64}) {
-            textureSpec.texelBlockSizeInBytes = texelSize;
+            textureSpec.blockInfo.byteSize = texelSize;
             for (const BufferSpec& bufferSpec : BaseBufferSpecs(textureSpec)) {
                 DoTest(textureSpec, bufferSpec);
             }
@@ -908,8 +605,7 @@
     for (const TextureSpec& textureSpec : kBaseTextureSpecs) {
         for (BufferSpec bufferSpec : BaseBufferSpecs(textureSpec)) {
             for (uint32_t val : kCheckValues) {
-                bufferSpec.offset = textureSpec.texelBlockSizeInBytes * val;
-
+                bufferSpec.offset = textureSpec.blockInfo.byteSize * val;
                 DoTest(textureSpec, bufferSpec);
             }
         }
@@ -958,15 +654,9 @@
 TEST_F(CopySplitTest, Block4x4_3D_CopyOneRow_StraddleBytesPerRowOffset) {
     constexpr TexelCount blockDim = 4_tc;
     constexpr uint32_t bytesPerBlock = 8;
-    TextureSpec textureSpec = {.x = 0_tc,
-                               .y = 0_tc,
-                               .z = 0_tc,
-                               .width = 128_tc,
-                               .height = 1_tc * blockDim,
-                               .depthOrArrayLayers = 8_tc,
-                               .texelBlockSizeInBytes = bytesPerBlock,
-                               .blockWidth = blockDim,
-                               .blockHeight = blockDim};
+    TextureSpec textureSpec = {.origin = {0_tc, 0_tc, 0_tc},
+                               .copySize = {128_tc, 1_tc * blockDim, 8_tc},
+                               .blockInfo = {bytesPerBlock, blockDim, blockDim}};
     BufferSpec bufferSpec = {.offset = 3592, .bytesPerRow = 256, .rowsPerImage = 1_bc};
     DoTest(textureSpec, bufferSpec, wgpu::TextureDimension::e3D, false);
 }
@@ -974,15 +664,9 @@
 TEST_F(CopySplitTest, Block2x2_3D_CopyOneRow_StraddleBytesPerRowOffset) {
     constexpr TexelCount blockDim = 2_tc;
     constexpr uint32_t bytesPerBlock = 4;
-    TextureSpec textureSpec = {.x = 0_tc,
-                               .y = 0_tc,
-                               .z = 0_tc,
-                               .width = 128_tc,
-                               .height = 1_tc * blockDim,
-                               .depthOrArrayLayers = 8_tc,
-                               .texelBlockSizeInBytes = bytesPerBlock,
-                               .blockWidth = blockDim,
-                               .blockHeight = blockDim};
+    TextureSpec textureSpec = {.origin = {0_tc, 0_tc, 0_tc},
+                               .copySize = {128_tc, 1_tc * blockDim, 8_tc},
+                               .blockInfo = {bytesPerBlock, blockDim, blockDim}};
     BufferSpec bufferSpec = {.offset = 3592, .bytesPerRow = 256, .rowsPerImage = 1_bc};
     DoTest(textureSpec, bufferSpec, wgpu::TextureDimension::e3D, false);
 }
@@ -990,15 +674,9 @@
 TEST_F(CopySplitTest, Block1x1_3D_CopyOneRow_StraddleBytesPerRowOffset) {
     constexpr TexelCount blockDim = 1_tc;
     constexpr uint32_t bytesPerBlock = 4;
-    TextureSpec textureSpec = {.x = 0_tc,
-                               .y = 0_tc,
-                               .z = 0_tc,
-                               .width = 128_tc,
-                               .height = 1_tc * blockDim,
-                               .depthOrArrayLayers = 8_tc,
-                               .texelBlockSizeInBytes = bytesPerBlock,
-                               .blockWidth = blockDim,
-                               .blockHeight = blockDim};
+    TextureSpec textureSpec = {.origin = {0_tc, 0_tc, 0_tc},
+                               .copySize = {128_tc, 1_tc * blockDim, 8_tc},
+                               .blockInfo = {bytesPerBlock, blockDim, blockDim}};
     BufferSpec bufferSpec = {.offset = 3592, .bytesPerRow = 256, .rowsPerImage = 1_bc};
     DoTest(textureSpec, bufferSpec, wgpu::TextureDimension::e3D, false);
 }