Update tests to use new mapping APIs

This CL updates all tests not specific to the old mapping API to use the
new mapping APIs. (a couple old tests that caused difficult diffs were
removed early).

Also fix an issue where the mapAsync callback wasn't fired with Unknown
when the buffer was destroyed.

Bug: dawn:445

Change-Id: I0101f533ecb1fd995066742b60a833dc2ad522aa
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/26300
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>

src/tests/unittests/validation/BufferValidationTests.cpp

@@ -1265,29 +1265,15 @@ TEST_F(BufferValidationTest, GetMappedRange_OnDestroyedBuffer) {
     }
 }
 
-// Test that it is invalid to call GetMappedRange on a buffer after MapReadAsync
-TEST_F(BufferValidationTest, GetMappedRange_OnMappedForReading) {
-    {
-        wgpu::Buffer buf = CreateMapReadBuffer(4);
+// Test that it is invalid to call GetMappedRange on a buffer after MapAsync for reading
+TEST_F(BufferValidationTest, GetMappedRange_NonConstOnMappedForReading) {
+    wgpu::Buffer buf = CreateMapReadBuffer(4);
 
-        buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr);
-        EXPECT_CALL(*mockBufferMapReadCallback,
-                    Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
-            .Times(1);
-        WaitForAllOperations(device);
+    buf.MapAsync(wgpu::MapMode::Read, 0, 4, ToMockBufferMapAsyncCallback, nullptr);
+    EXPECT_CALL(*mockBufferMapAsyncCallback, Call(WGPUBufferMapAsyncStatus_Success, _)).Times(1);
+    WaitForAllOperations(device);
 
-        ASSERT_EQ(nullptr, buf.GetMappedRange());
-    }
-    {
-        wgpu::Buffer buf = CreateMapReadBuffer(4);
-
-        buf.MapAsync(wgpu::MapMode::Read, 0, 4, ToMockBufferMapAsyncCallback, nullptr);
-        EXPECT_CALL(*mockBufferMapAsyncCallback, Call(WGPUBufferMapAsyncStatus_Success, _))
-            .Times(1);
-        WaitForAllOperations(device);
-
-        ASSERT_EQ(nullptr, buf.GetMappedRange());
-    }
+    ASSERT_EQ(nullptr, buf.GetMappedRange());
 }
 
 // Test valid cases to call GetMappedRange on a buffer.
@@ -1307,38 +1293,25 @@ TEST_F(BufferValidationTest, GetMappedRange_ValidBufferStateCases) {
         ASSERT_EQ(buffer.GetConstMappedRange(), buffer.GetMappedRange());
     }
 
-    // GetMappedRange after MapReadAsync case.
+    // GetMappedRange after MapAsync for reading case.
     {
         wgpu::Buffer buf = CreateMapReadBuffer(4);
 
-        buf.MapReadAsync(ToMockBufferMapReadCallback, nullptr);
-
-        const void* mappedPointer = nullptr;
-        EXPECT_CALL(*mockBufferMapReadCallback,
-                    Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
-            .WillOnce(SaveArg<1>(&mappedPointer));
-
+        buf.MapAsync(wgpu::MapMode::Read, 0, 4, nullptr, nullptr);
         WaitForAllOperations(device);
 
         ASSERT_NE(buf.GetConstMappedRange(), nullptr);
-        ASSERT_EQ(buf.GetConstMappedRange(), mappedPointer);
     }
 
-    // GetMappedRange after MapWriteAsync case.
+    // GetMappedRange after MapAsync for writing case.
     {
         wgpu::Buffer buf = CreateMapWriteBuffer(4);
-        buf.MapWriteAsync(ToMockBufferMapWriteCallback, nullptr);
-
-        const void* mappedPointer = nullptr;
-        EXPECT_CALL(*mockBufferMapWriteCallback,
-                    Call(WGPUBufferMapAsyncStatus_Success, Ne(nullptr), 4u, _))
-            .WillOnce(SaveArg<1>(&mappedPointer));
 
+        buf.MapAsync(wgpu::MapMode::Write, 0, 4, nullptr, nullptr);
         WaitForAllOperations(device);
 
         ASSERT_NE(buf.GetConstMappedRange(), nullptr);
         ASSERT_EQ(buf.GetConstMappedRange(), buf.GetMappedRange());
-        ASSERT_EQ(buf.GetConstMappedRange(), mappedPointer);
     }
 }
 

src/tests/unittests/validation/QueueSubmitValidationTests.cpp

@@ -169,26 +169,14 @@ namespace {
             ASSERT_DEVICE_ERROR(queue.WriteBuffer(buffer, 0, &value, sizeof(value)));
         }
 
-        // MapReadAsync
+        // MapAsync
         {
             wgpu::BufferDescriptor descriptor;
             descriptor.size = 4;
             descriptor.usage = wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::MapRead;
             wgpu::Buffer buf = device.CreateBuffer(&descriptor);
 
-            buf.MapReadAsync(nullptr, nullptr);
-            uint32_t value = 0;
-            ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &value, sizeof(value)));
-        }
-
-        // MapWriteAsync
-        {
-            wgpu::BufferDescriptor descriptor;
-            descriptor.size = 4;
-            descriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::MapWrite;
-            wgpu::Buffer buf = device.CreateBuffer(&descriptor);
-
-            buf.MapWriteAsync(nullptr, nullptr);
+            buf.MapAsync(wgpu::MapMode::Read, 0, 4, nullptr, nullptr);
             uint32_t value = 0;
             ASSERT_DEVICE_ERROR(queue.WriteBuffer(buf, 0, &value, sizeof(value)));
         }

