diff --git a/generator/templates/dawn_wire/client/ApiProcs.cpp b/generator/templates/dawn_wire/client/ApiProcs.cpp
index 0ad9a77..1b98d02 100644
--- a/generator/templates/dawn_wire/client/ApiProcs.cpp
+++ b/generator/templates/dawn_wire/client/ApiProcs.cpp
@@ -34,14 +34,14 @@
         {%- endmacro %}
 
         {% for type in by_category["object"] %}
-            DAWN_DECLARE_UNUSED bool DeviceMatches(const Device* device, const {{as_cType(type.name)}} obj) {
-                return device == reinterpret_cast<const {{as_wireType(type)}}>(obj)->device;
+            DAWN_DECLARE_UNUSED bool ClientMatches(const Client* client, const {{as_cType(type.name)}} obj) {
+                return client == reinterpret_cast<const {{as_wireType(type)}}>(obj)->client;
             }
 
-            DAWN_DECLARE_UNUSED bool DeviceMatches(const Device* device, const {{as_cType(type.name)}} *const obj, uint32_t count = 1) {
+            DAWN_DECLARE_UNUSED bool ClientMatches(const Client* client, const {{as_cType(type.name)}} *const obj, uint32_t count = 1) {
                 ASSERT(count == 0 || obj != nullptr);
                 for (uint32_t i = 0; i < count; ++i) {
-                    if (!DeviceMatches(device, obj[i])) {
+                    if (!ClientMatches(client, obj[i])) {
                         return false;
                     }
                 }
@@ -49,12 +49,12 @@
             }
         {% endfor %}
 
-        bool DeviceMatches(const Device* device, WGPUChainedStruct const* chainedStruct);
+        bool ClientMatches(const Client* client, WGPUChainedStruct const* chainedStruct);
 
         {% for type in by_category["structure"] if type.may_have_dawn_object %}
-            DAWN_DECLARE_UNUSED bool DeviceMatches(const Device* device, const {{as_cType(type.name)}}& obj) {
+            DAWN_DECLARE_UNUSED bool ClientMatches(const Client* client, const {{as_cType(type.name)}}& obj) {
                 {% if type.extensible %}
-                    if (!DeviceMatches(device, obj.nextInChain)) {
+                    if (!ClientMatches(client, obj.nextInChain)) {
                         return false;
                     }
                 {% endif %}
@@ -63,7 +63,7 @@
                         if (obj.{{as_varName(member.name)}} != nullptr)
                     {% endif %}
                     {
-                        if (!DeviceMatches(device, obj.{{as_varName(member.name)}}
+                        if (!ClientMatches(client, obj.{{as_varName(member.name)}}
                             {%- if member.annotation != "value" and member.length != "strlen" -%}
                                 , {{member_length(member, "obj.")}}
                             {%- endif -%})) {
@@ -74,9 +74,9 @@
                 return true;
             }
 
-            DAWN_DECLARE_UNUSED bool DeviceMatches(const Device* device, const {{as_cType(type.name)}} *const obj, uint32_t count = 1) {
+            DAWN_DECLARE_UNUSED bool ClientMatches(const Client* client, const {{as_cType(type.name)}} *const obj, uint32_t count = 1) {
                 for (uint32_t i = 0; i < count; ++i) {
-                    if (!DeviceMatches(device, obj[i])) {
+                    if (!ClientMatches(client, obj[i])) {
                         return false;
                     }
                 }
@@ -84,14 +84,14 @@
             }
         {% endfor %}
 
-        bool DeviceMatches(const Device* device, WGPUChainedStruct const* chainedStruct) {
+        bool ClientMatches(const Client* client, WGPUChainedStruct const* chainedStruct) {
             while (chainedStruct != nullptr) {
                 switch (chainedStruct->sType) {
                     {% for sType in types["s type"].values if sType.valid %}
                         {% set CType = as_cType(sType.name) %}
                         case {{as_cEnum(types["s type"].name, sType.name)}}: {
                             {% if types[sType.name.get()].may_have_dawn_object %}
-                                if (!DeviceMatches(device, reinterpret_cast<const {{CType}}*>(chainedStruct))) {
+                                if (!ClientMatches(client, reinterpret_cast<const {{CType}}*>(chainedStruct))) {
                                     return false;
                                 }
                             {% endif %}
@@ -103,7 +103,7 @@
                     default:
                         UNREACHABLE();
                         dawn::WarningLog()
-                            << "All objects may not be from the same device. "
+                            << "All objects may not be from the same client. "
                             << "Unknown sType " << chainedStruct->sType << " discarded.";
                         return false;
                 }
@@ -133,10 +133,10 @@
             ) {
                 {% if len(method.arguments) > 0 %}
                     {
-                        bool sameDevice = true;
+                        bool sameClient = true;
                         auto self = reinterpret_cast<{{as_wireType(type)}}>(cSelf);
-                        Device* device = self->device;
-                        DAWN_UNUSED(device);
+                        Client* client = self->client;
+                        DAWN_UNUSED(client);
 
                         do {
                             {% for arg in method.arguments if arg.type.may_have_dawn_object or arg.type.category == "object" %}
@@ -144,26 +144,26 @@
                                     if ({{as_varName(arg.name)}} != nullptr)
                                 {% endif %}
                                 {
-                                    if (!DeviceMatches(device, {{as_varName(arg.name)}}
+                                    if (!ClientMatches(client, {{as_varName(arg.name)}}
                                         {%- if arg.annotation != "value" and arg.length != "strlen" -%}
                                             , {{member_length(arg, "")}}
                                         {%- endif -%})) {
-                                        sameDevice = false;
+                                        sameClient = false;
                                         break;
                                     }
                                 }
                             {% endfor %}
                         } while (false);
 
-                        if (DAWN_UNLIKELY(!sameDevice)) {
-                            device->InjectError(WGPUErrorType_Validation,
+                        if (DAWN_UNLIKELY(!sameClient)) {
+                            reinterpret_cast<Device*>(client->GetDevice())->InjectError(WGPUErrorType_Validation,
                                                 "All objects must be from the same device.");
                             {% if method.return_type.category == "object" %}
                                 // Allocate an object without registering it on the server. This is backed by a real allocation on
                                 // the client so commands can be sent with it. But because it's not allocated on the server, it will
                                 // be a fatal error to use it.
                                 auto self = reinterpret_cast<{{as_wireType(type)}}>(cSelf);
-                                auto* allocation = self->device->GetClient()->{{method.return_type.name.CamelCase()}}Allocator().New(self->device);
+                                auto* allocation = self->client->{{method.return_type.name.CamelCase()}}Allocator().New(self->client);
                                 return reinterpret_cast<{{as_cType(method.return_type.name)}}>(allocation->object.get());
                             {% elif method.return_type.name.canonical_case() == "void" %}
                                 return;
@@ -176,7 +176,6 @@
 
                 auto self = reinterpret_cast<{{as_wireType(type)}}>(cSelf);
                 {% if Suffix not in client_handwritten_commands %}
-                    Device* device = self->device;
                     {{Suffix}}Cmd cmd;
 
                     //* Create the structure going on the wire on the stack and fill it with the value
@@ -185,7 +184,7 @@
 
                     //* For object creation, store the object ID the client will use for the result.
                     {% if method.return_type.category == "object" %}
-                        auto* allocation = self->device->GetClient()->{{method.return_type.name.CamelCase()}}Allocator().New(self->device);
+                        auto* allocation = self->client->{{method.return_type.name.CamelCase()}}Allocator().New(self->client);
                         cmd.result = ObjectHandle{allocation->object->id, allocation->generation};
                     {% endif %}
 
@@ -194,7 +193,7 @@
                     {% endfor %}
 
                     //* Allocate space to send the command and copy the value args over.
-                    device->GetClient()->SerializeCommand(cmd);
+                    self->client->SerializeCommand(cmd);
 
                     {% if method.return_type.category == "object" %}
                         return reinterpret_cast<{{as_cType(method.return_type.name)}}>(allocation->object.get());
@@ -222,8 +221,8 @@
                 cmd.objectType = ObjectType::{{type.name.CamelCase()}};
                 cmd.objectId = obj->id;
 
-                obj->device->GetClient()->SerializeCommand(cmd);
-                obj->device->GetClient()->{{type.name.CamelCase()}}Allocator().Free(obj);
+                obj->client->SerializeCommand(cmd);
+                obj->client->{{type.name.CamelCase()}}Allocator().Free(obj);
             }
 
             void Client{{as_MethodSuffix(type.name, Name("reference"))}}({{cType}} cObj) {
diff --git a/src/dawn_wire/client/Buffer.cpp b/src/dawn_wire/client/Buffer.cpp
index 23ca0ab..2244ace 100644
--- a/src/dawn_wire/client/Buffer.cpp
+++ b/src/dawn_wire/client/Buffer.cpp
@@ -20,15 +20,15 @@
 namespace dawn_wire { namespace client {
 
     // static
-    WGPUBuffer Buffer::Create(Device* device_, const WGPUBufferDescriptor* descriptor) {
-        Client* wireClient = device_->GetClient();
+    WGPUBuffer Buffer::Create(Device* device, const WGPUBufferDescriptor* descriptor) {
+        Client* wireClient = device->client;
 
         bool mappable =
             (descriptor->usage & (WGPUBufferUsage_MapRead | WGPUBufferUsage_MapWrite)) != 0 ||
             descriptor->mappedAtCreation;
         if (mappable && descriptor->size >= std::numeric_limits<size_t>::max()) {
-            device_->InjectError(WGPUErrorType_OutOfMemory, "Buffer is too large for map usage");
-            return device_->CreateErrorBuffer();
+            device->InjectError(WGPUErrorType_OutOfMemory, "Buffer is too large for map usage");
+            return device->CreateErrorBuffer();
         }
 
         std::unique_ptr<MemoryTransferService::WriteHandle> writeHandle = nullptr;
@@ -42,16 +42,16 @@
             writeHandle.reset(
                 wireClient->GetMemoryTransferService()->CreateWriteHandle(descriptor->size));
             if (writeHandle == nullptr) {
-                device_->InjectError(WGPUErrorType_OutOfMemory, "Buffer mapping allocation failed");
-                return device_->CreateErrorBuffer();
+                device->InjectError(WGPUErrorType_OutOfMemory, "Buffer mapping allocation failed");
+                return device->CreateErrorBuffer();
             }
 
             // Open the handle, it may fail by returning a nullptr in writeData.
             size_t writeDataLength = 0;
             std::tie(writeData, writeDataLength) = writeHandle->Open();
             if (writeData == nullptr) {
-                device_->InjectError(WGPUErrorType_OutOfMemory, "Buffer mapping allocation failed");
-                return device_->CreateErrorBuffer();
+                device->InjectError(WGPUErrorType_OutOfMemory, "Buffer mapping allocation failed");
+                return device->CreateErrorBuffer();
             }
             ASSERT(writeDataLength == descriptor->size);
 
@@ -60,12 +60,13 @@
         }
 
         // Create the buffer and send the creation command.
-        auto* bufferObjectAndSerial = wireClient->BufferAllocator().New(device_);
+        auto* bufferObjectAndSerial = wireClient->BufferAllocator().New(wireClient);
         Buffer* buffer = bufferObjectAndSerial->object.get();
+        buffer->mDevice = device;
         buffer->mSize = descriptor->size;
 
         DeviceCreateBufferCmd cmd;
-        cmd.device = ToAPI(device_);
+        cmd.device = ToAPI(device);
         cmd.descriptor = descriptor;
         cmd.result = ObjectHandle{buffer->id, bufferObjectAndSerial->generation};
         cmd.handleCreateInfoLength = writeHandleCreateInfoLength;
@@ -88,13 +89,14 @@
     }
 
     // static
-    WGPUBuffer Buffer::CreateError(Device* device_) {
-        auto* allocation = device_->GetClient()->BufferAllocator().New(device_);
+    WGPUBuffer Buffer::CreateError(Device* device) {
+        auto* allocation = device->client->BufferAllocator().New(device->client);
+        allocation->object->mDevice = device;
 
         DeviceCreateErrorBufferCmd cmd;
-        cmd.self = ToAPI(device_);
+        cmd.self = ToAPI(device);
         cmd.result = ObjectHandle{allocation->object->id, allocation->generation};
-        device_->GetClient()->SerializeCommand(cmd);
+        device->client->SerializeCommand(cmd);
 
         return ToAPI(allocation->object.get());
     }
@@ -124,7 +126,7 @@
                           size_t size,
                           WGPUBufferMapCallback callback,
                           void* userdata) {
-        if (device->GetClient()->IsDisconnected()) {
+        if (client->IsDisconnected()) {
             return callback(WGPUBufferMapAsyncStatus_DeviceLost, userdata);
         }
 
@@ -138,7 +140,8 @@
 
         // Step 1. Do early validation of READ ^ WRITE because the server rejects mode = 0.
         if (!(isReadMode ^ isWriteMode)) {
-            device->InjectError(WGPUErrorType_Validation, "MapAsync error (you figure out :P)");
+            mDevice->InjectError(WGPUErrorType_Validation,
+                                 "MapAsync mode must be exactly one of Read or Write");
             if (callback != nullptr) {
                 callback(WGPUBufferMapAsyncStatus_Error, userdata);
             }
@@ -158,19 +161,17 @@
 
         // Step 2a: Create the read / write handles for this request.
         if (isReadMode) {
-            request.readHandle.reset(
-                device->GetClient()->GetMemoryTransferService()->CreateReadHandle(size));
+            request.readHandle.reset(client->GetMemoryTransferService()->CreateReadHandle(size));
             if (request.readHandle == nullptr) {
-                device->InjectError(WGPUErrorType_OutOfMemory, "Failed to create buffer mapping");
+                mDevice->InjectError(WGPUErrorType_OutOfMemory, "Failed to create buffer mapping");
                 callback(WGPUBufferMapAsyncStatus_Error, userdata);
                 return;
             }
         } else {
             ASSERT(isWriteMode);
-            request.writeHandle.reset(
-                device->GetClient()->GetMemoryTransferService()->CreateWriteHandle(size));
+            request.writeHandle.reset(client->GetMemoryTransferService()->CreateWriteHandle(size));
             if (request.writeHandle == nullptr) {
-                device->InjectError(WGPUErrorType_OutOfMemory, "Failed to create buffer mapping");
+                mDevice->InjectError(WGPUErrorType_OutOfMemory, "Failed to create buffer mapping");
                 callback(WGPUBufferMapAsyncStatus_Error, userdata);
                 return;
             }
@@ -188,15 +189,15 @@
         // Step 3a. Fill the handle create info in the command.
         if (isReadMode) {
             cmd.handleCreateInfoLength = request.readHandle->SerializeCreateSize();
-            device->GetClient()->SerializeCommand(
-                cmd, cmd.handleCreateInfoLength,
-                [&](char* cmdSpace) { request.readHandle->SerializeCreate(cmdSpace); });
+            client->SerializeCommand(cmd, cmd.handleCreateInfoLength, [&](char* cmdSpace) {
+                request.readHandle->SerializeCreate(cmdSpace);
+            });
         } else {
             ASSERT(isWriteMode);
             cmd.handleCreateInfoLength = request.writeHandle->SerializeCreateSize();
-            device->GetClient()->SerializeCommand(
-                cmd, cmd.handleCreateInfoLength,
-                [&](char* cmdSpace) { request.writeHandle->SerializeCreate(cmdSpace); });
+            client->SerializeCommand(cmd, cmd.handleCreateInfoLength, [&](char* cmdSpace) {
+                request.writeHandle->SerializeCreate(cmdSpace);
+            });
         }
 
         // Step 4. Register this request so that we can retrieve it from its serial when the server
@@ -323,7 +324,7 @@
             cmd.writeFlushInfoLength = writeFlushInfoLength;
             cmd.writeFlushInfo = nullptr;
 
-            device->GetClient()->SerializeCommand(cmd, writeFlushInfoLength, [&](char* cmdSpace) {
+            client->SerializeCommand(cmd, writeFlushInfoLength, [&](char* cmdSpace) {
                 // Serialize flush metadata into the space after the command.
                 // This closes the handle for writing.
                 mWriteHandle->SerializeFlush(cmdSpace);
@@ -347,7 +348,7 @@
 
         BufferUnmapCmd cmd;
         cmd.self = ToAPI(this);
-        device->GetClient()->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
     }
 
     void Buffer::Destroy() {
@@ -365,7 +366,7 @@
 
         BufferDestroyCmd cmd;
         cmd.self = ToAPI(this);
-        device->GetClient()->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
     }
 
     bool Buffer::IsMappedForReading() const {
diff --git a/src/dawn_wire/client/Buffer.h b/src/dawn_wire/client/Buffer.h
index cacfd48..d6a275c 100644
--- a/src/dawn_wire/client/Buffer.h
+++ b/src/dawn_wire/client/Buffer.h
@@ -24,6 +24,8 @@
 
 namespace dawn_wire { namespace client {
 
+    class Device;
+
     class Buffer final : public ObjectBase {
       public:
         using ObjectBase::ObjectBase;
@@ -55,6 +57,8 @@
         bool IsMappedForWriting() const;
         bool CheckGetMappedRangeOffsetSize(size_t offset, size_t size) const;
 
+        Device* mDevice;
+
         // We want to defer all the validation to the server, which means we could have multiple
         // map request in flight at a single time and need to track them separately.
         // On well-behaved applications, only one request should exist at a single time.
diff --git a/src/dawn_wire/client/Client.cpp b/src/dawn_wire/client/Client.cpp
index 0b53bc4..d12bc57 100644
--- a/src/dawn_wire/client/Client.cpp
+++ b/src/dawn_wire/client/Client.cpp
@@ -57,10 +57,23 @@
     }
 
     void Client::DestroyAllObjects() {
-        while (!mDevices.empty()) {
-            // Note: We don't send a DestroyObject command for the device
-            // since freeing a device object is done out of band.
-            DeviceAllocator().Free(static_cast<Device*>(mDevices.head()->value()));
+        for (auto& objectList : mObjects) {
+            ObjectType objectType = static_cast<ObjectType>(&objectList - mObjects.data());
+            while (!objectList.empty()) {
+                ObjectBase* object = objectList.head()->value();
+                if (object == mDevice) {
+                    // Note: We don't send a DestroyObject command for the device
+                    // since freeing a device object is done out of band.
+                    DeviceAllocator().Free(mDevice);
+                    continue;
+                }
+
+                DestroyObjectCmd cmd;
+                cmd.objectType = objectType;
+                cmd.objectId = object->id;
+                SerializeCommand(cmd);
+                FreeObject(objectType, object);
+            }
         }
     }
 
@@ -71,9 +84,8 @@
         return reinterpret_cast<WGPUDeviceImpl*>(mDevice);
     }
 
-    ReservedTexture Client::ReserveTexture(WGPUDevice cDevice) {
-        Device* device = FromAPI(cDevice);
-        auto* allocation = TextureAllocator().New(device);
+    ReservedTexture Client::ReserveTexture(WGPUDevice device) {
+        auto* allocation = TextureAllocator().New(this);
 
         ReservedTexture result;
         result.texture = ToAPI(allocation->object.get());
@@ -87,12 +99,14 @@
         mSerializer = ChunkedCommandSerializer(NoopCommandSerializer::GetInstance());
         if (mDevice != nullptr) {
             mDevice->HandleDeviceLost("GPU connection lost");
-            mDevice->CancelCallbacksForDisconnect();
         }
-    }
-
-    void Client::TrackObject(Device* device) {
-        mDevices.Append(device);
+        for (auto& objectList : mObjects) {
+            LinkNode<ObjectBase>* object = objectList.head();
+            while (object != objectList.end()) {
+                object->value()->CancelCallbacksForDisconnect();
+                object = object->next();
+            }
+        }
     }
 
     bool Client::IsDisconnected() const {
diff --git a/src/dawn_wire/client/Client.h b/src/dawn_wire/client/Client.h
index 9a44cc3..4902df8 100644
--- a/src/dawn_wire/client/Client.h
+++ b/src/dawn_wire/client/Client.h
@@ -62,7 +62,10 @@
         void Disconnect();
         bool IsDisconnected() const;
 
-        void TrackObject(Device* device);
+        template <typename T>
+        void TrackObject(T* object) {
+            mObjects[ObjectTypeToTypeEnum<T>::value].Append(object);
+        }
 
       private:
         void DestroyAllObjects();
@@ -75,7 +78,7 @@
         MemoryTransferService* mMemoryTransferService = nullptr;
         std::unique_ptr<MemoryTransferService> mOwnedMemoryTransferService = nullptr;
 
-        LinkedList<ObjectBase> mDevices;
+        PerObjectType<LinkedList<ObjectBase>> mObjects;
         bool mDisconnected = false;
     };
 
diff --git a/src/dawn_wire/client/Device.cpp b/src/dawn_wire/client/Device.cpp
index 767e05b..af4cbfb 100644
--- a/src/dawn_wire/client/Device.cpp
+++ b/src/dawn_wire/client/Device.cpp
@@ -22,8 +22,8 @@
 
 namespace dawn_wire { namespace client {
 
-    Device::Device(Client* client, uint32_t initialRefcount, uint32_t initialId)
-        : ObjectBase(this, initialRefcount, initialId), mClient(client) {
+    Device::Device(Client* clientIn, uint32_t initialRefcount, uint32_t initialId)
+        : ObjectBase(clientIn, initialRefcount, initialId) {
 #if defined(DAWN_ENABLE_ASSERTS)
         mErrorCallback = [](WGPUErrorType, char const*, void*) {
             static bool calledOnce = false;
@@ -46,14 +46,14 @@
         };
 #endif  // DAWN_ENABLE_ASSERTS
         // Get the default queue for this device.
-        auto* allocation = mClient->QueueAllocator().New(this);
+        auto* allocation = client->QueueAllocator().New(client);
         mDefaultQueue = allocation->object.get();
 
         DeviceGetDefaultQueueCmd cmd;
         cmd.self = ToAPI(this);
         cmd.result = ObjectHandle{allocation->object->id, allocation->generation};
 
-        mClient->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
     }
 
     Device::~Device() {
@@ -77,27 +77,6 @@
                     "Device destroyed before callback", it.second.userdata);
             }
         }
-
-        DestroyAllObjects();
-    }
-
-    void Device::DestroyAllObjects() {
-        for (auto& objectList : mObjects) {
-            ObjectType objectType = static_cast<ObjectType>(&objectList - mObjects.data());
-            while (!objectList.empty()) {
-                ObjectBase* object = objectList.head()->value();
-
-                DestroyObjectCmd cmd;
-                cmd.objectType = objectType;
-                cmd.objectId = object->id;
-                mClient->SerializeCommand(cmd);
-                mClient->FreeObject(objectType, object);
-            }
-        }
-    }
-
-    Client* Device::GetClient() {
-        return mClient;
     }
 
     void Device::HandleError(WGPUErrorType errorType, const char* message) {
@@ -133,14 +112,6 @@
             it.second.callback(WGPUErrorType_DeviceLost, "Device lost", it.second.userdata);
         }
         mErrorScopes.clear();
-
-        for (auto& objectList : mObjects) {
-            LinkNode<ObjectBase>* object = objectList.head();
-            while (object != objectList.end()) {
-                object->value()->CancelCallbacksForDisconnect();
-                object = object->next();
-            }
-        }
     }
 
     void Device::SetUncapturedErrorCallback(WGPUErrorCallback errorCallback, void* errorUserdata) {
@@ -160,7 +131,7 @@
         cmd.self = ToAPI(this);
         cmd.filter = filter;
 
-        mClient->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
     }
 
     bool Device::PopErrorScope(WGPUErrorCallback callback, void* userdata) {
@@ -169,7 +140,7 @@
         }
         mErrorScopeStackSize--;
 
-        if (GetClient()->IsDisconnected()) {
+        if (client->IsDisconnected()) {
             callback(WGPUErrorType_DeviceLost, "GPU device disconnected", userdata);
             return true;
         }
@@ -183,7 +154,7 @@
         cmd.device = ToAPI(this);
         cmd.requestSerial = serial;
 
-        mClient->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
 
         return true;
     }
@@ -219,7 +190,7 @@
         cmd.self = ToAPI(this);
         cmd.type = type;
         cmd.message = message;
-        mClient->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
     }
 
     WGPUBuffer Device::CreateBuffer(const WGPUBufferDescriptor* descriptor) {
@@ -238,7 +209,7 @@
     void Device::CreateReadyComputePipeline(WGPUComputePipelineDescriptor const* descriptor,
                                             WGPUCreateReadyComputePipelineCallback callback,
                                             void* userdata) {
-        if (device->GetClient()->IsDisconnected()) {
+        if (client->IsDisconnected()) {
             return callback(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr,
                             "GPU device disconnected", userdata);
         }
@@ -251,14 +222,14 @@
         ASSERT(mCreateReadyPipelineRequests.find(serial) == mCreateReadyPipelineRequests.end());
         cmd.requestSerial = serial;
 
-        auto* allocation = GetClient()->ComputePipelineAllocator().New(this);
+        auto* allocation = client->ComputePipelineAllocator().New(client);
         CreateReadyPipelineRequest request = {};
         request.createReadyComputePipelineCallback = callback;
         request.userdata = userdata;
         request.pipelineObjectID = allocation->object->id;
 
         cmd.pipelineObjectHandle = ObjectHandle{allocation->object->id, allocation->generation};
-        GetClient()->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
 
         mCreateReadyPipelineRequests[serial] = std::move(request);
     }
@@ -275,12 +246,12 @@
         mCreateReadyPipelineRequests.erase(requestIt);
 
         auto pipelineAllocation =
-            GetClient()->ComputePipelineAllocator().GetObject(request.pipelineObjectID);
+            client->ComputePipelineAllocator().GetObject(request.pipelineObjectID);
 
         // If the return status is a failure we should give a null pipeline to the callback and
         // free the allocation both on the client side and the server side.
         if (status != WGPUCreateReadyPipelineStatus_Success) {
-            GetClient()->ComputePipelineAllocator().Free(pipelineAllocation);
+            client->ComputePipelineAllocator().Free(pipelineAllocation);
             request.createReadyComputePipelineCallback(status, nullptr, message, request.userdata);
             return true;
         }
@@ -294,7 +265,7 @@
     void Device::CreateReadyRenderPipeline(WGPURenderPipelineDescriptor const* descriptor,
                                            WGPUCreateReadyRenderPipelineCallback callback,
                                            void* userdata) {
-        if (GetClient()->IsDisconnected()) {
+        if (client->IsDisconnected()) {
             return callback(WGPUCreateReadyPipelineStatus_DeviceLost, nullptr,
                             "GPU device disconnected", userdata);
         }
@@ -306,14 +277,14 @@
         ASSERT(mCreateReadyPipelineRequests.find(serial) == mCreateReadyPipelineRequests.end());
         cmd.requestSerial = serial;
 
-        auto* allocation = GetClient()->RenderPipelineAllocator().New(this);
+        auto* allocation = client->RenderPipelineAllocator().New(client);
         CreateReadyPipelineRequest request = {};
         request.createReadyRenderPipelineCallback = callback;
         request.userdata = userdata;
         request.pipelineObjectID = allocation->object->id;
 
         cmd.pipelineObjectHandle = ObjectHandle(allocation->object->id, allocation->generation);
-        GetClient()->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
 
         mCreateReadyPipelineRequests[serial] = std::move(request);
     }
@@ -330,12 +301,12 @@
         mCreateReadyPipelineRequests.erase(requestIt);
 
         auto pipelineAllocation =
-            GetClient()->RenderPipelineAllocator().GetObject(request.pipelineObjectID);
+            client->RenderPipelineAllocator().GetObject(request.pipelineObjectID);
 
         // If the return status is a failure we should give a null pipeline to the callback and
         // free the allocation both on the client side and the server side.
         if (status != WGPUCreateReadyPipelineStatus_Success) {
-            GetClient()->RenderPipelineAllocator().Free(pipelineAllocation);
+            client->RenderPipelineAllocator().Free(pipelineAllocation);
             request.createReadyRenderPipelineCallback(status, nullptr, message, request.userdata);
             return true;
         }
diff --git a/src/dawn_wire/client/Device.h b/src/dawn_wire/client/Device.h
index a0036a4..6862bb3 100644
--- a/src/dawn_wire/client/Device.h
+++ b/src/dawn_wire/client/Device.h
@@ -34,7 +34,6 @@
         Device(Client* client, uint32_t refcount, uint32_t id);
         ~Device();
 
-        Client* GetClient();
         void SetUncapturedErrorCallback(WGPUErrorCallback errorCallback, void* errorUserdata);
         void SetDeviceLostCallback(WGPUDeviceLostCallback errorCallback, void* errorUserdata);
         void InjectError(WGPUErrorType type, const char* message);
@@ -63,16 +62,9 @@
 
         WGPUQueue GetDefaultQueue();
 
-        template <typename T>
-        void TrackObject(T* object) {
-            mObjects[ObjectTypeToTypeEnum<T>::value].Append(object);
-        }
-
         void CancelCallbacksForDisconnect() override;
 
       private:
-        void DestroyAllObjects();
-
         struct ErrorScopeData {
             WGPUErrorCallback callback = nullptr;
             void* userdata = nullptr;
@@ -90,7 +82,6 @@
         std::map<uint64_t, CreateReadyPipelineRequest> mCreateReadyPipelineRequests;
         uint64_t mCreateReadyPipelineRequestSerial = 0;
 
-        Client* mClient = nullptr;
         WGPUErrorCallback mErrorCallback = nullptr;
         WGPUDeviceLostCallback mDeviceLostCallback = nullptr;
         bool mDidRunLostCallback = false;
@@ -98,8 +89,6 @@
         void* mDeviceLostUserdata = nullptr;
 
         Queue* mDefaultQueue = nullptr;
-
-        PerObjectType<LinkedList<ObjectBase>> mObjects;
     };
 
 }}  // namespace dawn_wire::client
diff --git a/src/dawn_wire/client/Fence.cpp b/src/dawn_wire/client/Fence.cpp
index a11d4e9..9bb40b3 100644
--- a/src/dawn_wire/client/Fence.cpp
+++ b/src/dawn_wire/client/Fence.cpp
@@ -15,7 +15,6 @@
 #include "dawn_wire/client/Fence.h"
 
 #include "dawn_wire/client/Client.h"
-#include "dawn_wire/client/Device.h"
 
 namespace dawn_wire { namespace client {
 
@@ -48,7 +47,7 @@
     void Fence::OnCompletion(uint64_t value,
                              WGPUFenceOnCompletionCallback callback,
                              void* userdata) {
-        if (device->GetClient()->IsDisconnected()) {
+        if (client->IsDisconnected()) {
             return callback(WGPUFenceCompletionStatus_DeviceLost, userdata);
         }
 
@@ -62,7 +61,7 @@
 
         mOnCompletionRequests[serial] = {callback, userdata};
 
-        this->device->GetClient()->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
     }
 
     void Fence::OnUpdateCompletedValueCallback(uint64_t value) {
diff --git a/src/dawn_wire/client/ObjectAllocator.h b/src/dawn_wire/client/ObjectAllocator.h
index bb0c4e4..4572752 100644
--- a/src/dawn_wire/client/ObjectAllocator.h
+++ b/src/dawn_wire/client/ObjectAllocator.h
@@ -25,14 +25,8 @@
 
 namespace dawn_wire { namespace client {
 
-    class Client;
-    class Device;
-
     template <typename T>
     class ObjectAllocator {
-        using ObjectOwner =
-            typename std::conditional<std::is_same<T, Device>::value, Client, Device>::type;
-
       public:
         struct ObjectAndSerial {
             ObjectAndSerial(std::unique_ptr<T> object, uint32_t generation)
@@ -47,10 +41,11 @@
             mObjects.emplace_back(nullptr, 0);
         }
 
-        ObjectAndSerial* New(ObjectOwner* owner) {
+        template <typename Client>
+        ObjectAndSerial* New(Client* client) {
             uint32_t id = GetNewId();
-            auto object = std::make_unique<T>(owner, 1, id);
-            owner->TrackObject(object.get());
+            auto object = std::make_unique<T>(client, 1, id);
+            client->TrackObject(object.get());
 
             if (id >= mObjects.size()) {
                 ASSERT(id == mObjects.size());
@@ -109,7 +104,6 @@
         uint32_t mCurrentId = 1;
         std::vector<uint32_t> mFreeIds;
         std::vector<ObjectAndSerial> mObjects;
-        Device* mDevice;
     };
 }}  // namespace dawn_wire::client
 
diff --git a/src/dawn_wire/client/ObjectBase.h b/src/dawn_wire/client/ObjectBase.h
index e317611..ac257c8 100644
--- a/src/dawn_wire/client/ObjectBase.h
+++ b/src/dawn_wire/client/ObjectBase.h
@@ -22,16 +22,16 @@
 
 namespace dawn_wire { namespace client {
 
-    class Device;
+    class Client;
 
-    // All non-Device objects of the client side have:
-    //  - A pointer to the device to get where to serialize commands
+    // All objects on the client side have:
+    //  - A pointer to the Client to get where to serialize commands
     //  - The external reference count
     //  - An ID that is used to refer to this object when talking with the server side
     //  - A next/prev pointer. They are part of a linked list of objects of the same type.
     struct ObjectBase : public LinkNode<ObjectBase> {
-        ObjectBase(Device* device, uint32_t refcount, uint32_t id)
-            : device(device), refcount(refcount), id(id) {
+        ObjectBase(Client* client, uint32_t refcount, uint32_t id)
+            : client(client), refcount(refcount), id(id) {
         }
 
         ~ObjectBase() {
@@ -41,7 +41,7 @@
         virtual void CancelCallbacksForDisconnect() {
         }
 
-        Device* const device;
+        Client* const client;
         uint32_t refcount;
         const uint32_t id;
     };
diff --git a/src/dawn_wire/client/Queue.cpp b/src/dawn_wire/client/Queue.cpp
index 52de14c..37ae3fa 100644
--- a/src/dawn_wire/client/Queue.cpp
+++ b/src/dawn_wire/client/Queue.cpp
@@ -20,13 +20,13 @@
 namespace dawn_wire { namespace client {
 
     WGPUFence Queue::CreateFence(WGPUFenceDescriptor const* descriptor) {
-        auto* allocation = device->GetClient()->FenceAllocator().New(device);
+        auto* allocation = client->FenceAllocator().New(client);
 
         QueueCreateFenceCmd cmd;
         cmd.self = ToAPI(this);
         cmd.result = ObjectHandle{allocation->object->id, allocation->generation};
         cmd.descriptor = descriptor;
-        device->GetClient()->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
 
         Fence* fence = allocation->object.get();
         fence->Initialize(this, descriptor);
@@ -46,7 +46,7 @@
         cmd.data = static_cast<const uint8_t*>(data);
         cmd.size = size;
 
-        device->GetClient()->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
     }
 
     void Queue::WriteTexture(const WGPUTextureCopyView* destination,
@@ -62,7 +62,7 @@
         cmd.dataLayout = dataLayout;
         cmd.writeSize = writeSize;
 
-        device->GetClient()->SerializeCommand(cmd);
+        client->SerializeCommand(cmd);
     }
 
 }}  // namespace dawn_wire::client