diff --git a/src/dawn/tests/unittests/wire/WireDisconnectTests.cpp b/src/dawn/tests/unittests/wire/WireDisconnectTests.cpp
index 5a2f94f..4957945 100644
--- a/src/dawn/tests/unittests/wire/WireDisconnectTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireDisconnectTests.cpp
@@ -47,7 +47,7 @@
 // Test that commands are not received if the client disconnects.
 TEST_F(WireDisconnectTests, CommandsAfterDisconnect) {
     // Check that commands work at all.
-    wgpuDeviceCreateCommandEncoder(cDevice, nullptr);
+    wgpu::CommandEncoder encoder1 = device.CreateCommandEncoder();
 
     WGPUCommandEncoder apiCmdBufEncoder = api.GetNewCommandEncoder();
     EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr))
@@ -58,7 +58,7 @@
     GetWireClient()->Disconnect();
 
     // Command is not received because client disconnected.
-    wgpuDeviceCreateCommandEncoder(cDevice, nullptr);
+    wgpu::CommandEncoder encoder2 = device.CreateCommandEncoder();
     EXPECT_CALL(api, DeviceCreateCommandEncoder(_, _)).Times(Exactly(0));
     FlushClient();
 }
@@ -67,7 +67,7 @@
 // after are received.
 TEST_F(WireDisconnectTests, FlushAfterDisconnect) {
     // Check that commands work at all.
-    wgpuDeviceCreateCommandEncoder(cDevice, nullptr);
+    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
 
     // Disconnect.
     GetWireClient()->Disconnect();
@@ -109,8 +109,8 @@
 // callback again.
 TEST_F(WireDisconnectTests, ServerLostThenDisconnectInCallback) {
     MockCallback<WGPUDeviceLostCallback> mockDeviceLostCallback;
-    wgpuDeviceSetDeviceLostCallback(cDevice, mockDeviceLostCallback.Callback(),
-                                    mockDeviceLostCallback.MakeUserdata(this));
+    device.SetDeviceLostCallback(mockDeviceLostCallback.Callback(),
+                                 mockDeviceLostCallback.MakeUserdata(this));
 
     api.CallDeviceSetDeviceLostCallbackCallback(apiDevice, WGPUDeviceLostReason_Unknown,
                                                 "lost reason");
@@ -129,8 +129,8 @@
 // Check that a device loss after a disconnect does not trigger the callback again.
 TEST_F(WireDisconnectTests, DisconnectThenServerLost) {
     MockCallback<WGPUDeviceLostCallback> mockDeviceLostCallback;
-    wgpuDeviceSetDeviceLostCallback(cDevice, mockDeviceLostCallback.Callback(),
-                                    mockDeviceLostCallback.MakeUserdata(this));
+    device.SetDeviceLostCallback(mockDeviceLostCallback.Callback(),
+                                 mockDeviceLostCallback.MakeUserdata(this));
 
     // Disconnect the client. We should see the callback once.
     EXPECT_CALL(mockDeviceLostCallback, Call(WGPUDeviceLostReason_InstanceDropped, _, this))
@@ -147,9 +147,8 @@
 
 // Test that client objects are all destroyed if the WireClient is destroyed.
 TEST_F(WireDisconnectTests, DeleteClientDestroysObjects) {
-    WGPUSamplerDescriptor desc = {};
-    wgpuDeviceCreateCommandEncoder(cDevice, nullptr);
-    wgpuDeviceCreateSampler(cDevice, &desc);
+    wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+    wgpu::Sampler sampler = device.CreateSampler();
 
     WGPUCommandEncoder apiCommandEncoder = api.GetNewCommandEncoder();
     EXPECT_CALL(api, DeviceCreateCommandEncoder(apiDevice, nullptr))
diff --git a/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp b/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp
index ed44cac..5e92160 100644
--- a/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireErrorCallbackTests.cpp
@@ -106,7 +106,7 @@
 
 // Test the return wire for device validation error callbacks
 TEST_F(WireErrorCallbackTests, DeviceValidationErrorCallback) {
-    wgpuDeviceSetUncapturedErrorCallback(cDevice, ToMockDeviceErrorCallback, this);
+    device.SetUncapturedErrorCallback(ToMockDeviceErrorCallback, this);
 
     // Setting the error callback should stay on the client side and do nothing
     FlushClient();
@@ -125,7 +125,7 @@
 
 // Test the return wire for device OOM error callbacks
 TEST_F(WireErrorCallbackTests, DeviceOutOfMemoryErrorCallback) {
-    wgpuDeviceSetUncapturedErrorCallback(cDevice, ToMockDeviceErrorCallback, this);
+    device.SetUncapturedErrorCallback(ToMockDeviceErrorCallback, this);
 
     // Setting the error callback should stay on the client side and do nothing
     FlushClient();
@@ -144,7 +144,7 @@
 
 // Test the return wire for device internal error callbacks
 TEST_F(WireErrorCallbackTests, DeviceInternalErrorCallback) {
-    wgpuDeviceSetUncapturedErrorCallback(cDevice, ToMockDeviceErrorCallback, this);
+    device.SetUncapturedErrorCallback(ToMockDeviceErrorCallback, this);
 
     // Setting the error callback should stay on the client side and do nothing
     FlushClient();
@@ -163,7 +163,7 @@
 
 // Test the return wire for device user warning callbacks
 TEST_F(WireErrorCallbackTests, DeviceLoggingCallback) {
-    wgpuDeviceSetLoggingCallback(cDevice, ToMockDeviceLoggingCallback, this);
+    device.SetLoggingCallback(ToMockDeviceLoggingCallback, this);
 
     // Setting the injected warning callback should stay on the client side and do nothing
     FlushClient();
@@ -201,21 +201,23 @@
   protected:
     // Overridden version of wgpuDevicePopErrorScope that defers to the API call based on the test
     // callback mode.
-    void DevicePopErrorScope(WGPUDevice d, void* userdata = nullptr) {
+    void DevicePopErrorScope(const wgpu::Device& d, void* userdata = nullptr) {
         if (IsAsync()) {
-            wgpuDevicePopErrorScope(d, mMockOldCb.Callback(), mMockOldCb.MakeUserdata(userdata));
+            d.PopErrorScope(mMockOldCb.Callback(), mMockOldCb.MakeUserdata(userdata));
         } else {
-            WGPUPopErrorScopeCallbackInfo callbackInfo = {};
-            callbackInfo.mode = ToWGPUCallbackMode(GetParam().mCallbackMode);
+            wgpu::PopErrorScopeCallbackInfo callbackInfo = {};
+            callbackInfo.mode =
+                static_cast<wgpu::CallbackMode>(ToWGPUCallbackMode(GetParam().mCallbackMode));
             callbackInfo.callback = mMockCb.Callback();
             callbackInfo.userdata = mMockCb.MakeUserdata(userdata);
-            this->mFutureIDs.push_back(wgpuDevicePopErrorScopeF(d, callbackInfo).id);
+            this->mFutureIDs.push_back(d.PopErrorScope(callbackInfo).id);
         }
     }
 
-    void PushErrorScope(WGPUErrorFilter filter) {
-        EXPECT_CALL(api, DevicePushErrorScope(apiDevice, filter)).Times(1);
-        wgpuDevicePushErrorScope(cDevice, filter);
+    void PushErrorScope(wgpu::ErrorFilter filter) {
+        EXPECT_CALL(api, DevicePushErrorScope(apiDevice, static_cast<WGPUErrorFilter>(filter)))
+            .Times(1);
+        device.PushErrorScope(filter);
         FlushClient();
     }
 
@@ -239,15 +241,15 @@
 
 // Test the return wire for validation error scopes.
 TEST_P(WirePopErrorScopeCallbackTests, TypeAndFilters) {
-    static constexpr std::array<std::pair<WGPUErrorType, WGPUErrorFilter>, 3> kErrorTypeAndFilters =
-        {{{WGPUErrorType_Validation, WGPUErrorFilter_Validation},
-          {WGPUErrorType_OutOfMemory, WGPUErrorFilter_OutOfMemory},
-          {WGPUErrorType_Internal, WGPUErrorFilter_Internal}}};
+    static constexpr std::array<std::pair<WGPUErrorType, wgpu::ErrorFilter>, 3>
+        kErrorTypeAndFilters = {{{WGPUErrorType_Validation, wgpu::ErrorFilter::Validation},
+                                 {WGPUErrorType_OutOfMemory, wgpu::ErrorFilter::OutOfMemory},
+                                 {WGPUErrorType_Internal, wgpu::ErrorFilter::Internal}}};
 
     for (const auto& [type, filter] : kErrorTypeAndFilters) {
         PushErrorScope(filter);
 
-        DevicePopErrorScope(cDevice, this);
+        DevicePopErrorScope(device, this);
         EXPECT_CALL(api, OnDevicePopErrorScope2(apiDevice, _)).WillOnce([&] {
             api.CallDevicePopErrorScope2Callback(apiDevice, WGPUPopErrorScopeStatus_Success, type,
                                                  "Some error message");
@@ -274,9 +276,9 @@
 // Wire disconnect before server response calls the callback with Unknown error type.
 // TODO(crbug.com/dawn/2021) When using new callback signature, check for InstanceDropped status.
 TEST_P(WirePopErrorScopeCallbackTests, DisconnectBeforeServerReply) {
-    PushErrorScope(WGPUErrorFilter_Validation);
+    PushErrorScope(wgpu::ErrorFilter::Validation);
 
-    DevicePopErrorScope(cDevice, this);
+    DevicePopErrorScope(device, this);
     EXPECT_CALL(api, OnDevicePopErrorScope2(apiDevice, _)).Times(1);
 
     FlushClient();
@@ -302,9 +304,9 @@
     // reponse, the callback would also be fired.
     DAWN_SKIP_TEST_IF(IsSpontaneous());
 
-    PushErrorScope(WGPUErrorFilter_Validation);
+    PushErrorScope(wgpu::ErrorFilter::Validation);
 
-    DevicePopErrorScope(cDevice, this);
+    DevicePopErrorScope(device, this);
     EXPECT_CALL(api, OnDevicePopErrorScope2(apiDevice, _)).WillOnce(InvokeWithoutArgs([&] {
         api.CallDevicePopErrorScope2Callback(apiDevice, WGPUPopErrorScopeStatus_Success,
                                              WGPUErrorType_Validation, "Some error message");
diff --git a/src/dawn/tests/unittests/wire/WireExtensionTests.cpp b/src/dawn/tests/unittests/wire/WireExtensionTests.cpp
index 923b854..02a6c74 100644
--- a/src/dawn/tests/unittests/wire/WireExtensionTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireExtensionTests.cpp
@@ -44,28 +44,26 @@
 
 // Serialize/Deserializes a chained struct correctly.
 TEST_F(WireExtensionTests, ChainedStruct) {
-    WGPUShaderModuleDescriptor shaderModuleDesc = {};
+    wgpu::ShaderModuleDescriptor shaderModuleDesc = {};
     WGPUShaderModule apiShaderModule = api.GetNewShaderModule();
-    WGPUShaderModule shaderModule = wgpuDeviceCreateShaderModule(cDevice, &shaderModuleDesc);
+    wgpu::ShaderModule shaderModule = device.CreateShaderModule(&shaderModuleDesc);
     EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiShaderModule));
     FlushClient();
 
-    WGPUPrimitiveDepthClipControl clientExt = {};
-    clientExt.chain.sType = WGPUSType_PrimitiveDepthClipControl;
-    clientExt.chain.next = nullptr;
+    wgpu::PrimitiveDepthClipControl clientExt;
     clientExt.unclippedDepth = true;
 
-    WGPURenderPipelineDescriptor renderPipelineDesc = {};
+    wgpu::RenderPipelineDescriptor renderPipelineDesc;
     renderPipelineDesc.vertex.module = shaderModule;
-    renderPipelineDesc.primitive.nextInChain = &clientExt.chain;
+    renderPipelineDesc.primitive.nextInChain = &clientExt;
 
-    wgpuDeviceCreateRenderPipeline(cDevice, &renderPipelineDesc);
+    wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&renderPipelineDesc);
     EXPECT_CALL(api, DeviceCreateRenderPipeline(apiDevice, NotNull()))
         .WillOnce(Invoke(
             [&](Unused, const WGPURenderPipelineDescriptor* serverDesc) -> WGPURenderPipeline {
                 const auto* ext = reinterpret_cast<const WGPUPrimitiveDepthClipControl*>(
                     serverDesc->primitive.nextInChain);
-                EXPECT_EQ(ext->chain.sType, clientExt.chain.sType);
+                EXPECT_EQ(ext->chain.sType, WGPUSType_PrimitiveDepthClipControl);
                 EXPECT_EQ(ext->unclippedDepth, true);
                 EXPECT_EQ(ext->chain.next, nullptr);
 
@@ -76,38 +74,35 @@
 
 // Serialize/Deserializes multiple chained structs correctly.
 TEST_F(WireExtensionTests, MutlipleChainedStructs) {
-    WGPUShaderModuleDescriptor shaderModuleDesc = {};
+    wgpu::ShaderModuleDescriptor shaderModuleDesc = {};
     WGPUShaderModule apiShaderModule = api.GetNewShaderModule();
-    WGPUShaderModule shaderModule = wgpuDeviceCreateShaderModule(cDevice, &shaderModuleDesc);
+    wgpu::ShaderModule shaderModule = device.CreateShaderModule(&shaderModuleDesc);
     EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiShaderModule));
     FlushClient();
 
-    WGPUPrimitiveDepthClipControl clientExt2 = {};
-    clientExt2.chain.sType = WGPUSType_PrimitiveDepthClipControl;
-    clientExt2.chain.next = nullptr;
+    wgpu::PrimitiveDepthClipControl clientExt2;
     clientExt2.unclippedDepth = false;
 
-    WGPUPrimitiveDepthClipControl clientExt1 = {};
-    clientExt1.chain.sType = WGPUSType_PrimitiveDepthClipControl;
-    clientExt1.chain.next = &clientExt2.chain;
+    wgpu::PrimitiveDepthClipControl clientExt1;
+    clientExt1.nextInChain = &clientExt2;
     clientExt1.unclippedDepth = true;
 
-    WGPURenderPipelineDescriptor renderPipelineDesc = {};
+    wgpu::RenderPipelineDescriptor renderPipelineDesc;
     renderPipelineDesc.vertex.module = shaderModule;
-    renderPipelineDesc.primitive.nextInChain = &clientExt1.chain;
+    renderPipelineDesc.primitive.nextInChain = &clientExt1;
 
-    wgpuDeviceCreateRenderPipeline(cDevice, &renderPipelineDesc);
+    wgpu::RenderPipeline pipeline1 = device.CreateRenderPipeline(&renderPipelineDesc);
     EXPECT_CALL(api, DeviceCreateRenderPipeline(apiDevice, NotNull()))
         .WillOnce(Invoke(
             [&](Unused, const WGPURenderPipelineDescriptor* serverDesc) -> WGPURenderPipeline {
                 const auto* ext1 = reinterpret_cast<const WGPUPrimitiveDepthClipControl*>(
                     serverDesc->primitive.nextInChain);
-                EXPECT_EQ(ext1->chain.sType, clientExt1.chain.sType);
+                EXPECT_EQ(ext1->chain.sType, WGPUSType_PrimitiveDepthClipControl);
                 EXPECT_EQ(ext1->unclippedDepth, true);
 
                 const auto* ext2 =
                     reinterpret_cast<const WGPUPrimitiveDepthClipControl*>(ext1->chain.next);
-                EXPECT_EQ(ext2->chain.sType, clientExt2.chain.sType);
+                EXPECT_EQ(ext2->chain.sType, WGPUSType_PrimitiveDepthClipControl);
                 EXPECT_EQ(ext2->unclippedDepth, false);
                 EXPECT_EQ(ext2->chain.next, nullptr);
 
@@ -116,22 +111,22 @@
     FlushClient();
 
     // Swap the order of the chained structs.
-    renderPipelineDesc.primitive.nextInChain = &clientExt2.chain;
-    clientExt2.chain.next = &clientExt1.chain;
-    clientExt1.chain.next = nullptr;
+    renderPipelineDesc.primitive.nextInChain = &clientExt2;
+    clientExt2.nextInChain = &clientExt1;
+    clientExt1.nextInChain = nullptr;
 
-    wgpuDeviceCreateRenderPipeline(cDevice, &renderPipelineDesc);
+    wgpu::RenderPipeline pipeline2 = device.CreateRenderPipeline(&renderPipelineDesc);
     EXPECT_CALL(api, DeviceCreateRenderPipeline(apiDevice, NotNull()))
         .WillOnce(Invoke(
             [&](Unused, const WGPURenderPipelineDescriptor* serverDesc) -> WGPURenderPipeline {
                 const auto* ext2 = reinterpret_cast<const WGPUPrimitiveDepthClipControl*>(
                     serverDesc->primitive.nextInChain);
-                EXPECT_EQ(ext2->chain.sType, clientExt2.chain.sType);
+                EXPECT_EQ(ext2->chain.sType, WGPUSType_PrimitiveDepthClipControl);
                 EXPECT_EQ(ext2->unclippedDepth, false);
 
                 const auto* ext1 =
                     reinterpret_cast<const WGPUPrimitiveDepthClipControl*>(ext2->chain.next);
-                EXPECT_EQ(ext1->chain.sType, clientExt1.chain.sType);
+                EXPECT_EQ(ext1->chain.sType, WGPUSType_PrimitiveDepthClipControl);
                 EXPECT_EQ(ext1->unclippedDepth, true);
                 EXPECT_EQ(ext1->chain.next, nullptr);
 
@@ -142,21 +137,20 @@
 
 // Test that a chained struct with Invalid sType passes through as Invalid.
 TEST_F(WireExtensionTests, InvalidSType) {
-    WGPUShaderModuleDescriptor shaderModuleDesc = {};
+    wgpu::ShaderModuleDescriptor shaderModuleDesc = {};
     WGPUShaderModule apiShaderModule = api.GetNewShaderModule();
-    WGPUShaderModule shaderModule = wgpuDeviceCreateShaderModule(cDevice, &shaderModuleDesc);
+    wgpu::ShaderModule shaderModule = device.CreateShaderModule(&shaderModuleDesc);
     EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiShaderModule));
     FlushClient();
 
-    WGPUPrimitiveDepthClipControl clientExt = {};
-    clientExt.chain.sType = WGPUSType(0);
-    clientExt.chain.next = nullptr;
+    wgpu::PrimitiveDepthClipControl clientExt = {};
+    clientExt.sType = wgpu::SType(0);
 
-    WGPURenderPipelineDescriptor renderPipelineDesc = {};
+    wgpu::RenderPipelineDescriptor renderPipelineDesc;
     renderPipelineDesc.vertex.module = shaderModule;
-    renderPipelineDesc.primitive.nextInChain = &clientExt.chain;
+    renderPipelineDesc.primitive.nextInChain = &clientExt;
 
-    wgpuDeviceCreateRenderPipeline(cDevice, &renderPipelineDesc);
+    wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&renderPipelineDesc);
     EXPECT_CALL(api, DeviceCreateRenderPipeline(apiDevice, NotNull()))
         .WillOnce(Invoke(
             [&](Unused, const WGPURenderPipelineDescriptor* serverDesc) -> WGPURenderPipeline {
@@ -169,21 +163,20 @@
 
 // Test that a chained struct with unknown sType passes through as Invalid.
 TEST_F(WireExtensionTests, UnknownSType) {
-    WGPUShaderModuleDescriptor shaderModuleDesc = {};
+    wgpu::ShaderModuleDescriptor shaderModuleDesc = {};
     WGPUShaderModule apiShaderModule = api.GetNewShaderModule();
-    WGPUShaderModule shaderModule = wgpuDeviceCreateShaderModule(cDevice, &shaderModuleDesc);
+    wgpu::ShaderModule shaderModule = device.CreateShaderModule(&shaderModuleDesc);
     EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiShaderModule));
     FlushClient();
 
-    WGPUPrimitiveDepthClipControl clientExt = {};
-    clientExt.chain.sType = static_cast<WGPUSType>(-1);
-    clientExt.chain.next = nullptr;
+    wgpu::PrimitiveDepthClipControl clientExt = {};
+    clientExt.sType = static_cast<wgpu::SType>(-1);
 
-    WGPURenderPipelineDescriptor renderPipelineDesc = {};
+    wgpu::RenderPipelineDescriptor renderPipelineDesc;
     renderPipelineDesc.vertex.module = shaderModule;
-    renderPipelineDesc.primitive.nextInChain = &clientExt.chain;
+    renderPipelineDesc.primitive.nextInChain = &clientExt;
 
-    wgpuDeviceCreateRenderPipeline(cDevice, &renderPipelineDesc);
+    wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&renderPipelineDesc);
     EXPECT_CALL(api, DeviceCreateRenderPipeline(apiDevice, NotNull()))
         .WillOnce(Invoke(
             [&](Unused, const WGPURenderPipelineDescriptor* serverDesc) -> WGPURenderPipeline {
diff --git a/src/dawn/tests/unittests/wire/WireInjectBufferTests.cpp b/src/dawn/tests/unittests/wire/WireInjectBufferTests.cpp
index 8c0bac6..0b719b6 100644
--- a/src/dawn/tests/unittests/wire/WireInjectBufferTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireInjectBufferTests.cpp
@@ -25,8 +25,9 @@
 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include "dawn/tests/unittests/wire/WireTest.h"
+#include <utility>
 
+#include "dawn/tests/unittests/wire/WireTest.h"
 #include "dawn/wire/WireClient.h"
 #include "dawn/wire/WireServer.h"
 
@@ -41,95 +42,108 @@
     WireInjectBufferTests() {}
     ~WireInjectBufferTests() override = default;
 
+    std::pair<ReservedBuffer, wgpu::Buffer> ReserveBuffer(
+        const wgpu::BufferDescriptor* desc = &kPlaceholderDesc) {
+        auto reservation = GetWireClient()->ReserveBuffer(
+            device.Get(), reinterpret_cast<const WGPUBufferDescriptor*>(desc));
+        return {reservation, wgpu::Buffer::Acquire(reservation.buffer)};
+    }
+
     // A placeholder buffer format for ReserveBuffer. The data in it doesn't matter as long as
     // we don't call buffer reflection methods.
-    WGPUBufferDescriptor placeholderDesc = {};
+    static constexpr wgpu::BufferDescriptor kPlaceholderDesc = {};
 };
 
 // Test that reserving and injecting a buffer makes calls on the client object forward to the
 // server object correctly.
 TEST_F(WireInjectBufferTests, CallAfterReserveInject) {
-    auto reserved = GetWireClient()->ReserveBuffer(cDevice, &placeholderDesc);
+    auto [reservation, buffer] = ReserveBuffer();
 
     WGPUBuffer apiBuffer = api.GetNewBuffer();
     EXPECT_CALL(api, BufferAddRef(apiBuffer));
-    ASSERT_TRUE(GetWireServer()->InjectBuffer(apiBuffer, reserved.handle, reserved.deviceHandle));
+    ASSERT_TRUE(
+        GetWireServer()->InjectBuffer(apiBuffer, reservation.handle, reservation.deviceHandle));
 
-    wgpuBufferDestroy(reserved.buffer);
+    buffer.Destroy();
     EXPECT_CALL(api, BufferDestroy(apiBuffer));
     FlushClient();
 }
 
 // Test that reserve correctly returns different IDs each time.
 TEST_F(WireInjectBufferTests, ReserveDifferentIDs) {
-    auto reserved1 = GetWireClient()->ReserveBuffer(cDevice, &placeholderDesc);
-    auto reserved2 = GetWireClient()->ReserveBuffer(cDevice, &placeholderDesc);
+    auto [reservation1, buffer1] = ReserveBuffer();
+    auto [reservation2, buffer2] = ReserveBuffer();
 
-    ASSERT_NE(reserved1.handle.id, reserved2.handle.id);
-    ASSERT_NE(reserved1.buffer, reserved2.buffer);
+    ASSERT_NE(reservation1.handle.id, reservation2.handle.id);
+    ASSERT_NE(buffer1.Get(), buffer2.Get());
 }
 
 // Test that injecting the same id without a destroy first fails.
 TEST_F(WireInjectBufferTests, InjectExistingID) {
-    auto reserved = GetWireClient()->ReserveBuffer(cDevice, &placeholderDesc);
+    auto [reservation, buffer] = ReserveBuffer();
 
     WGPUBuffer apiBuffer = api.GetNewBuffer();
     EXPECT_CALL(api, BufferAddRef(apiBuffer));
-    ASSERT_TRUE(GetWireServer()->InjectBuffer(apiBuffer, reserved.handle, reserved.deviceHandle));
+    ASSERT_TRUE(
+        GetWireServer()->InjectBuffer(apiBuffer, reservation.handle, reservation.deviceHandle));
 
     // ID already in use, call fails.
-    ASSERT_FALSE(GetWireServer()->InjectBuffer(apiBuffer, reserved.handle, reserved.deviceHandle));
+    ASSERT_FALSE(
+        GetWireServer()->InjectBuffer(apiBuffer, reservation.handle, reservation.deviceHandle));
 }
 
 // Test that injecting the same id without a destroy first fails.
 TEST_F(WireInjectBufferTests, ReuseIDAndGeneration) {
     // Do this loop multiple times since the first time, we can't test `generation - 1` since
     // generation == 0.
-    ReservedBuffer reserved;
+    ReservedBuffer reservation;
+    wgpu::Buffer buffer;
     WGPUBuffer apiBuffer = nullptr;
     for (int i = 0; i < 2; ++i) {
-        reserved = GetWireClient()->ReserveBuffer(cDevice, &placeholderDesc);
+        std::tie(reservation, buffer) = ReserveBuffer();
 
         apiBuffer = api.GetNewBuffer();
         EXPECT_CALL(api, BufferAddRef(apiBuffer));
         ASSERT_TRUE(
-            GetWireServer()->InjectBuffer(apiBuffer, reserved.handle, reserved.deviceHandle));
+            GetWireServer()->InjectBuffer(apiBuffer, reservation.handle, reservation.deviceHandle));
 
         // Release the buffer. It should be possible to reuse the ID now, but not the generation
-        wgpuBufferRelease(reserved.buffer);
+        buffer = nullptr;
         EXPECT_CALL(api, BufferRelease(apiBuffer));
         FlushClient();
 
         // Invalid to inject with the same ID and generation.
         ASSERT_FALSE(
-            GetWireServer()->InjectBuffer(apiBuffer, reserved.handle, reserved.deviceHandle));
+            GetWireServer()->InjectBuffer(apiBuffer, reservation.handle, reservation.deviceHandle));
         if (i > 0) {
-            EXPECT_GE(reserved.handle.generation, 1u);
+            EXPECT_GE(reservation.handle.generation, 1u);
 
             // Invalid to inject with the same ID and lesser generation.
-            reserved.handle.generation -= 1;
-            ASSERT_FALSE(
-                GetWireServer()->InjectBuffer(apiBuffer, reserved.handle, reserved.deviceHandle));
+            reservation.handle.generation -= 1;
+            ASSERT_FALSE(GetWireServer()->InjectBuffer(apiBuffer, reservation.handle,
+                                                       reservation.deviceHandle));
         }
     }
 
     // Valid to inject with the same ID and greater generation.
     EXPECT_CALL(api, BufferAddRef(apiBuffer));
-    reserved.handle.generation += 2;
-    ASSERT_TRUE(GetWireServer()->InjectBuffer(apiBuffer, reserved.handle, reserved.deviceHandle));
+    reservation.handle.generation += 2;
+    ASSERT_TRUE(
+        GetWireServer()->InjectBuffer(apiBuffer, reservation.handle, reservation.deviceHandle));
 }
 
 // Test that the server only borrows the buffer and does a single reference-release
 TEST_F(WireInjectBufferTests, InjectedBufferLifetime) {
-    auto reserved = GetWireClient()->ReserveBuffer(cDevice, &placeholderDesc);
+    auto [reservation, buffer] = ReserveBuffer();
 
     // Injecting the buffer adds a reference
     WGPUBuffer apiBuffer = api.GetNewBuffer();
     EXPECT_CALL(api, BufferAddRef(apiBuffer));
-    ASSERT_TRUE(GetWireServer()->InjectBuffer(apiBuffer, reserved.handle, reserved.deviceHandle));
+    ASSERT_TRUE(
+        GetWireServer()->InjectBuffer(apiBuffer, reservation.handle, reservation.deviceHandle));
 
     // Releasing the buffer removes a single reference.
-    wgpuBufferRelease(reserved.buffer);
+    buffer = nullptr;
     EXPECT_CALL(api, BufferRelease(apiBuffer));
     FlushClient();
 
@@ -143,21 +157,21 @@
 TEST_F(WireInjectBufferTests, ReclaimBufferReservation) {
     // Test that doing a reservation and full release is an error.
     {
-        auto reserved = GetWireClient()->ReserveBuffer(cDevice, &placeholderDesc);
-        wgpuBufferRelease(reserved.buffer);
+        auto [reservation, buffer] = ReserveBuffer();
+        buffer = nullptr;
         FlushClient(false);
     }
 
     // Test that doing a reservation and then reclaiming it recycles the ID.
     {
-        auto reserved1 = GetWireClient()->ReserveBuffer(cDevice, &placeholderDesc);
-        GetWireClient()->ReclaimBufferReservation(reserved1);
+        auto [reservation1, buffer1] = ReserveBuffer();
+        GetWireClient()->ReclaimBufferReservation(reservation1);
 
-        auto reserved2 = GetWireClient()->ReserveBuffer(cDevice, &placeholderDesc);
+        auto [reservation2, buffer2] = ReserveBuffer();
 
         // The ID is the same, but the generation is still different.
-        ASSERT_EQ(reserved1.handle.id, reserved2.handle.id);
-        ASSERT_NE(reserved1.handle.generation, reserved2.handle.generation);
+        ASSERT_EQ(reservation1.handle.id, reservation2.handle.id);
+        ASSERT_NE(reservation1.handle.generation, reservation2.handle.generation);
 
         // No errors should occur.
         FlushClient();
@@ -166,15 +180,13 @@
 
 // Test the reflection of buffer creation parameters for reserved buffer.
 TEST_F(WireInjectBufferTests, ReservedBufferReflection) {
-    WGPUBufferDescriptor desc = {};
+    wgpu::BufferDescriptor desc;
     desc.size = 10;
-    desc.usage = WGPUBufferUsage_Storage;
+    desc.usage = wgpu::BufferUsage::Storage;
 
-    auto reserved = GetWireClient()->ReserveBuffer(cDevice, &desc);
-    WGPUBuffer buffer = reserved.buffer;
-
-    ASSERT_EQ(desc.size, wgpuBufferGetSize(buffer));
-    ASSERT_EQ(desc.usage, wgpuBufferGetUsage(buffer));
+    auto [reservation, buffer] = ReserveBuffer(&desc);
+    ASSERT_EQ(desc.size, buffer.GetSize());
+    ASSERT_EQ(desc.usage, buffer.GetUsage());
 }
 
 }  // anonymous namespace
diff --git a/src/dawn/tests/unittests/wire/WireInjectSwapChainTests.cpp b/src/dawn/tests/unittests/wire/WireInjectSwapChainTests.cpp
index 39c3287..e64b4c6 100644
--- a/src/dawn/tests/unittests/wire/WireInjectSwapChainTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireInjectSwapChainTests.cpp
@@ -25,8 +25,9 @@
 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include "dawn/tests/unittests/wire/WireTest.h"
+#include <utility>
 
+#include "dawn/tests/unittests/wire/WireTest.h"
 #include "dawn/wire/WireClient.h"
 #include "dawn/wire/WireServer.h"
 
@@ -39,68 +40,78 @@
 class WireInjectSwapChainTests : public WireTest {
   public:
     WireInjectSwapChainTests() {
-        swapChainDesc = {};
-        swapChainDesc.usage = WGPUTextureUsage_RenderAttachment;
-        swapChainDesc.format = WGPUTextureFormat_RGBA8Unorm;
+        swapChainDesc.usage = wgpu::TextureUsage::RenderAttachment;
+        swapChainDesc.format = wgpu::TextureFormat::RGBA8Unorm;
         swapChainDesc.width = 17;
         swapChainDesc.height = 42;
-        swapChainDesc.presentMode = WGPUPresentMode_Mailbox;
+        swapChainDesc.presentMode = wgpu::PresentMode::Mailbox;
     }
     ~WireInjectSwapChainTests() override = default;
 
-    WGPUSwapChainDescriptor swapChainDesc;
+    std::pair<ReservedSwapChain, wgpu::SwapChain> ReserveSwapChain(
+        const wgpu::SwapChainDescriptor* desc = nullptr) {
+        if (desc == nullptr) {
+            desc = &swapChainDesc;
+        }
+
+        auto reservation = GetWireClient()->ReserveSwapChain(
+            device.Get(), reinterpret_cast<const WGPUSwapChainDescriptor*>(desc));
+        return {reservation, wgpu::SwapChain::Acquire(reservation.swapchain)};
+    }
+
+    wgpu::SwapChainDescriptor swapChainDesc;
 };
 
 // Test that reserving and injecting a swapchain makes calls on the client object forward to the
 // server object correctly.
 TEST_F(WireInjectSwapChainTests, CallAfterReserveInject) {
-    auto reserved = GetWireClient()->ReserveSwapChain(cDevice, &swapChainDesc);
+    auto [reservation, swapchain] = ReserveSwapChain();
 
     WGPUSwapChain apiSwapchain = api.GetNewSwapChain();
     EXPECT_CALL(api, SwapChainAddRef(apiSwapchain));
-    ASSERT_TRUE(
-        GetWireServer()->InjectSwapChain(apiSwapchain, reserved.handle, reserved.deviceHandle));
+    ASSERT_TRUE(GetWireServer()->InjectSwapChain(apiSwapchain, reservation.handle,
+                                                 reservation.deviceHandle));
 
-    wgpuSwapChainPresent(reserved.swapchain);
+    swapchain.Present();
     EXPECT_CALL(api, SwapChainPresent(apiSwapchain));
     FlushClient();
 }
 
 // Test that reserve correctly returns different IDs each time.
 TEST_F(WireInjectSwapChainTests, ReserveDifferentIDs) {
-    auto reserved1 = GetWireClient()->ReserveSwapChain(cDevice, &swapChainDesc);
-    auto reserved2 = GetWireClient()->ReserveSwapChain(cDevice, &swapChainDesc);
+    auto [reservation1, swapchain1] = ReserveSwapChain();
+    auto [reservation2, swapchain2] = ReserveSwapChain();
 
-    ASSERT_NE(reserved1.handle.id, reserved2.handle.id);
-    ASSERT_NE(reserved1.swapchain, reserved2.swapchain);
+    ASSERT_NE(reservation1.handle.id, reservation2.handle.id);
+    ASSERT_NE(swapchain1.Get(), swapchain2.Get());
 }
 
 // Test that injecting the same id without a destroy first fails.
 TEST_F(WireInjectSwapChainTests, InjectExistingID) {
-    auto reserved = GetWireClient()->ReserveSwapChain(cDevice, &swapChainDesc);
+    auto [reservation, swapchain] = ReserveSwapChain();
 
     WGPUSwapChain apiSwapchain = api.GetNewSwapChain();
     EXPECT_CALL(api, SwapChainAddRef(apiSwapchain));
-    ASSERT_TRUE(
-        GetWireServer()->InjectSwapChain(apiSwapchain, reserved.handle, reserved.deviceHandle));
+    ASSERT_TRUE(GetWireServer()->InjectSwapChain(apiSwapchain, reservation.handle,
+                                                 reservation.deviceHandle));
 
     // ID already in use, call fails.
-    ASSERT_FALSE(
-        GetWireServer()->InjectSwapChain(apiSwapchain, reserved.handle, reserved.deviceHandle));
+    ASSERT_FALSE(GetWireServer()->InjectSwapChain(apiSwapchain, reservation.handle,
+                                                  reservation.deviceHandle));
 }
 
 // Test that the server only borrows the swapchain and does a single addref-release
 TEST_F(WireInjectSwapChainTests, InjectedSwapChainLifetime) {
-    auto reserved = GetWireClient()->ReserveSwapChain(cDevice, &swapChainDesc);
+    auto [reservation, swapchain] = ReserveSwapChain();
 
     // Injecting the swapchain adds a reference
     WGPUSwapChain apiSwapchain = api.GetNewSwapChain();
     EXPECT_CALL(api, SwapChainAddRef(apiSwapchain));
-    ASSERT_TRUE(
-        GetWireServer()->InjectSwapChain(apiSwapchain, reserved.handle, reserved.deviceHandle));
+    ASSERT_TRUE(GetWireServer()->InjectSwapChain(apiSwapchain, reservation.handle,
+                                                 reservation.deviceHandle));
 
     // Releasing the swapchain removes a single reference.
-    wgpuSwapChainRelease(reserved.swapchain);
+    swapchain = nullptr;
     EXPECT_CALL(api, SwapChainRelease(apiSwapchain));
     FlushClient();
 
@@ -114,21 +125,21 @@
 TEST_F(WireInjectSwapChainTests, ReclaimSwapChainReservation) {
     // Test that doing a reservation and full release is an error.
     {
-        auto reserved = GetWireClient()->ReserveSwapChain(cDevice, &swapChainDesc);
-        wgpuSwapChainRelease(reserved.swapchain);
+        auto [reservation, swapchain] = ReserveSwapChain();
+        swapchain = nullptr;
         FlushClient(false);
     }
 
     // Test that doing a reservation and then reclaiming it recycles the ID.
     {
-        auto reserved1 = GetWireClient()->ReserveSwapChain(cDevice, &swapChainDesc);
-        GetWireClient()->ReclaimSwapChainReservation(reserved1);
+        auto [reservation1, swapchain1] = ReserveSwapChain();
+        GetWireClient()->ReclaimSwapChainReservation(reservation1);
 
-        auto reserved2 = GetWireClient()->ReserveSwapChain(cDevice, &swapChainDesc);
+        auto [reservation2, swapchain2] = ReserveSwapChain();
 
         // The ID is the same, but the generation is still different.
-        ASSERT_EQ(reserved1.handle.id, reserved2.handle.id);
-        ASSERT_NE(reserved1.handle.generation, reserved2.handle.generation);
+        ASSERT_EQ(reservation1.handle.id, reservation2.handle.id);
+        ASSERT_NE(reservation1.handle.generation, reservation2.handle.generation);
 
         // No errors should occur.
         FlushClient();
@@ -137,26 +148,26 @@
 
 // Test that the texture's reflection is correct for injected swapchains in the wire.
 TEST_F(WireInjectSwapChainTests, SwapChainTextureReflection) {
-    auto reserved = GetWireClient()->ReserveSwapChain(cDevice, &swapChainDesc);
+    auto [reservation, swapchain] = ReserveSwapChain();
 
     WGPUSwapChain apiSwapchain = api.GetNewSwapChain();
     EXPECT_CALL(api, SwapChainAddRef(apiSwapchain));
-    ASSERT_TRUE(
-        GetWireServer()->InjectSwapChain(apiSwapchain, reserved.handle, reserved.deviceHandle));
+    ASSERT_TRUE(GetWireServer()->InjectSwapChain(apiSwapchain, reservation.handle,
+                                                 reservation.deviceHandle));
 
-    WGPUTexture tex = wgpuSwapChainGetCurrentTexture(reserved.swapchain);
+    wgpu::Texture tex = swapchain.GetCurrentTexture();
     WGPUTexture apiTex = api.GetNewTexture();
     EXPECT_CALL(api, SwapChainGetCurrentTexture(apiSwapchain)).WillOnce(Return(apiTex));
     FlushClient();
 
-    EXPECT_EQ(swapChainDesc.width, wgpuTextureGetWidth(tex));
-    EXPECT_EQ(swapChainDesc.height, wgpuTextureGetHeight(tex));
-    EXPECT_EQ(swapChainDesc.usage, wgpuTextureGetUsage(tex));
-    EXPECT_EQ(swapChainDesc.format, wgpuTextureGetFormat(tex));
-    EXPECT_EQ(1u, wgpuTextureGetDepthOrArrayLayers(tex));
-    EXPECT_EQ(1u, wgpuTextureGetMipLevelCount(tex));
-    EXPECT_EQ(1u, wgpuTextureGetSampleCount(tex));
-    EXPECT_EQ(WGPUTextureDimension_2D, wgpuTextureGetDimension(tex));
+    EXPECT_EQ(swapChainDesc.width, tex.GetWidth());
+    EXPECT_EQ(swapChainDesc.height, tex.GetHeight());
+    EXPECT_EQ(swapChainDesc.usage, tex.GetUsage());
+    EXPECT_EQ(swapChainDesc.format, tex.GetFormat());
+    EXPECT_EQ(1u, tex.GetDepthOrArrayLayers());
+    EXPECT_EQ(1u, tex.GetMipLevelCount());
+    EXPECT_EQ(1u, tex.GetSampleCount());
+    EXPECT_EQ(wgpu::TextureDimension::e2D, tex.GetDimension());
 }
 
 }  // anonymous namespace
diff --git a/src/dawn/tests/unittests/wire/WireInjectTextureTests.cpp b/src/dawn/tests/unittests/wire/WireInjectTextureTests.cpp
index c642449..8009a38 100644
--- a/src/dawn/tests/unittests/wire/WireInjectTextureTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireInjectTextureTests.cpp
@@ -25,8 +25,9 @@
 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#include "dawn/tests/unittests/wire/WireTest.h"
+#include <utility>
 
+#include "dawn/tests/unittests/wire/WireTest.h"
 #include "dawn/wire/WireClient.h"
 #include "dawn/wire/WireServer.h"
 
@@ -41,21 +42,29 @@
     WireInjectTextureTests() {}
     ~WireInjectTextureTests() override = default;
 
+    std::pair<ReservedTexture, wgpu::Texture> ReserveTexture(
+        const wgpu::TextureDescriptor* desc = &kPlaceholderDesc) {
+        auto reservation = GetWireClient()->ReserveTexture(
+            device.Get(), reinterpret_cast<const WGPUTextureDescriptor*>(desc));
+        return {reservation, wgpu::Texture::Acquire(reservation.texture)};
+    }
+
     // A placeholder texture format for ReserveTexture. The data in it doesn't matter as long as
     // we don't call texture reflection methods.
-    WGPUTextureDescriptor placeholderDesc = {};
+    static constexpr wgpu::TextureDescriptor kPlaceholderDesc = {};
 };
 
 // Test that reserving and injecting a texture makes calls on the client object forward to the
 // server object correctly.
 TEST_F(WireInjectTextureTests, CallAfterReserveInject) {
-    auto reserved = GetWireClient()->ReserveTexture(cDevice, &placeholderDesc);
+    auto [reservation, texture] = ReserveTexture();
 
     WGPUTexture apiTexture = api.GetNewTexture();
     EXPECT_CALL(api, TextureAddRef(apiTexture));
-    ASSERT_TRUE(GetWireServer()->InjectTexture(apiTexture, reserved.handle, reserved.deviceHandle));
+    ASSERT_TRUE(
+        GetWireServer()->InjectTexture(apiTexture, reservation.handle, reservation.deviceHandle));
 
-    wgpuTextureCreateView(reserved.texture, nullptr);
+    wgpu::TextureView view = texture.CreateView();
     WGPUTextureView apiPlaceholderView = api.GetNewTextureView();
     EXPECT_CALL(api, TextureCreateView(apiTexture, nullptr)).WillOnce(Return(apiPlaceholderView));
     FlushClient();
@@ -63,75 +72,79 @@
 
 // Test that reserve correctly returns different IDs each time.
 TEST_F(WireInjectTextureTests, ReserveDifferentIDs) {
-    auto reserved1 = GetWireClient()->ReserveTexture(cDevice, &placeholderDesc);
-    auto reserved2 = GetWireClient()->ReserveTexture(cDevice, &placeholderDesc);
+    auto [reservation1, texture1] = ReserveTexture();
+    auto [reservation2, texture2] = ReserveTexture();
 
-    ASSERT_NE(reserved1.handle.id, reserved2.handle.id);
-    ASSERT_NE(reserved1.texture, reserved2.texture);
+    ASSERT_NE(reservation1.handle.id, reservation2.handle.id);
+    ASSERT_NE(texture1.Get(), texture2.Get());
 }
 
 // Test that injecting the same id without a destroy first fails.
 TEST_F(WireInjectTextureTests, InjectExistingID) {
-    auto reserved = GetWireClient()->ReserveTexture(cDevice, &placeholderDesc);
+    auto [reservation, texture] = ReserveTexture();
 
     WGPUTexture apiTexture = api.GetNewTexture();
     EXPECT_CALL(api, TextureAddRef(apiTexture));
-    ASSERT_TRUE(GetWireServer()->InjectTexture(apiTexture, reserved.handle, reserved.deviceHandle));
+    ASSERT_TRUE(
+        GetWireServer()->InjectTexture(apiTexture, reservation.handle, reservation.deviceHandle));
 
     // ID already in use, call fails.
     ASSERT_FALSE(
-        GetWireServer()->InjectTexture(apiTexture, reserved.handle, reserved.deviceHandle));
+        GetWireServer()->InjectTexture(apiTexture, reservation.handle, reservation.deviceHandle));
 }
 
 // Test that injecting the same id without a destroy first fails.
 TEST_F(WireInjectTextureTests, ReuseIDAndGeneration) {
     // Do this loop multiple times since the first time, we can't test `generation - 1` since
     // generation == 0.
-    ReservedTexture reserved;
+    ReservedTexture reservation;
+    wgpu::Texture texture;
     WGPUTexture apiTexture = nullptr;
     for (int i = 0; i < 2; ++i) {
-        reserved = GetWireClient()->ReserveTexture(cDevice, &placeholderDesc);
+        std::tie(reservation, texture) = ReserveTexture();
 
         apiTexture = api.GetNewTexture();
         EXPECT_CALL(api, TextureAddRef(apiTexture));
-        ASSERT_TRUE(
-            GetWireServer()->InjectTexture(apiTexture, reserved.handle, reserved.deviceHandle));
+        ASSERT_TRUE(GetWireServer()->InjectTexture(apiTexture, reservation.handle,
+                                                   reservation.deviceHandle));
 
         // Release the texture. It should be possible to reuse the ID now, but not the generation
-        wgpuTextureRelease(reserved.texture);
+        texture = nullptr;
         EXPECT_CALL(api, TextureRelease(apiTexture));
         FlushClient();
 
         // Invalid to inject with the same ID and generation.
-        ASSERT_FALSE(
-            GetWireServer()->InjectTexture(apiTexture, reserved.handle, reserved.deviceHandle));
+        ASSERT_FALSE(GetWireServer()->InjectTexture(apiTexture, reservation.handle,
+                                                    reservation.deviceHandle));
         if (i > 0) {
-            EXPECT_GE(reserved.handle.generation, 1u);
+            EXPECT_GE(reservation.handle.generation, 1u);
 
             // Invalid to inject with the same ID and lesser generation.
-            reserved.handle.generation -= 1;
-            ASSERT_FALSE(
-                GetWireServer()->InjectTexture(apiTexture, reserved.handle, reserved.deviceHandle));
+            reservation.handle.generation -= 1;
+            ASSERT_FALSE(GetWireServer()->InjectTexture(apiTexture, reservation.handle,
+                                                        reservation.deviceHandle));
         }
     }
 
     // Valid to inject with the same ID and greater generation.
     EXPECT_CALL(api, TextureAddRef(apiTexture));
-    reserved.handle.generation += 2;
-    ASSERT_TRUE(GetWireServer()->InjectTexture(apiTexture, reserved.handle, reserved.deviceHandle));
+    reservation.handle.generation += 2;
+    ASSERT_TRUE(
+        GetWireServer()->InjectTexture(apiTexture, reservation.handle, reservation.deviceHandle));
 }
 
 // Test that the server only borrows the texture and does a single addref-release
 TEST_F(WireInjectTextureTests, InjectedTextureLifetime) {
-    auto reserved = GetWireClient()->ReserveTexture(cDevice, &placeholderDesc);
+    auto [reservation, texture] = ReserveTexture();
 
     // Injecting the texture adds a reference
     WGPUTexture apiTexture = api.GetNewTexture();
     EXPECT_CALL(api, TextureAddRef(apiTexture));
-    ASSERT_TRUE(GetWireServer()->InjectTexture(apiTexture, reserved.handle, reserved.deviceHandle));
+    ASSERT_TRUE(
+        GetWireServer()->InjectTexture(apiTexture, reservation.handle, reservation.deviceHandle));
 
     // Releasing the texture removes a single reference.
-    wgpuTextureRelease(reserved.texture);
+    texture = nullptr;
     EXPECT_CALL(api, TextureRelease(apiTexture));
     FlushClient();
 
@@ -145,21 +158,21 @@
 TEST_F(WireInjectTextureTests, ReclaimTextureReservation) {
     // Test that doing a reservation and full release is an error.
     {
-        auto reserved = GetWireClient()->ReserveTexture(cDevice, &placeholderDesc);
-        wgpuTextureRelease(reserved.texture);
+        auto [reservation, texture] = ReserveTexture();
+        texture = nullptr;
         FlushClient(false);
     }
 
     // Test that doing a reservation and then reclaiming it recycles the ID.
     {
-        auto reserved1 = GetWireClient()->ReserveTexture(cDevice, &placeholderDesc);
-        GetWireClient()->ReclaimTextureReservation(reserved1);
+        auto [reservation1, texture1] = ReserveTexture();
+        GetWireClient()->ReclaimTextureReservation(reservation1);
 
-        auto reserved2 = GetWireClient()->ReserveTexture(cDevice, &placeholderDesc);
+        auto [reservation2, texture2] = ReserveTexture();
 
         // The ID is the same, but the generation is still different.
-        ASSERT_EQ(reserved1.handle.id, reserved2.handle.id);
-        ASSERT_NE(reserved1.handle.generation, reserved2.handle.generation);
+        ASSERT_EQ(reservation1.handle.id, reservation2.handle.id);
+        ASSERT_NE(reservation1.handle.generation, reservation2.handle.generation);
 
         // No errors should occur.
         FlushClient();
@@ -168,24 +181,23 @@
 
 // Test the reflection of texture creation parameters for reserved textures.
 TEST_F(WireInjectTextureTests, ReservedTextureReflection) {
-    WGPUTextureDescriptor desc = {};
+    wgpu::TextureDescriptor desc = {};
     desc.size = {10, 11, 12};
-    desc.format = WGPUTextureFormat_R32Float;
-    desc.dimension = WGPUTextureDimension_3D;
+    desc.format = wgpu::TextureFormat::R32Float;
+    desc.dimension = wgpu::TextureDimension::e3D;
     desc.mipLevelCount = 1000;
     desc.sampleCount = 3;
-    desc.usage = WGPUTextureUsage_RenderAttachment;
+    desc.usage = wgpu::TextureUsage::RenderAttachment;
 
-    auto reserved = GetWireClient()->ReserveTexture(cDevice, &desc);
-    WGPUTexture texture = reserved.texture;
+    auto [reservation, texture] = ReserveTexture(&desc);
 
-    ASSERT_EQ(desc.size.width, wgpuTextureGetWidth(texture));
-    ASSERT_EQ(desc.size.height, wgpuTextureGetHeight(texture));
-    ASSERT_EQ(desc.size.depthOrArrayLayers, wgpuTextureGetDepthOrArrayLayers(texture));
-    ASSERT_EQ(desc.format, wgpuTextureGetFormat(texture));
-    ASSERT_EQ(desc.dimension, wgpuTextureGetDimension(texture));
-    ASSERT_EQ(desc.mipLevelCount, wgpuTextureGetMipLevelCount(texture));
-    ASSERT_EQ(desc.sampleCount, wgpuTextureGetSampleCount(texture));
+    ASSERT_EQ(desc.size.width, texture.GetWidth());
+    ASSERT_EQ(desc.size.height, texture.GetHeight());
+    ASSERT_EQ(desc.size.depthOrArrayLayers, texture.GetDepthOrArrayLayers());
+    ASSERT_EQ(desc.format, texture.GetFormat());
+    ASSERT_EQ(desc.dimension, texture.GetDimension());
+    ASSERT_EQ(desc.mipLevelCount, texture.GetMipLevelCount());
+    ASSERT_EQ(desc.sampleCount, texture.GetSampleCount());
 }
 
 }  // anonymous namespace
diff --git a/src/dawn/tests/unittests/wire/WireOptionalTests.cpp b/src/dawn/tests/unittests/wire/WireOptionalTests.cpp
index 61b38b7..078e42d 100644
--- a/src/dawn/tests/unittests/wire/WireOptionalTests.cpp
+++ b/src/dawn/tests/unittests/wire/WireOptionalTests.cpp
@@ -41,28 +41,28 @@
 
 // Test passing nullptr instead of objects - object as value version
 TEST_F(WireOptionalTests, OptionalObjectValue) {
-    WGPUBindGroupLayoutDescriptor bglDesc = {};
+    wgpu::BindGroupLayoutDescriptor bglDesc = {};
     bglDesc.entryCount = 0;
-    WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(cDevice, &bglDesc);
+    wgpu::BindGroupLayout bgl = device.CreateBindGroupLayout(&bglDesc);
 
     WGPUBindGroupLayout apiBindGroupLayout = api.GetNewBindGroupLayout();
     EXPECT_CALL(api, DeviceCreateBindGroupLayout(apiDevice, _))
         .WillOnce(Return(apiBindGroupLayout));
 
     // The `sampler`, `textureView` and `buffer` members of a binding are optional.
-    WGPUBindGroupEntry entry;
+    wgpu::BindGroupEntry entry;
     entry.binding = 0;
     entry.sampler = nullptr;
     entry.textureView = nullptr;
     entry.buffer = nullptr;
     entry.nextInChain = nullptr;
 
-    WGPUBindGroupDescriptor bgDesc = {};
+    wgpu::BindGroupDescriptor bgDesc = {};
     bgDesc.layout = bgl;
     bgDesc.entryCount = 1;
     bgDesc.entries = &entry;
 
-    wgpuDeviceCreateBindGroup(cDevice, &bgDesc);
+    wgpu::BindGroup bg = device.CreateBindGroup(&bgDesc);
 
     WGPUBindGroup apiPlaceholderBindGroup = api.GetNewBindGroup();
     EXPECT_CALL(api, DeviceCreateBindGroup(
@@ -81,35 +81,35 @@
 // Test that the wire is able to send optional pointers to structures
 TEST_F(WireOptionalTests, OptionalStructPointer) {
     // Create shader module
-    WGPUShaderModuleDescriptor vertexDescriptor = {};
-    WGPUShaderModule vsModule = wgpuDeviceCreateShaderModule(cDevice, &vertexDescriptor);
+    wgpu::ShaderModuleDescriptor vertexDescriptor = {};
+    wgpu::ShaderModule vsModule = device.CreateShaderModule(&vertexDescriptor);
     WGPUShaderModule apiVsModule = api.GetNewShaderModule();
     EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiVsModule));
 
     // Create the color state descriptor
-    WGPUBlendComponent blendComponent = {};
-    blendComponent.operation = WGPUBlendOperation_Add;
-    blendComponent.srcFactor = WGPUBlendFactor_One;
-    blendComponent.dstFactor = WGPUBlendFactor_One;
-    WGPUBlendState blendState = {};
+    wgpu::BlendComponent blendComponent = {};
+    blendComponent.operation = wgpu::BlendOperation::Add;
+    blendComponent.srcFactor = wgpu::BlendFactor::One;
+    blendComponent.dstFactor = wgpu::BlendFactor::One;
+    wgpu::BlendState blendState = {};
     blendState.alpha = blendComponent;
     blendState.color = blendComponent;
-    WGPUColorTargetState colorTargetState = {};
-    colorTargetState.format = WGPUTextureFormat_RGBA8Unorm;
+    wgpu::ColorTargetState colorTargetState = {};
+    colorTargetState.format = wgpu::TextureFormat::RGBA8Unorm;
     colorTargetState.blend = &blendState;
-    colorTargetState.writeMask = WGPUColorWriteMask_All;
+    colorTargetState.writeMask = wgpu::ColorWriteMask::All;
 
     // Create the depth-stencil state
-    WGPUStencilFaceState stencilFace = {};
-    stencilFace.compare = WGPUCompareFunction_Always;
-    stencilFace.failOp = WGPUStencilOperation_Keep;
-    stencilFace.depthFailOp = WGPUStencilOperation_Keep;
-    stencilFace.passOp = WGPUStencilOperation_Keep;
+    wgpu::StencilFaceState stencilFace = {};
+    stencilFace.compare = wgpu::CompareFunction::Always;
+    stencilFace.failOp = wgpu::StencilOperation::Keep;
+    stencilFace.depthFailOp = wgpu::StencilOperation::Keep;
+    stencilFace.passOp = wgpu::StencilOperation::Keep;
 
-    WGPUDepthStencilState depthStencilState = {};
-    depthStencilState.format = WGPUTextureFormat_Depth24PlusStencil8;
+    wgpu::DepthStencilState depthStencilState = {};
+    depthStencilState.format = wgpu::TextureFormat::Depth24PlusStencil8;
     depthStencilState.depthWriteEnabled = false;
-    depthStencilState.depthCompare = WGPUCompareFunction_Always;
+    depthStencilState.depthCompare = wgpu::CompareFunction::Always;
     depthStencilState.stencilBack = stencilFace;
     depthStencilState.stencilFront = stencilFace;
     depthStencilState.stencilReadMask = 0xff;
@@ -119,21 +119,21 @@
     depthStencilState.depthBiasClamp = 0.0;
 
     // Create the pipeline layout
-    WGPUPipelineLayoutDescriptor layoutDescriptor = {};
+    wgpu::PipelineLayoutDescriptor layoutDescriptor = {};
     layoutDescriptor.bindGroupLayoutCount = 0;
     layoutDescriptor.bindGroupLayouts = nullptr;
-    WGPUPipelineLayout layout = wgpuDeviceCreatePipelineLayout(cDevice, &layoutDescriptor);
+    wgpu::PipelineLayout layout = device.CreatePipelineLayout(&layoutDescriptor);
     WGPUPipelineLayout apiLayout = api.GetNewPipelineLayout();
     EXPECT_CALL(api, DeviceCreatePipelineLayout(apiDevice, _)).WillOnce(Return(apiLayout));
 
     // Create pipeline
-    WGPURenderPipelineDescriptor pipelineDescriptor = {};
+    wgpu::RenderPipelineDescriptor pipelineDescriptor = {};
 
     pipelineDescriptor.vertex.module = vsModule;
     pipelineDescriptor.vertex.bufferCount = 0;
     pipelineDescriptor.vertex.buffers = nullptr;
 
-    WGPUFragmentState fragment = {};
+    wgpu::FragmentState fragment = {};
     fragment.module = vsModule;
     fragment.targetCount = 1;
     fragment.targets = &colorTargetState;
@@ -143,13 +143,13 @@
     pipelineDescriptor.multisample.mask = 0xFFFFFFFF;
     pipelineDescriptor.multisample.alphaToCoverageEnabled = false;
     pipelineDescriptor.layout = layout;
-    pipelineDescriptor.primitive.topology = WGPUPrimitiveTopology_TriangleList;
-    pipelineDescriptor.primitive.frontFace = WGPUFrontFace_CCW;
-    pipelineDescriptor.primitive.cullMode = WGPUCullMode_None;
+    pipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::TriangleList;
+    pipelineDescriptor.primitive.frontFace = wgpu::FrontFace::CCW;
+    pipelineDescriptor.primitive.cullMode = wgpu::CullMode::None;
 
     // First case: depthStencil is not null.
     pipelineDescriptor.depthStencil = &depthStencilState;
-    wgpuDeviceCreateRenderPipeline(cDevice, &pipelineDescriptor);
+    wgpu::RenderPipeline pipeline1 = device.CreateRenderPipeline(&pipelineDescriptor);
 
     WGPURenderPipeline apiPlaceholderPipeline = api.GetNewRenderPipeline();
     EXPECT_CALL(
@@ -180,7 +180,7 @@
 
     // Second case: depthStencil is null.
     pipelineDescriptor.depthStencil = nullptr;
-    wgpuDeviceCreateRenderPipeline(cDevice, &pipelineDescriptor);
+    wgpu::RenderPipeline pipeline2 = device.CreateRenderPipeline(&pipelineDescriptor);
     EXPECT_CALL(api,
                 DeviceCreateRenderPipeline(
                     apiDevice, MatchesLambda([](const WGPURenderPipelineDescriptor* desc) -> bool {