src/tests/unittests/wire/WireBufferMappingTests.cpp

@@ -19,57 +19,20 @@ using namespace dawn_wire;
 
 namespace {
 
-    // Mock classes to add expectations on the wire calling callbacks
-    class MockBufferMapReadCallback {
+    // Mock class to add expectations on the wire calling callbacks
+    class MockBufferMapCallback {
       public:
         MOCK_METHOD(void,
                     Call,
                     (WGPUBufferMapAsyncStatus status,
-                     const uint32_t* ptr,
-                     uint64_t dataLength,
                      void* userdata));
     };
 
-    std::unique_ptr<StrictMock<MockBufferMapReadCallback>> mockBufferMapReadCallback;
-    void ToMockBufferMapReadCallback(WGPUBufferMapAsyncStatus status,
-                                     const void* ptr,
-                                     uint64_t dataLength,
-                                     void* userdata) {
-        // Assume the data is uint32_t to make writing matchers easier
-        mockBufferMapReadCallback->Call(status, static_cast<const uint32_t*>(ptr), dataLength,
-                                        userdata);
+    std::unique_ptr<StrictMock<MockBufferMapCallback>> mockBufferMapCallback;
+    void ToMockBufferMapCallback(WGPUBufferMapAsyncStatus status, void* userdata) {
+        mockBufferMapCallback->Call(status, userdata);
     }
 
-    class MockBufferMapWriteCallback {
-      public:
-        MOCK_METHOD(
-            void,
-            Call,
-            (WGPUBufferMapAsyncStatus status, uint32_t* ptr, uint64_t dataLength, void* userdata));
-    };
-
-    std::unique_ptr<StrictMock<MockBufferMapWriteCallback>> mockBufferMapWriteCallback;
-    uint32_t* lastMapWritePointer = nullptr;
-    void ToMockBufferMapWriteCallback(WGPUBufferMapAsyncStatus status,
-                                      void* ptr,
-                                      uint64_t dataLength,
-                                      void* userdata) {
-        // Assume the data is uint32_t to make writing matchers easier
-        lastMapWritePointer = static_cast<uint32_t*>(ptr);
-        mockBufferMapWriteCallback->Call(status, lastMapWritePointer, dataLength, userdata);
-    }
-
-    class MockBufferCreateMappedCallback {
-      public:
-        MOCK_METHOD(void,
-                    Call,
-                    (WGPUBufferMapAsyncStatus status,
-                     WGPUBuffer buffer,
-                     uint32_t* ptr,
-                     uint64_t dataLength,
-                     void* userdata));
-    };
-
 }  // anonymous namespace
 
 class WireBufferMappingTests : public WireTest {
@@ -81,8 +44,7 @@ class WireBufferMappingTests : public WireTest {
     void SetUp() override {
         WireTest::SetUp();
 
-        mockBufferMapReadCallback = std::make_unique<StrictMock<MockBufferMapReadCallback>>();
-        mockBufferMapWriteCallback = std::make_unique<StrictMock<MockBufferMapWriteCallback>>();
+        mockBufferMapCallback = std::make_unique<StrictMock<MockBufferMapCallback>>();
 
         WGPUBufferDescriptor descriptor = {};
         descriptor.size = kBufferSize;
@@ -99,16 +61,14 @@ class WireBufferMappingTests : public WireTest {
     void TearDown() override {
         WireTest::TearDown();
 
-        // Delete mocks so that expectations are checked
-        mockBufferMapReadCallback = nullptr;
-        mockBufferMapWriteCallback = nullptr;
+        // Delete mock so that expectations are checked
+        mockBufferMapCallback = nullptr;
     }
 
     void FlushServer() {
         WireTest::FlushServer();
 
-        Mock::VerifyAndClearExpectations(&mockBufferMapReadCallback);
-        Mock::VerifyAndClearExpectations(&mockBufferMapWriteCallback);
+        Mock::VerifyAndClearExpectations(&mockBufferMapCallback);
     }
 
   protected:
@@ -118,11 +78,11 @@ class WireBufferMappingTests : public WireTest {
     WGPUBuffer apiBuffer;
 };
 
-// MapRead-specific tests
+// Tests specific to mapping for reading
 
 // Check mapping for reading a succesfully created buffer
 TEST_F(WireBufferMappingTests, MappingForReadSuccessBuffer) {
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     uint32_t bufferContent = 31337;
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
@@ -133,12 +93,13 @@ TEST_F(WireBufferMappingTests, MappingForReadSuccessBuffer) {
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapReadCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _)).Times(1);
 
     FlushServer();
 
+    EXPECT_EQ(bufferContent,
+              *static_cast<const uint32_t*>(wgpuBufferGetConstMappedRange(buffer, 0, kBufferSize)));
+
     wgpuBufferUnmap(buffer);
     EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
 
@@ -148,7 +109,7 @@ TEST_F(WireBufferMappingTests, MappingForReadSuccessBuffer) {
 // Check that things work correctly when a validation error happens when mapping the buffer for
 // reading
 TEST_F(WireBufferMappingTests, ErrorWhileMappingForRead) {
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
         api.CallMapAsyncCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error);
@@ -156,16 +117,17 @@ TEST_F(WireBufferMappingTests, ErrorWhileMappingForRead) {
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Error, _)).Times(1);
 
     FlushServer();
+
+    EXPECT_EQ(nullptr, wgpuBufferGetConstMappedRange(buffer, 0, kBufferSize));
 }
 
 // Check that the map read callback is called with UNKNOWN when the buffer is destroyed before the
 // request is finished
 TEST_F(WireBufferMappingTests, DestroyBeforeReadRequestEnd) {
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     // Return success
     uint32_t bufferContent = 0;
@@ -176,8 +138,7 @@ TEST_F(WireBufferMappingTests, DestroyBeforeReadRequestEnd) {
         .WillOnce(Return(&bufferContent));
 
     // Destroy before the client gets the success, so the callback is called with unknown.
-    EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Unknown, _)).Times(1);
     wgpuBufferRelease(buffer);
     EXPECT_CALL(api, BufferRelease(apiBuffer));
 
@@ -188,7 +149,7 @@ TEST_F(WireBufferMappingTests, DestroyBeforeReadRequestEnd) {
 // Check the map read callback is called with UNKNOWN when the map request would have worked, but
 // Unmap was called
 TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForRead) {
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     uint32_t bufferContent = 31337;
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
@@ -200,8 +161,7 @@ TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForRead) {
     FlushClient();
 
     // Oh no! We are calling Unmap too early!
-    EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Unknown, _)).Times(1);
     wgpuBufferUnmap(buffer);
 
     // The callback shouldn't get called, even when the request succeeded on the server side
@@ -211,7 +171,7 @@ TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForRead) {
 // Check that an error map read callback gets nullptr while a buffer is already mapped
 TEST_F(WireBufferMappingTests, MappingForReadingErrorWhileAlreadyMappedGetsNullptr) {
     // Successful map
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     uint32_t bufferContent = 31337;
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
@@ -222,29 +182,28 @@ TEST_F(WireBufferMappingTests, MappingForReadingErrorWhileAlreadyMappedGetsNullp
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapReadCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _)).Times(1);
 
     FlushServer();
 
     // Map failure while the buffer is already mapped
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
         api.CallMapAsyncCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error);
     }));
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Error, _)).Times(1);
 
     FlushServer();
