Reland "Add Getter for TextureBindingViewDimension"

This reverts commit adb36e4.

Reason for revert: Should be able to cleanly reland over
https://dawn-review.googlesource.com/c/dawn/+/282095
The GN issue should be fixed, so we should be able to rely on CQ.
(Technically these should be bundled into one change, but they come
from different authors, and can be landed separately, so that's what
I'm doing.)

Bug: 466134210
Bug: 458616688
Change-Id: I3324ca170661b3c5c176cc3ff5e5fd88edef4a99
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/282896
Bot-Commit: rubber-stamper@appspot.gserviceaccount.com <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: Kai Ninomiya <kainino@chromium.org>

Author: kainino0x

src/dawn/dawn.json

@@ -4087,6 +4087,11 @@
                 "no autolock": true,
                 "returns": "texture usage"
             },
+            {
+                "name": "get texture binding view dimension",
+                "no autolock": true,
+                "returns": "texture view dimension"
+            },
             {
                 "name": "destroy"
             },

src/dawn/dawn_wire.json

@@ -304,13 +304,16 @@
             "TextureGetSampleCount",
             "TextureGetDimension",
             "TextureGetFormat",
-            "TextureGetUsage"
+            "TextureGetUsage",
+            "TextureGetTextureBindingViewDimension"
         ],
         "client_handwritten_commands": [
             "AdapterGetInstance",
             "BufferDestroy",
             "BufferUnmap",
             "DeviceCreateErrorBuffer",
+            "DeviceCreateErrorTexture",
+            "DeviceCreateTexture",
             "DeviceDestroy",
             "DeviceGetQueue",
             "DeviceGetSupportedSurfaceUsage",

src/dawn/native/Texture.cpp

@@ -602,37 +602,49 @@ bool CopySrcNeedsInternalTextureBindingUsage(const DeviceBase* device, const For
     return false;
 }
 
-wgpu::TextureViewDimension ResolveDefaultCompatiblityTextureBindingViewDimension(
+wgpu::TextureViewDimension ResolveDefaultCompatiblityTextureBindingViewDimensionImpl(
     const DeviceBase* device,
-    const UnpackedPtr<TextureDescriptor>& descriptor) {
+    wgpu::TextureDimension dimension,
+    uint32_t depthOrArrayLayers,
+    wgpu::TextureViewDimension textureBindingViewDimension) {
     // In non-compatibility mode this value is not used so return undefined so that it is not
     // used by mistake.
     if (device->HasFlexibleTextureViews()) {
         return wgpu::TextureViewDimension::Undefined;
     }
 
-    auto textureBindingViewDimension = wgpu::TextureViewDimension::Undefined;
-    if (auto* subDesc = descriptor.Get<TextureBindingViewDimensionDescriptor>()) {
-        textureBindingViewDimension = subDesc->textureBindingViewDimension;
-    }
     if (textureBindingViewDimension != wgpu::TextureViewDimension::Undefined) {
         return textureBindingViewDimension;
     }
 
-    switch (descriptor->dimension) {
+    switch (dimension) {
         case wgpu::TextureDimension::e1D:
             return wgpu::TextureViewDimension::e1D;
         case wgpu::TextureDimension::e2D:
-            return descriptor->size.depthOrArrayLayers == 1 ? wgpu::TextureViewDimension::e2D
-                                                            : wgpu::TextureViewDimension::e2DArray;
+            return depthOrArrayLayers == 1 ? wgpu::TextureViewDimension::e2D
+                                           : wgpu::TextureViewDimension::e2DArray;
         case wgpu::TextureDimension::e3D:
             return wgpu::TextureViewDimension::e3D;
         case wgpu::TextureDimension::Undefined:
         default:
-            DAWN_UNREACHABLE();
+            // We could get here on an error texture.
+            return wgpu::TextureViewDimension::Undefined;
     }
 }
 
+wgpu::TextureViewDimension ResolveDefaultCompatiblityTextureBindingViewDimension(
+    const DeviceBase* device,
+    const UnpackedPtr<TextureDescriptor>& descriptor) {
+    auto textureBindingViewDimension = wgpu::TextureViewDimension::Undefined;
+    if (auto* subDesc = descriptor.Get<TextureBindingViewDimensionDescriptor>()) {
+        textureBindingViewDimension = subDesc->textureBindingViewDimension;
+    }
+
+    return ResolveDefaultCompatiblityTextureBindingViewDimensionImpl(
+        device, descriptor->dimension, descriptor->size.depthOrArrayLayers,
+        textureBindingViewDimension);
+}
+
 wgpu::TextureUsage AddInternalUsages(const DeviceBase* device,
                                      wgpu::TextureUsage usage,
                                      const Format& format,
@@ -1023,7 +1035,21 @@ TextureBase::TextureBase(DeviceBase* device,
       mMipLevelCount(descriptor->mipLevelCount),
       mSampleCount(descriptor->sampleCount),
       mUsage(descriptor->usage),
-      mFormatEnumForReflection(descriptor->format) {}
+      mFormatEnumForReflection(descriptor->format) {
+    auto textureBindingViewDimension = wgpu::TextureViewDimension::Undefined;
+    for (const wgpu::ChainedStruct* chain = descriptor->nextInChain; chain != nullptr;
+         chain = chain->nextInChain) {
+        if (chain->sType == wgpu::SType::TextureBindingViewDimensionDescriptor) {
+            textureBindingViewDimension =
+                reinterpret_cast<const TextureBindingViewDimensionDescriptor*>(chain)
+                    ->textureBindingViewDimension;
+        }
+    }
+
+    mCompatibilityTextureBindingViewDimension =
+        ResolveDefaultCompatiblityTextureBindingViewDimensionImpl(
+            device, mDimension, mBaseSize.depthOrArrayLayers, textureBindingViewDimension);
+}
 
 void TextureBase::DestroyImpl() {
     // TODO(crbug.com/dawn/831): DestroyImpl is called from two places.
@@ -1545,6 +1571,10 @@ wgpu::TextureUsage TextureBase::APIGetUsage() const {
     return mUsage;
 }
 
+wgpu::TextureViewDimension TextureBase::APIGetTextureBindingViewDimension() const {
+    return mCompatibilityTextureBindingViewDimension;
+}
+
 void TextureBase::APIPin(wgpu::TextureUsage usage) {
     // There is no status to return so we don't need to handle the case where an error has been
     // consumed.

src/dawn/native/Texture.h

@@ -248,6 +248,7 @@ class TextureBase : public RefCountedWithExternalCount<SharedResource> {
     wgpu::TextureDimension APIGetDimension() const;
     wgpu::TextureFormat APIGetFormat() const;
     wgpu::TextureUsage APIGetUsage() const;
+    wgpu::TextureViewDimension APIGetTextureBindingViewDimension() const;
 
   protected:
     TextureBase(DeviceBase* device, const UnpackedPtr<TextureDescriptor>& descriptor);

src/dawn/tests/unittests/validation/TextureValidationTests.cpp

@@ -712,6 +712,78 @@ TEST_F(TextureValidationTest, UseASTCFormatWithoutEnablingFeature) {
     }
 }
 
+class TextureCompatValidationTest : public ValidationTest {
+  protected:
+    bool UseCompatibilityMode() const override { return true; }
+
+    wgpu::TextureDescriptor CreateDefaultTextureDescriptor() {
+        wgpu::TextureDescriptor descriptor;
+        descriptor.size.width = 1;
+        descriptor.size.height = 1;
+        descriptor.size.depthOrArrayLayers = 1;
+        descriptor.mipLevelCount = 1;
+        descriptor.sampleCount = 1;
+        descriptor.dimension = wgpu::TextureDimension::e2D;
+        descriptor.format = wgpu::TextureFormat::RGBA8Unorm;
+        descriptor.usage = wgpu::TextureUsage::TextureBinding;
+        return descriptor;
+    }
+};
+
+TEST_F(TextureCompatValidationTest, TextureBindingViewDimension1DDefaultsTo1D) {
+    wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+    descriptor.dimension = wgpu::TextureDimension::e1D;
+    wgpu::Texture tex = device.CreateTexture(&descriptor);
+
+    EXPECT_EQ(wgpu::TextureViewDimension::e1D, tex.GetTextureBindingViewDimension());
+}
+
+TEST_F(TextureCompatValidationTest, TextureBindingViewDimension2DDefaultsTo2D) {
+    wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+    descriptor.dimension = wgpu::TextureDimension::e2D;
+    wgpu::Texture tex = device.CreateTexture(&descriptor);
+
+    EXPECT_EQ(wgpu::TextureViewDimension::e2D, tex.GetTextureBindingViewDimension());
+}
+
+TEST_F(TextureCompatValidationTest, TextureBindingViewDimension2DWith2PlusLayersDefaultsTo2D) {
+    wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+    descriptor.dimension = wgpu::TextureDimension::e2D;
+    descriptor.size.depthOrArrayLayers = 2;
+    wgpu::Texture tex = device.CreateTexture(&descriptor);
+
+    EXPECT_EQ(wgpu::TextureViewDimension::e2DArray, tex.GetTextureBindingViewDimension());
+}
+
+TEST_F(TextureCompatValidationTest, TextureBindingViewDimension3DDefaultsTo3D) {
+    wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+    descriptor.dimension = wgpu::TextureDimension::e3D;
+    wgpu::Texture tex = device.CreateTexture(&descriptor);
+
+    EXPECT_EQ(wgpu::TextureViewDimension::e3D, tex.GetTextureBindingViewDimension());
+}
+
+TEST_F(TextureCompatValidationTest, TextureBindingViewDimensionInvalidDefaultsToUndefined) {
+    wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+    descriptor.dimension = static_cast<wgpu::TextureDimension>(12345);
+
+    wgpu::Texture tex;
+    ASSERT_DEVICE_ERROR(tex = device.CreateTexture(&descriptor));
+
+    EXPECT_EQ(wgpu::TextureViewDimension::Undefined, tex.GetTextureBindingViewDimension());
+}
+
+TEST_F(TextureCompatValidationTest, TextureBindingViewDimensionInvalidFormatStillSetsDimension) {
+    wgpu::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+    descriptor.format = static_cast<wgpu::TextureFormat>(12345);
+    descriptor.size.depthOrArrayLayers = 2;
+
+    wgpu::Texture tex;
+    ASSERT_DEVICE_ERROR(tex = device.CreateTexture(&descriptor));
+
+    EXPECT_EQ(wgpu::TextureViewDimension::e2DArray, tex.GetTextureBindingViewDimension());
+}
+
 class D32S8TextureFormatsValidationTests : public TextureValidationTest {
   protected:
     std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
@@ -1027,6 +1099,8 @@ static void CheckTextureMatchesDescriptor(const wgpu::Texture& tex,
     }
     EXPECT_EQ(desc.usage, tex.GetUsage());
     EXPECT_EQ(desc.format, tex.GetFormat());
+    // This is undefined in core, set in compat.
+    EXPECT_EQ(wgpu::TextureViewDimension::Undefined, tex.GetTextureBindingViewDimension());
 }
 
 // Test that the texture creation parameters are correctly reflected for succesfully created

src/dawn/tests/unittests/wire/WireInjectTextureTests.cpp

@@ -52,6 +52,10 @@ class WireInjectTextureTests : public WireTest {
     // A placeholder texture format for ReserveTexture. The data in it doesn't matter as long as
     // we don't call texture reflection methods.
     static constexpr wgpu::TextureDescriptor kPlaceholderDesc = {};
+
+    bool IsCompatibilityMode() {
+        return !device.HasFeature(wgpu::FeatureName::CoreFeaturesAndLimits);
+    }
 };
 
 // Test that reserving and injecting a texture makes calls on the client object forward to the
@@ -198,6 +202,12 @@ TEST_F(WireInjectTextureTests, ReservedTextureReflection) {
     ASSERT_EQ(desc.dimension, texture.GetDimension());
     ASSERT_EQ(desc.mipLevelCount, texture.GetMipLevelCount());
     ASSERT_EQ(desc.sampleCount, texture.GetSampleCount());
+
+    wgpu::TextureViewDimension expectedTextureBindingViewDimension =
+        IsCompatibilityMode() ? wgpu::TextureViewDimension::e3D
+                              : wgpu::TextureViewDimension::Undefined;
+
+    ASSERT_EQ(expectedTextureBindingViewDimension, texture.GetTextureBindingViewDimension());
 }
 
 }  // anonymous namespace

src/dawn/wire/client/Client.cpp

@@ -96,7 +96,7 @@ ReservedBuffer Client::ReserveBuffer(WGPUDevice device, const WGPUBufferDescript
 }
 
 ReservedTexture Client::ReserveTexture(WGPUDevice device, const WGPUTextureDescriptor* descriptor) {
-    Ref<Texture> texture = Make<Texture>(descriptor);
+    Ref<Texture> texture = Make<Texture>(FromAPI(device), descriptor);
 
     ReservedTexture result;
     result.handle = texture->GetWireHandle(this);

src/dawn/wire/client/Device.cpp

@@ -395,6 +395,14 @@ WGPUBuffer Device::APICreateErrorBuffer(const WGPUBufferDescriptor* descriptor)
     return Buffer::CreateError(this, descriptor);
 }
 
+WGPUTexture Device::APICreateTexture(const WGPUTextureDescriptor* descriptor) {
+    return Texture::Create(this, descriptor);
+}
+
+WGPUTexture Device::APICreateErrorTexture(const WGPUTextureDescriptor* descriptor) {
+    return Texture::CreateError(this, descriptor);
+}
+
 WGPUAdapter Device::APIGetAdapter() const {
     Ref<Adapter> adapter = mAdapter;
     return ReturnToAPI(std::move(adapter));

src/dawn/wire/client/Device.h

@@ -77,6 +77,8 @@ class Device final : public RefCountedWithExternalCount<ObjectWithEventsBase> {
     WGPUFuture APICreateRenderPipelineAsync(
         WGPURenderPipelineDescriptor const* descriptor,
         const WGPUCreateRenderPipelineAsyncCallbackInfo& callbackInfo);
+    WGPUTexture APICreateTexture(const WGPUTextureDescriptor* descriptor);
+    WGPUTexture APICreateErrorTexture(const WGPUTextureDescriptor* descriptor);
 
     WGPUStatus APIGetLimits(WGPULimits* limits) const;
     WGPUFuture APIGetLostFuture();

src/dawn/wire/client/Surface.cpp

@@ -153,7 +153,7 @@ void Surface::APIGetCurrentTexture(WGPUSurfaceTexture* surfaceTexture) {
 
     // Assume texture creation will work in the server and return a new texture proxy.
     Client* wireClient = GetClient();
-    Ref<Texture> texture = wireClient->Make<Texture>(&mTextureDescriptor);
+    Ref<Texture> texture = wireClient->Make<Texture>(mConfiguredDevice.Get(), &mTextureDescriptor);
 
     SurfaceGetCurrentTextureCmd cmd;
     cmd.surfaceId = GetWireHandle(wireClient).id;