Add early-exit validation to MapAsync for already mapped buffers and test case

Author: rajv79

src/dawn/native/Buffer.cpp

@@ -574,6 +574,34 @@ Future BufferBase::APIMapAsync(wgpu::MapMode mode,
     {
         auto deviceGuard = GetDevice()->GetGuard();
 
+            // Early-exit validation: prevent double-mapping of the same buffer.
+            //
+            // According to the WebGPU specification, a buffer must not be mapped more than
+            // once at a time. If a buffer is already in a Mapped or MappedAtCreation state,
+            // calling MapAsync() again is invalid.
+            //
+            // Instead of deferring to the full validation path (ValidateMapAsync),
+            // we return early here with a warning and an error callback to improve
+            // developer feedback and reduce unnecessary work.
+
+            BufferState currentState = mState.load(std::memory_order::acquire);
+            if (currentState == BufferState::Mapped || currentState == BufferState::MappedAtCreation) {
+                // Log a warning for developer visibility. This does not raise a device error.
+                dawn::EmitWarning(GetDevice(),
+                    "Attempted to map a buffer that is already mapped. "
+                    "Call Unmap() before calling MapAsync again.");
+
+                // Trigger the callback immediately with an error status.
+                // This provides synchronous feedback for invalid usage.
+                if (callbackInfo.callback != nullptr) {
+                    callbackInfo.callback(WGPUMapAsyncStatus_Error, callbackInfo.userdata);
+                }
+
+                // Return a null future. No event is tracked for this invalid operation.
+                return Future::MakeEmpty();
+            }
+
+
         // Handle the defaulting of size required by WebGPU, even if in webgpu_cpp.h it is not
         // possible to default the function argument (because there is the callback later in the
         // argument list)
@@ -614,6 +642,9 @@ Future BufferBase::APIMapAsync(wgpu::MapMode mode,
     return {futureID};
 }
 
+
+//****************************************************************************************************** */
+
 void* BufferBase::APIGetMappedRange(size_t offset, size_t size) {
     return GetMappedRange(offset, size, true);
 }

src/dawn/tests/end2end/BufferTests.cpp

@@ -1230,6 +1230,45 @@ TEST_P(BufferTests, CreateErrorBuffer) {
     ASSERT_EQ(buffer, nullptr);
 }
 
+// Test that MapAsync fails if called twice on the same buffer without unmapping.
+TEST_P(BufferValidationTests, MapAsyncFailsWhenAlreadyMapped) {
+    // Create a writable buffer with MapWrite and CopyDst usage.
+    wgpu::BufferDescriptor desc;
+    desc.size = 64;
+    desc.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::CopyDst;
+
+    wgpu::Buffer buffer = device.CreateBuffer(&desc);
+
+    // First call to MapAsync should succeed.
+    bool callback1Called = false;
+    buffer.MapAsync(wgpu::MapMode::Write, 0, 64,
+        [&](WGPUMapAsyncStatus status) {
+            // Expect the first mapping to succeed.
+            EXPECT_EQ(status, WGPUMapAsyncStatus_Success);
+            callback1Called = true;
+        });
+
+    // Immediately call MapAsync again without unmapping.
+    bool callback2Called = false;
+    buffer.MapAsync(wgpu::MapMode::Write, 0, 64,
+        [&](WGPUMapAsyncStatus status) {
+            // The second mapping should fail and return an error.
+            EXPECT_EQ(status, WGPUMapAsyncStatus_Error);
+            callback2Called = true;
+        });
+
+    // Process the commands and trigger callbacks.
+    device.Tick();
+
+    // Ensure both callbacks were actually called.
+    EXPECT_TRUE(callback1Called);
+    EXPECT_TRUE(callback2Called);
+
+    // Cleanup: Unmap the buffer after use.
+    buffer.Unmap();
+}
+
+
 // Test that mapping an OOM buffer fails gracefully
 TEST_P(BufferTests, CreateBufferOOMMapAsync) {
     // TODO(crbug.com/346377856): fails on ANGLE/D3D11, but is likely a Dawn/GL bug that only