+
+    EXPECT_EQ(nullptr, wgpuBufferGetConstMappedRange(buffer, 0, kBufferSize));
 }
 
 // Test that the MapReadCallback isn't fired twice when unmap() is called inside the callback
 TEST_F(WireBufferMappingTests, UnmapInsideMapReadCallback) {
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     uint32_t bufferContent = 31337;
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
@@ -255,8 +214,7 @@ TEST_F(WireBufferMappingTests, UnmapInsideMapReadCallback) {
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapReadCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _))
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _))
         .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferUnmap(buffer); }));
 
     FlushServer();
@@ -269,7 +227,7 @@ TEST_F(WireBufferMappingTests, UnmapInsideMapReadCallback) {
 // Test that the MapReadCallback isn't fired twice the buffer external refcount reaches 0 in the
 // callback
 TEST_F(WireBufferMappingTests, DestroyInsideMapReadCallback) {
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     uint32_t bufferContent = 31337;
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
@@ -280,8 +238,7 @@ TEST_F(WireBufferMappingTests, DestroyInsideMapReadCallback) {
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapReadCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(bufferContent)), kBufferSize, _))
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _))
         .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferRelease(buffer); }));
 
     FlushServer();
@@ -291,15 +248,14 @@ TEST_F(WireBufferMappingTests, DestroyInsideMapReadCallback) {
     FlushClient();
 }
 
