Fix a bug about mip dimension calculation

Mip dimension should be greater than or equal to 1, while width >> level
may lead to 0.

Bug: dawn:547

Change-Id: Ib3dfb9fbdbed0e922df6efa366598eff0ca10df2
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/49506
Commit-Queue: Yunchao He <yunchao.he@intel.com>
Reviewed-by: Austin Eng <enga@chromium.org>

src/dawn_native/CommandEncoder.cpp

@@ -179,17 +179,13 @@ namespace dawn_native {
                 return DAWN_VALIDATION_ERROR("The mip level count of the resolve target must be 1");
             }
 
-            uint32_t colorAttachmentBaseMipLevel = attachment->GetBaseMipLevel();
+            const Extent3D& colorTextureSize =
-            const Extent3D& colorTextureSize = attachment->GetTexture()->GetSize();
+                attachment->GetTexture()->GetMipLevelVirtualSize(attachment->GetBaseMipLevel());
-            uint32_t colorAttachmentWidth = colorTextureSize.width >> colorAttachmentBaseMipLevel;
+            const Extent3D& resolveTextureSize =
-            uint32_t colorAttachmentHeight = colorTextureSize.height >> colorAttachmentBaseMipLevel;
+                resolveTarget->GetTexture()->GetMipLevelVirtualSize(
-
+                    resolveTarget->GetBaseMipLevel());
-            uint32_t resolveTargetBaseMipLevel = resolveTarget->GetBaseMipLevel();
+            if (colorTextureSize.width != resolveTextureSize.width ||
-            const Extent3D& resolveTextureSize = resolveTarget->GetTexture()->GetSize();
+                colorTextureSize.height != resolveTextureSize.height) {
-            uint32_t resolveTargetWidth = resolveTextureSize.width >> resolveTargetBaseMipLevel;
-            uint32_t resolveTargetHeight = resolveTextureSize.height >> resolveTargetBaseMipLevel;
-            if (colorAttachmentWidth != resolveTargetWidth ||
-                colorAttachmentHeight != resolveTargetHeight) {
                 return DAWN_VALIDATION_ERROR(
                     "The size of the resolve target must be the same as the color attachment");
             }

src/tests/end2end/CopyTests.cpp

@@ -671,6 +671,27 @@ TEST_P(CopyTests_T2B, TextureMipAligned) {
     }
 }
 
+// Test that copying mips when one dimension is 256-byte aligned and another dimension reach one
+// works
+TEST_P(CopyTests_T2B, TextureMipDimensionReachOne) {
+    constexpr uint32_t mipLevelCount = 4;
+    constexpr uint32_t kWidth = 256 << mipLevelCount;
+    constexpr uint32_t kHeight = 2;
+
+    TextureSpec defaultTextureSpec;
+    defaultTextureSpec.textureSize = {kWidth, kHeight, 1};
+
+    TextureSpec textureSpec = defaultTextureSpec;
+    textureSpec.levelCount = mipLevelCount;
+
+    for (unsigned int i = 0; i < 4; ++i) {
+        textureSpec.copyLevel = i;
+        DoTest(textureSpec,
+               MinimumBufferSpec(std::max(kWidth >> i, 1u), std::max(kHeight >> i, 1u)),
+               {std::max(kWidth >> i, 1u), std::max(kHeight >> i, 1u), 1});
+    }
+}
+
 // Test that copying mips without 256-byte aligned sizes works
 TEST_P(CopyTests_T2B, TextureMipUnaligned) {
     constexpr uint32_t kWidth = 259;

src/utils/TestUtils.cpp

@@ -39,8 +39,8 @@ namespace utils {
 
         TextureDataCopyLayout layout;
 
-        layout.mipSize = {textureSizeAtLevel0.width >> mipmapLevel,
+        layout.mipSize = {std::max(textureSizeAtLevel0.width >> mipmapLevel, 1u),
-                          textureSizeAtLevel0.height >> mipmapLevel,
+                          std::max(textureSizeAtLevel0.height >> mipmapLevel, 1u),
                           textureSizeAtLevel0.depthOrArrayLayers};
 
         layout.bytesPerRow = GetMinimumBytesPerRow(format, layout.mipSize.width);