Add tests and fix (create) mapping zero-sized buffers

When creating a zero-sized buffer mapped, StagingBuffer creation
is skipped. This required adding a new MappedAtCreation state
since mStagingBuffer couldn't be used as a tag value for that.

Made the OpenGL backend always create non-zero-sized buffers.

Finally added tests for MapRead/WriteAsync and CreateBufferMapped
of zero-sized buffers.

Bug: dawn:446
Change-Id: I04f6fe98fd646f1867c21065cd1cd33a1595e19f
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/21481
Reviewed-by: Austin Eng <enga@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>

src/tests/end2end/BufferTests.cpp

@@ -108,6 +108,17 @@ TEST_P(BufferMapReadTests, LargeRead) {
     UnmapBuffer(buffer);
 }
 
+// Test mapping a zero-sized buffer.
+TEST_P(BufferMapReadTests, ZeroSized) {
+    wgpu::BufferDescriptor descriptor;
+    descriptor.size = 0;
+    descriptor.usage = wgpu::BufferUsage::MapRead | wgpu::BufferUsage::CopyDst;
+    wgpu::Buffer buffer = device.CreateBuffer(&descriptor);
+
+    MapReadAsyncAndWait(buffer);
+    UnmapBuffer(buffer);
+}
+
 DAWN_INSTANTIATE_TEST(BufferMapReadTests, D3D12Backend(), MetalBackend(), OpenGLBackend(), VulkanBackend());
 
 class BufferMapWriteTests : public DawnTest {
@@ -202,6 +213,17 @@ TEST_P(BufferMapWriteTests, LargeWrite) {
     EXPECT_BUFFER_U32_RANGE_EQ(myData.data(), buffer, 0, kDataSize);
 }
 
+// Test mapping a zero-sized buffer.
+TEST_P(BufferMapWriteTests, ZeroSized) {
+    wgpu::BufferDescriptor descriptor;
+    descriptor.size = 0;
+    descriptor.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::CopySrc;
+    wgpu::Buffer buffer = device.CreateBuffer(&descriptor);
+
+    MapWriteAsyncAndWait(buffer);
+    UnmapBuffer(buffer);
+}
+
 // Stress test mapping many buffers.
 TEST_P(BufferMapWriteTests, ManyWrites) {
     constexpr uint32_t kDataSize = 1000;
@@ -370,6 +392,21 @@ TEST_P(CreateBufferMappedTests, NonMappableUsageLarge) {
     EXPECT_BUFFER_U32_RANGE_EQ(myData.data(), result.buffer, 0, kDataSize);
 }
 
+// Test destroying a non-mappable buffer mapped at creation.
+// This is a regression test for an issue where the D3D12 backend thought the buffer was actually
+// mapped and tried to unlock the heap residency (when actually the buffer was using a staging
+// buffer)
+TEST_P(CreateBufferMappedTests, DestroyNonMappableWhileMappedForCreation) {
+    wgpu::CreateBufferMappedResult result = CreateBufferMapped(wgpu::BufferUsage::CopySrc, 4);
+    result.buffer.Destroy();
+}
+
+// Test destroying a mappable buffer mapped at creation.
+TEST_P(CreateBufferMappedTests, DestroyMappableWhileMappedForCreation) {
+    wgpu::CreateBufferMappedResult result = CreateBufferMapped(wgpu::BufferUsage::MapRead, 4);
+    result.buffer.Destroy();
+}
+
 // Test that mapping a buffer is valid after CreateBufferMapped and Unmap
 TEST_P(CreateBufferMappedTests, CreateThenMapSuccess) {
     static uint32_t myData = 230502;
@@ -437,6 +474,48 @@ TEST_P(CreateBufferMappedTests, LargeBufferFails) {
     ASSERT_DEVICE_ERROR(device.CreateBuffer(&descriptor));
 }
 
+// Test that creating a zero-sized buffer mapped is allowed.
+TEST_P(CreateBufferMappedTests, ZeroSized) {
+    wgpu::BufferDescriptor descriptor;
+    descriptor.size = 0;
+    descriptor.usage = wgpu::BufferUsage::Vertex;
+    wgpu::CreateBufferMappedResult result = device.CreateBufferMapped(&descriptor);
+
+    ASSERT_EQ(0u, result.dataLength);
+    ASSERT_NE(nullptr, result.data);
+
+    // Check that unmapping the buffer works too.
+    UnmapBuffer(result.buffer);
+}
+
+// Test that creating a zero-sized mapppable buffer mapped. (it is a different code path)
+TEST_P(CreateBufferMappedTests, ZeroSizedMappableBuffer) {
+    wgpu::BufferDescriptor descriptor;
+    descriptor.size = 0;
+    descriptor.usage = wgpu::BufferUsage::MapWrite;
+    wgpu::CreateBufferMappedResult result = device.CreateBufferMapped(&descriptor);
+
+    ASSERT_EQ(0u, result.dataLength);
+    ASSERT_NE(nullptr, result.data);
+
+    // Check that unmapping the buffer works too.
+    UnmapBuffer(result.buffer);
+}
+
+// Test that creating a zero-sized error buffer mapped. (it is a different code path)
+TEST_P(CreateBufferMappedTests, ZeroSizedErrorBuffer) {
+    DAWN_SKIP_TEST_IF(IsDawnValidationSkipped());
+
+    wgpu::BufferDescriptor descriptor;
+    descriptor.size = 0;
+    descriptor.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::Storage;
+    wgpu::CreateBufferMappedResult result;
+    ASSERT_DEVICE_ERROR(result = device.CreateBufferMapped(&descriptor));
+
+    ASSERT_EQ(0u, result.dataLength);
+    ASSERT_NE(nullptr, result.data);
+}
+
 DAWN_INSTANTIATE_TEST(CreateBufferMappedTests,
                       D3D12Backend(),
                       D3D12Backend({}, {"use_d3d12_resource_heap_tier2"}),
@@ -446,6 +525,7 @@ DAWN_INSTANTIATE_TEST(CreateBufferMappedTests,
 
 class BufferTests : public DawnTest {};
 
+// Test that creating a zero-buffer is allowed.
 TEST_P(BufferTests, ZeroSizedBuffer) {
     wgpu::BufferDescriptor desc;
     desc.size = 0;
@@ -453,6 +533,17 @@ TEST_P(BufferTests, ZeroSizedBuffer) {
     device.CreateBuffer(&desc);
 }
 
+// Test that creating a very large buffers fails gracefully.
+TEST_P(BufferTests, LargeBufferFails) {
+    // TODO(http://crbug.com/dawn/27): Missing support.
+    DAWN_SKIP_TEST_IF(IsOpenGL());
+
+    wgpu::BufferDescriptor descriptor;
+    descriptor.size = std::numeric_limits<uint64_t>::max();
+    descriptor.usage = wgpu::BufferUsage::MapRead | wgpu::BufferUsage::CopyDst;
+    ASSERT_DEVICE_ERROR(device.CreateBuffer(&descriptor));
+}
+
 DAWN_INSTANTIATE_TEST(BufferTests,
                       D3D12Backend(),
                       MetalBackend(),