-// MapWrite-specific tests
+// Tests specific to mapping for writing
 
 // Check mapping for writing a succesfully created buffer
 TEST_F(WireBufferMappingTests, MappingForWriteSuccessBuffer) {
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     uint32_t serverBufferContent = 31337;
     uint32_t updatedContent = 4242;
-    uint32_t zero = 0;
 
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
         api.CallMapAsyncCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success);
@@ -310,12 +266,14 @@ TEST_F(WireBufferMappingTests, MappingForWriteSuccessBuffer) {
     FlushClient();
 
     // The map write callback always gets a buffer full of zeroes.
-    EXPECT_CALL(*mockBufferMapWriteCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _)).Times(1);
 
     FlushServer();
 
+    uint32_t* lastMapWritePointer =
+        static_cast<uint32_t*>(wgpuBufferGetMappedRange(buffer, 0, kBufferSize));
+    ASSERT_EQ(0u, *lastMapWritePointer);
+
     // Write something to the mapped pointer
     *lastMapWritePointer = updatedContent;
 
@@ -331,7 +289,7 @@ TEST_F(WireBufferMappingTests, MappingForWriteSuccessBuffer) {
 // Check that things work correctly when a validation error happens when mapping the buffer for
 // writing
 TEST_F(WireBufferMappingTests, ErrorWhileMappingForWrite) {
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
         api.CallMapAsyncCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error);
@@ -339,16 +297,17 @@ TEST_F(WireBufferMappingTests, ErrorWhileMappingForWrite) {
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Error, _)).Times(1);
 
     FlushServer();
+
+    EXPECT_EQ(nullptr, wgpuBufferGetMappedRange(buffer, 0, kBufferSize));
 }
 
 // Check that the map write callback is called with UNKNOWN when the buffer is destroyed before the
 // request is finished
 TEST_F(WireBufferMappingTests, DestroyBeforeWriteRequestEnd) {
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     // Return success
     uint32_t bufferContent = 31337;
@@ -359,8 +318,7 @@ TEST_F(WireBufferMappingTests, DestroyBeforeWriteRequestEnd) {
         .WillOnce(Return(&bufferContent));
 
     // Destroy before the client gets the success, so the callback is called with unknown.
-    EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Unknown, _)).Times(1);
     wgpuBufferRelease(buffer);
     EXPECT_CALL(api, BufferRelease(apiBuffer));
 
@@ -371,7 +329,7 @@ TEST_F(WireBufferMappingTests, DestroyBeforeWriteRequestEnd) {
 // Check the map read callback is called with UNKNOWN when the map request would have worked, but
 // Unmap was called
 TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForWrite) {
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     uint32_t bufferContent = 31337;
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
@@ -383,8 +341,7 @@ TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForWrite) {
     FlushClient();
 
     // Oh no! We are calling Unmap too early!
-    EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Unknown, _)).Times(1);
     wgpuBufferUnmap(buffer);
 
     // The callback shouldn't get called, even when the request succeeded on the server side
@@ -394,10 +351,9 @@ TEST_F(WireBufferMappingTests, UnmapCalledTooEarlyForWrite) {
 // Check that an error map read callback gets nullptr while a buffer is already mapped
 TEST_F(WireBufferMappingTests, MappingForWritingErrorWhileAlreadyMappedGetsNullptr) {
     // Successful map
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     uint32_t bufferContent = 31337;
-    uint32_t zero = 0;
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
         api.CallMapAsyncCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success);
     }));
@@ -406,32 +362,30 @@ TEST_F(WireBufferMappingTests, MappingForWritingErrorWhileAlreadyMappedGetsNullp
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapWriteCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _)).Times(1);
 
     FlushServer();
 
     // Map failure while the buffer is already mapped
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
         api.CallMapAsyncCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error);
     }));
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Error, _)).Times(1);
 
     FlushServer();
+
+    EXPECT_EQ(nullptr, wgpuBufferGetMappedRange(buffer, 0, kBufferSize));
 }
 
 // Test that the MapWriteCallback isn't fired twice when unmap() is called inside the callback
 TEST_F(WireBufferMappingTests, UnmapInsideMapWriteCallback) {
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     uint32_t bufferContent = 31337;
-    uint32_t zero = 0;
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
         api.CallMapAsyncCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success);
     }));
@@ -440,8 +394,7 @@ TEST_F(WireBufferMappingTests, UnmapInsideMapWriteCallback) {
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapWriteCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _))
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _))
         .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferUnmap(buffer); }));
 
     FlushServer();
@@ -454,10 +407,9 @@ TEST_F(WireBufferMappingTests, UnmapInsideMapWriteCallback) {
 // Test that the MapWriteCallback isn't fired twice the buffer external refcount reaches 0 in the
 // callback
 TEST_F(WireBufferMappingTests, DestroyInsideMapWriteCallback) {
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     uint32_t bufferContent = 31337;
-    uint32_t zero = 0;
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
         api.CallMapAsyncCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success);
     }));
@@ -466,8 +418,7 @@ TEST_F(WireBufferMappingTests, DestroyInsideMapWriteCallback) {
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapWriteCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _))
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _))
         .WillOnce(InvokeWithoutArgs([&]() { wgpuBufferRelease(buffer); }));
 
     FlushServer();
@@ -542,9 +493,8 @@ TEST_F(WireBufferMappingTests, MappedAtCreationThenMapSuccess) {
 
     FlushClient();
 
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
-    uint32_t zero = 0;
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
         api.CallMapAsyncCallback(apiBuffer, WGPUBufferMapAsyncStatus_Success);
     }));
@@ -553,9 +503,7 @@ TEST_F(WireBufferMappingTests, MappedAtCreationThenMapSuccess) {
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapWriteCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, Pointee(Eq(zero)), kBufferSize, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _)).Times(1);
 
     FlushServer();
 }
@@ -576,7 +524,7 @@ TEST_F(WireBufferMappingTests, MappedAtCreationThenMapFailure) {
 
     FlushClient();
 
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     EXPECT_CALL(api, OnBufferMapAsyncCallback(apiBuffer, _, _)).WillOnce(InvokeWithoutArgs([&]() {
         api.CallMapAsyncCallback(apiBuffer, WGPUBufferMapAsyncStatus_Error);
@@ -584,11 +532,12 @@ TEST_F(WireBufferMappingTests, MappedAtCreationThenMapFailure) {
 
     FlushClient();
 
-    EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Error, _)).Times(1);
 
     FlushServer();
 
+    EXPECT_EQ(nullptr, wgpuBufferGetConstMappedRange(buffer, 0, kBufferSize));
+
     wgpuBufferUnmap(buffer);
     EXPECT_CALL(api, BufferUnmap(apiBuffer)).Times(1);
 

src/tests/unittests/wire/WireMemoryTransferServiceTests.cpp

@@ -22,55 +22,20 @@ using namespace dawn_wire;
 
 namespace {
 
-    // Mock classes to add expectations on the wire calling callbacks
-    class MockBufferMapReadCallback {
+    // Mock class to add expectations on the wire calling callbacks
+    class MockBufferMapCallback {
       public:
         MOCK_METHOD(void,
                     Call,
                     (WGPUBufferMapAsyncStatus status,
-                     const uint32_t* ptr,
-                     uint64_t dataLength,
                      void* userdata));
     };
 
-    std::unique_ptr<StrictMock<MockBufferMapReadCallback>> mockBufferMapReadCallback;
-    void ToMockBufferMapReadCallback(WGPUBufferMapAsyncStatus status,
-                                     const void* ptr,
-                                     uint64_t dataLength,
-                                     void* userdata) {
-        // Assume the data is uint32_t to make writing matchers easier
-        mockBufferMapReadCallback->Call(status, static_cast<const uint32_t*>(ptr), dataLength,
-                                        userdata);
+    std::unique_ptr<StrictMock<MockBufferMapCallback>> mockBufferMapCallback;
+    void ToMockBufferMapCallback(WGPUBufferMapAsyncStatus status, void* userdata) {
+        mockBufferMapCallback->Call(status, userdata);
     }
 
-    class MockBufferMapWriteCallback {
-      public:
-        MOCK_METHOD(
-            void,
-            Call,
-            (WGPUBufferMapAsyncStatus status, uint32_t* ptr, uint64_t dataLength, void* userdata));
-    };
-
-    std::unique_ptr<StrictMock<MockBufferMapWriteCallback>> mockBufferMapWriteCallback;
-    void ToMockBufferMapWriteCallback(WGPUBufferMapAsyncStatus status,
-                                      void* ptr,
-                                      uint64_t dataLength,
-                                      void* userdata) {
-        // Assume the data is uint32_t to make writing matchers easier
-        mockBufferMapWriteCallback->Call(status, static_cast<uint32_t*>(ptr), dataLength, userdata);
-    }
-
-    class MockBufferCreateMappedCallback {
-      public:
-        MOCK_METHOD(void,
-                    Call,
-                    (WGPUBufferMapAsyncStatus status,
-                     WGPUBuffer buffer,
-                     uint32_t* ptr,
-                     uint64_t dataLength,
-                     void* userdata));
-    };
-
 }  // anonymous namespace
 
 // WireMemoryTransferServiceTests test the MemoryTransferService with buffer mapping.
@@ -102,8 +67,7 @@ class WireMemoryTransferServiceTests : public WireTest {
     void SetUp() override {
         WireTest::SetUp();
 
-        mockBufferMapReadCallback = std::make_unique<StrictMock<MockBufferMapReadCallback>>();
-        mockBufferMapWriteCallback = std::make_unique<StrictMock<MockBufferMapWriteCallback>>();
+        mockBufferMapCallback = std::make_unique<StrictMock<MockBufferMapCallback>>();
 
         // TODO(enga): Make this thread-safe.
         mBufferContent++;
@@ -117,9 +81,8 @@ class WireMemoryTransferServiceTests : public WireTest {
     void TearDown() override {
         WireTest::TearDown();
 
-        // Delete mocks so that expectations are checked
-        mockBufferMapReadCallback = nullptr;
-        mockBufferMapWriteCallback = nullptr;
+        // Delete mock so that expectations are checked
+        mockBufferMapCallback = nullptr;
     }
 
     void FlushClient(bool success = true) {
@@ -130,8 +93,7 @@ class WireMemoryTransferServiceTests : public WireTest {
     void FlushServer(bool success = true) {
         WireTest::FlushServer(success);
 
-        Mock::VerifyAndClearExpectations(&mockBufferMapReadCallback);
-        Mock::VerifyAndClearExpectations(&mockBufferMapWriteCallback);
+        Mock::VerifyAndClearExpectations(&mockBufferMapCallback);
         Mock::VerifyAndClearExpectations(&clientMemoryTransferService);
     }
 
@@ -365,20 +327,20 @@ uint32_t WireMemoryTransferServiceTests::mSerializeCreateInfo = 4242;
 uint32_t WireMemoryTransferServiceTests::mSerializeInitialDataInfo = 1394;
 uint32_t WireMemoryTransferServiceTests::mSerializeFlushInfo = 1235;
 
-// Test successful MapRead.
+// Test successful mapping for reading.
 TEST_F(WireMemoryTransferServiceTests, BufferMapReadSuccess) {
     WGPUBuffer buffer;
     WGPUBuffer apiBuffer;
     std::tie(apiBuffer, buffer) = CreateBuffer();
     FlushClient();
 
-    // The client should create and serialize a ReadHandle on mapReadAsync.
+    // The client should create and serialize a ReadHandle on mapAsync for reading.
     ClientReadHandle* clientHandle = ExpectReadHandleCreation();
     ExpectReadHandleSerialization(clientHandle);
 
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
-    // The server should deserialize the MapRead handle from the client and then serialize
+    // The server should deserialize the read handle from the client and then serialize
     // an initialization message.
     ServerReadHandle* serverHandle = ExpectServerReadHandleDeserialize();
     ExpectServerReadHandleInitialize(serverHandle);
@@ -393,9 +355,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadSuccess) {
     FlushClient();
 
     // The client receives a successful callback.
-    EXPECT_CALL(*mockBufferMapReadCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, &mBufferContent, sizeof(mBufferContent), _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _)).Times(1);
 
     // The client should receive the handle initialization message from the server.
     ExpectClientReadHandleDeserializeInitialize(clientHandle, &mBufferContent);
@@ -412,18 +372,18 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadSuccess) {
     FlushClient();
 }
 
-// Test unsuccessful MapRead.
+// Test unsuccessful mapping for reading.
 TEST_F(WireMemoryTransferServiceTests, BufferMapReadError) {
     WGPUBuffer buffer;
     WGPUBuffer apiBuffer;
     std::tie(apiBuffer, buffer) = CreateBuffer();
     FlushClient();
 
-    // The client should create and serialize a ReadHandle on mapReadAsync.
+    // The client should create and serialize a ReadHandle on mapAsync.
     ClientReadHandle* clientHandle = ExpectReadHandleCreation();
     ExpectReadHandleSerialization(clientHandle);
 
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     // The server should deserialize the ReadHandle from the client.
     ServerReadHandle* serverHandle = ExpectServerReadHandleDeserialize();
@@ -439,8 +399,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadError) {
     FlushClient();
 
     // The client receives an error callback.
-    EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Error, _)).Times(1);
 
     // The client receives the map failure and destroys the handle.
     EXPECT_CALL(clientMemoryTransferService, OnReadHandleDestroy(clientHandle)).Times(1);
@@ -454,7 +413,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadError) {
     FlushClient();
 }
 
-// Test MapRead ReadHandle creation failure.
+// Test ReadHandle creation failure.
 TEST_F(WireMemoryTransferServiceTests, BufferMapReadHandleCreationFailure) {
     WGPUBuffer buffer;
     WGPUBuffer apiBuffer;
@@ -466,10 +425,9 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadHandleCreationFailure) {
 
     // Failed creation of a ReadHandle is a mapping failure and the client synchronously receives
     // an error callback.
-    EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Error, _)).Times(1);
 
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 }
 
 // Test MapRead DeserializeReadHandle failure.
@@ -479,11 +437,11 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeReadHandleFailure
     std::tie(apiBuffer, buffer) = CreateBuffer();
     FlushClient();
 
-    // The client should create and serialize a ReadHandle on mapReadAsync.
+    // The client should create and serialize a ReadHandle on mapping for reading..
     ClientReadHandle* clientHandle = ExpectReadHandleCreation();
     ExpectReadHandleSerialization(clientHandle);
 
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     // Mock a Deserialization failure.
     MockServerReadHandleDeserializeFailure();
@@ -492,26 +450,25 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeReadHandleFailure
 
     // The server received a fatal failure and the client callback was never returned.
     // It is called when the wire is destructed.
-    EXPECT_CALL(*mockBufferMapReadCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Unknown, _)).Times(1);
 
     EXPECT_CALL(clientMemoryTransferService, OnReadHandleDestroy(clientHandle)).Times(1);
 }
 
-// Test MapRead DeserializeInitialData failure.
+// Test read handle DeserializeInitialData failure.
 TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeInitialDataFailure) {
     WGPUBuffer buffer;
     WGPUBuffer apiBuffer;
     std::tie(apiBuffer, buffer) = CreateBuffer();
     FlushClient();
 
-    // The client should create and serialize a ReadHandle on mapReadAsync.
+    // The client should create and serialize a ReadHandle on mapping for reading.
     ClientReadHandle* clientHandle = ExpectReadHandleCreation();
     ExpectReadHandleSerialization(clientHandle);
 
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
-    // The server should deserialize the MapRead handle from the client and then serialize
+    // The server should deserialize the read handle from the client and then serialize
     // an initialization message.
     ServerReadHandle* serverHandle = ExpectServerReadHandleDeserialize();
     ExpectServerReadHandleInitialize(serverHandle);
@@ -531,9 +488,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeInitialDataFailur
 
     // Failed deserialization is a fatal failure and the client synchronously receives a
     // DEVICE_LOST callback.
-    EXPECT_CALL(*mockBufferMapReadCallback,
-                Call(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_DeviceLost, _)).Times(1);
 
     // The handle will be destroyed since deserializing failed.
     EXPECT_CALL(clientMemoryTransferService, OnReadHandleDestroy(clientHandle)).Times(1);
@@ -543,20 +498,20 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDeserializeInitialDataFailur
     EXPECT_CALL(serverMemoryTransferService, OnReadHandleDestroy(serverHandle)).Times(1);
 }
 
-// Test MapRead destroying the buffer before unmapping on the client side.
+// Test mapping for reading destroying the buffer before unmapping on the client side.
 TEST_F(WireMemoryTransferServiceTests, BufferMapReadDestroyBeforeUnmap) {
     WGPUBuffer buffer;
     WGPUBuffer apiBuffer;
     std::tie(apiBuffer, buffer) = CreateBuffer();
     FlushClient();
 
-    // The client should create and serialize a ReadHandle on mapReadAsync.
+    // The client should create and serialize a ReadHandle on mapping for reading.
     ClientReadHandle* clientHandle = ExpectReadHandleCreation();
     ExpectReadHandleSerialization(clientHandle);
 
-    wgpuBufferMapReadAsync(buffer, ToMockBufferMapReadCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Read, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
-    // The server should deserialize the MapRead handle from the client and then serialize
+    // The server should deserialize the read handle from the client and then serialize
     // an initialization message.
     ServerReadHandle* serverHandle = ExpectServerReadHandleDeserialize();
     ExpectServerReadHandleInitialize(serverHandle);
@@ -571,9 +526,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDestroyBeforeUnmap) {
     FlushClient();
 
     // The client receives a successful callback.
-    EXPECT_CALL(*mockBufferMapReadCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, &mBufferContent, sizeof(mBufferContent), _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _)).Times(1);
 
     // The client should receive the handle initialization message from the server.
     ExpectClientReadHandleDeserializeInitialize(clientHandle, &mBufferContent);
@@ -598,7 +551,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapReadDestroyBeforeUnmap) {
     }
 }
 
-// Test successful MapWrite.
+// Test successful mapping for writing.
 TEST_F(WireMemoryTransferServiceTests, BufferMapWriteSuccess) {
     WGPUBuffer buffer;
     WGPUBuffer apiBuffer;
@@ -608,7 +561,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteSuccess) {
     ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
     ExpectWriteHandleSerialization(clientHandle);
 
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     // The server should then deserialize the WriteHandle from the client.
     ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
@@ -623,10 +576,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteSuccess) {
     FlushClient();
 
     // The client receives a successful callback.
-    EXPECT_CALL(*mockBufferMapWriteCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, &mMappedBufferContent,
-                     sizeof(mMappedBufferContent), _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _)).Times(1);
 
     // Since the mapping succeeds, the client opens the WriteHandle.
     ExpectClientWriteHandleOpen(clientHandle, &mMappedBufferContent);
@@ -659,11 +609,11 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteError) {
     std::tie(apiBuffer, buffer) = CreateBuffer();
     FlushClient();
 
-    // The client should create and serialize a WriteHandle on mapWriteAsync.
+    // The client should create and serialize a WriteHandle on mapping for writing.
     ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
     ExpectWriteHandleSerialization(clientHandle);
 
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     // The server should then deserialize the WriteHandle from the client.
     ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
@@ -679,8 +629,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteError) {
     FlushClient();
 
     // The client receives an error callback.
-    EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Error, _)).Times(1);
 
     // Client receives the map failure and destroys the handle.
     EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
@@ -694,7 +643,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteError) {
     FlushClient();
 }
 
-// Test MapRead WriteHandle creation failure.
+// Test WriteHandle creation failure.
 TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleCreationFailure) {
     WGPUBuffer buffer;
     WGPUBuffer apiBuffer;
@@ -706,10 +655,9 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleCreationFailure) {
 
     // Failed creation of a WriteHandle is a mapping failure and the client synchronously receives
     // an error callback.
-    EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Error, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Error, _)).Times(1);
 
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 }
 
 // Test MapWrite DeserializeWriteHandle failure.
@@ -719,11 +667,11 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeWriteHandleFailu
     std::tie(apiBuffer, buffer) = CreateBuffer();
     FlushClient();
 
-    // The client should create and serialize a WriteHandle on mapWriteAsync.
+    // The client should create and serialize a WriteHandle on mapping for writing.
     ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
     ExpectWriteHandleSerialization(clientHandle);
 
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     // Mock a deserialization failure.
     MockServerWriteHandleDeserializeFailure();
@@ -732,8 +680,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeWriteHandleFailu
 
     // The server hit a fatal failure and never returned the callback. The client callback is
     // called when the wire is destructed.
-    EXPECT_CALL(*mockBufferMapWriteCallback, Call(WGPUBufferMapAsyncStatus_Unknown, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Unknown, _)).Times(1);
 
     EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
 }
@@ -748,7 +695,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleOpenFailure) {
     ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
     ExpectWriteHandleSerialization(clientHandle);
 
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     // The server should then deserialize the WriteHandle from the client.
     ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
@@ -767,9 +714,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteHandleOpenFailure) {
     MockClientWriteHandleOpenFailure(clientHandle);
 
     // Failing to open a handle is a fatal failure and the client receives a DEVICE_LOST callback.
-    EXPECT_CALL(*mockBufferMapWriteCallback,
-                Call(WGPUBufferMapAsyncStatus_DeviceLost, nullptr, 0, _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_DeviceLost, _)).Times(1);
 
     // Since opening the handle fails, it gets destroyed immediately.
     EXPECT_CALL(clientMemoryTransferService, OnWriteHandleDestroy(clientHandle)).Times(1);
@@ -789,7 +734,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeFlushFailure) {
     ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
     ExpectWriteHandleSerialization(clientHandle);
 
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     // The server should then deserialize the WriteHandle from the client.
     ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
@@ -804,10 +749,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDeserializeFlushFailure) {
     FlushClient();
 
     // The client receives a success callback.
-    EXPECT_CALL(*mockBufferMapWriteCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, &mMappedBufferContent,
-                     sizeof(mMappedBufferContent), _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _)).Times(1);
 
     // Since the mapping succeeds, the client opens the WriteHandle.
     ExpectClientWriteHandleOpen(clientHandle, &mMappedBufferContent);
@@ -841,7 +783,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDestroyBeforeUnmap) {
     ClientWriteHandle* clientHandle = ExpectWriteHandleCreation();
     ExpectWriteHandleSerialization(clientHandle);
 
-    wgpuBufferMapWriteAsync(buffer, ToMockBufferMapWriteCallback, nullptr);
+    wgpuBufferMapAsync(buffer, WGPUMapMode_Write, 0, kBufferSize, ToMockBufferMapCallback, nullptr);
 
     // The server should then deserialize the WriteHandle from the client.
     ServerWriteHandle* serverHandle = ExpectServerWriteHandleDeserialization();
@@ -856,10 +798,7 @@ TEST_F(WireMemoryTransferServiceTests, BufferMapWriteDestroyBeforeUnmap) {
     FlushClient();
 
     // The client receives a successful callback.
-    EXPECT_CALL(*mockBufferMapWriteCallback,
-                Call(WGPUBufferMapAsyncStatus_Success, &mMappedBufferContent,
-                     sizeof(mMappedBufferContent), _))
-        .Times(1);
+    EXPECT_CALL(*mockBufferMapCallback, Call(WGPUBufferMapAsyncStatus_Success, _)).Times(1);
 
     // Since the mapping succeeds, the client opens the WriteHandle.
     ExpectClientWriteHandleOpen(clientHandle, &mMappedBufferContent);