dawn_wire: Move manual class members from ServerBase to Server

Bug: dawn:88
Change-Id: Ic216006aa52cace7aa7451b957e72119783e6d7a
Reviewed-on: https://dawn-review.googlesource.com/c/4100
Commit-Queue: Austin Eng <enga@chromium.org>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>

generator/templates/dawn_wire/server/ServerBase.h

@@ -22,50 +22,43 @@
 
 namespace dawn_wire { namespace server {
 
-    class Server;
-
-    struct MapUserdata {
-        Server* server;
-        ObjectHandle buffer;
-        uint32_t requestSerial;
-        uint32_t size;
-        bool isWrite;
-    };
-
-    struct FenceCompletionUserdata {
-        Server* server;
-        ObjectHandle fence;
-        uint64_t value;
-    };
-
     class ServerBase : public ObjectIdResolver {
       public:
-        ServerBase(dawnDevice device, const dawnProcTable& procs, CommandSerializer* serializer)
+        ServerBase() = default;
-            : mProcs(procs), mSerializer(serializer) {
+        virtual ~ServerBase() = default;
-        }
 
-        virtual ~ServerBase() {
+      protected:
-            //* Free all objects when the server is destroyed
+        void DestroyAllObjects(const dawnProcTable& procs) {
+          //* Free all objects when the server is destroyed
             {% for type in by_category["object"] if type.name.canonical_case() != "device" %}
                 {
                     std::vector<{{as_cType(type.name)}}> handles = mKnown{{type.name.CamelCase()}}.AcquireAllHandles();
                     for ({{as_cType(type.name)}} handle : handles) {
-                        mProcs.{{as_varName(type.name, Name("release"))}}(handle);
+                        procs.{{as_varName(type.name, Name("release"))}}(handle);
                     }
                 }
             {% endfor %}
         }
 
-      protected:
+        {% for type in by_category["object"] %}
-        dawnProcTable mProcs;
+            const KnownObjects<{{as_cType(type.name)}}>& {{type.name.CamelCase()}}Objects() const {
-        CommandSerializer* mSerializer = nullptr;
+                return mKnown{{type.name.CamelCase()}};
+            }
+            KnownObjects<{{as_cType(type.name)}}>& {{type.name.CamelCase()}}Objects() {
+                return mKnown{{type.name.CamelCase()}};
+            }
+        {% endfor %}
 
-        WireDeserializeAllocator mAllocator;
+        {% for type in by_category["object"] if type.name.CamelCase() in server_reverse_lookup_objects %}
-
+            const ObjectIdLookupTable<{{as_cType(type.name)}}>& {{type.name.CamelCase()}}ObjectIdTable() const {
-        void* GetCmdSpace(size_t size) {
+                return m{{type.name.CamelCase()}}IdTable;
-            return mSerializer->GetCmdSpace(size);
+            }
-        }
+            ObjectIdLookupTable<{{as_cType(type.name)}}>& {{type.name.CamelCase()}}ObjectIdTable() {
+                return m{{type.name.CamelCase()}}IdTable;
+            }
+        {% endfor %}
 
+      private:
         // Implementation of the ObjectIdResolver interface
         {% for type in by_category["object"] %}
             DeserializeResult GetFromId(ObjectId id, {{as_cType(type.name)}}* out) const final {

generator/templates/dawn_wire/server/ServerCallbacks.cpp

@@ -28,7 +28,7 @@ namespace dawn_wire { namespace server {
     {% for type in by_category["object"] if type.is_builder%}
         {% set Type = type.name.CamelCase() %}
         void Server::On{{Type}}Error(dawnBuilderErrorStatus status, const char* message, uint32_t id, uint32_t serial) {
-            auto* builder = mKnown{{Type}}.Get(id);
+            auto* builder = {{Type}}Objects().Get(id);
 
             if (builder == nullptr || builder->serial != serial) {
                 return;

generator/templates/dawn_wire/server/ServerHandlers.cpp

@@ -37,7 +37,7 @@ namespace dawn_wire { namespace server {
                     {% endif %}
 
                     //* Unpack 'self'
-                    auto* selfData = mKnown{{type.name.CamelCase()}}.Get(cmd.selfId);
+                    auto* selfData = {{type.name.CamelCase()}}Objects().Get(cmd.selfId);
                     ASSERT(selfData != nullptr);
 
                     //* In all cases allocate the object data as it will be refered-to by the client.
@@ -45,7 +45,7 @@ namespace dawn_wire { namespace server {
                     {% set returns = return_type.name.canonical_case() != "void" %}
                     {% if returns %}
                         {% set Type = method.return_type.name.CamelCase() %}
-                        auto* resultData = mKnown{{Type}}.Allocate(cmd.result.id);
+                        auto* resultData = {{Type}}Objects().Allocate(cmd.result.id);
                         if (resultData == nullptr) {
                             return false;
                         }
@@ -90,7 +90,7 @@ namespace dawn_wire { namespace server {
                         {% if return_type.name.CamelCase() in server_reverse_lookup_objects %}
                             //* For created objects, store a mapping from them back to their client IDs
                             if (result) {
-                                m{{return_type.name.CamelCase()}}IdTable.Store(result, cmd.result.id);
+                                {{return_type.name.CamelCase()}}ObjectIdTable().Store(result, cmd.result.id);
                             }
                         {% endif %}
 
@@ -133,19 +133,19 @@ namespace dawn_wire { namespace server {
                         //* Freeing the device has to be done out of band.
                         return false;
                     {% else %}
-                        auto* data = mKnown{{type.name.CamelCase()}}.Get(objectId);
+                        auto* data = {{type.name.CamelCase()}}Objects().Get(objectId);
                         if (data == nullptr) {
                             return false;
                         }
                         {% if type.name.CamelCase() in server_reverse_lookup_objects %}
-                            m{{type.name.CamelCase()}}IdTable.Remove(data->handle);
+                            {{type.name.CamelCase()}}ObjectIdTable().Remove(data->handle);
                         {% endif %}
 
                         if (data->handle != nullptr) {
                             mProcs.{{as_varName(type.name, Name("release"))}}(data->handle);
                         }
 
-                        mKnown{{type.name.CamelCase()}}.Free(objectId);
+                        {{type.name.CamelCase()}}Objects().Free(objectId);
                         return true;
                     {% endif %}
                 }
@@ -156,7 +156,7 @@ namespace dawn_wire { namespace server {
     }
 
     const char* Server::HandleCommands(const char* commands, size_t size) {
-        mProcs.deviceTick(mKnownDevice.Get(1)->handle);
+        mProcs.deviceTick(DeviceObjects().Get(1)->handle);
 
         while (size >= sizeof(WireCmd)) {
             WireCmd cmdId = *reinterpret_cast<const WireCmd*>(commands);

src/dawn_wire/server/Server.cpp

@@ -17,9 +17,9 @@
 namespace dawn_wire { namespace server {
 
     Server::Server(dawnDevice device, const dawnProcTable& procs, CommandSerializer* serializer)
-        : ServerBase(device, procs, serializer) {
+        : mSerializer(serializer), mProcs(procs) {
         // The client-server knowledge is bootstrapped with device 1.
-        auto* deviceData = mKnownDevice.Allocate(1);
+        auto* deviceData = DeviceObjects().Allocate(1);
         deviceData->handle = device;
         deviceData->valid = true;
 
@@ -28,6 +28,11 @@ namespace dawn_wire { namespace server {
     }
 
     Server::~Server() {
+        DestroyAllObjects(mProcs);
+    }
+
+    void* Server::GetCmdSpace(size_t size) {
+        return mSerializer->GetCmdSpace(size);
     }
 
 }}  // namespace dawn_wire::server

src/dawn_wire/server/Server.h

@@ -19,6 +19,22 @@
 
 namespace dawn_wire { namespace server {
 
+    class Server;
+
+    struct MapUserdata {
+        Server* server;
+        ObjectHandle buffer;
+        uint32_t requestSerial;
+        uint32_t size;
+        bool isWrite;
+    };
+
+    struct FenceCompletionUserdata {
+        Server* server;
+        ObjectHandle fence;
+        uint64_t value;
+    };
+
     class Server : public ServerBase, public CommandHandler {
       public:
         Server(dawnDevice device, const dawnProcTable& procs, CommandSerializer* serializer);
@@ -27,6 +43,8 @@ namespace dawn_wire { namespace server {
         const char* HandleCommands(const char* commands, size_t size);
 
       private:
+        void* GetCmdSpace(size_t size);
+
         // Forwarding callbacks
         static void ForwardDeviceErrorToServer(const char* message, dawnCallbackUserdata userdata);
         static void ForwardBufferMapReadAsync(dawnBufferMapAsyncStatus status,
@@ -56,6 +74,10 @@ namespace dawn_wire { namespace server {
         bool HandleDestroyObject(const char** commands, size_t* size);
 
 #include "dawn_wire/server/ServerPrototypes_autogen.inl"
+
+        CommandSerializer* mSerializer = nullptr;
+        WireDeserializeAllocator mAllocator;
+        dawnProcTable mProcs;
     };
 
 }}  // namespace dawn_wire::server

src/dawn_wire/server/ServerBuffer.cpp

@@ -20,7 +20,7 @@
 namespace dawn_wire { namespace server {
 
     bool Server::PreHandleBufferUnmap(const BufferUnmapCmd& cmd) {
-        auto* selfData = mKnownBuffer.Get(cmd.selfId);
+        auto* selfData = BufferObjects().Get(cmd.selfId);
         ASSERT(selfData != nullptr);
 
         selfData->mappedData = nullptr;
@@ -49,7 +49,7 @@ namespace dawn_wire { namespace server {
             return false;
         }
 
-        auto* buffer = mKnownBuffer.Get(bufferId);
+        auto* buffer = BufferObjects().Get(bufferId);
         if (buffer == nullptr) {
             return false;
         }
@@ -100,7 +100,7 @@ namespace dawn_wire { namespace server {
             return false;
         }
 
-        auto* buffer = mKnownBuffer.Get(bufferId);
+        auto* buffer = BufferObjects().Get(bufferId);
         if (buffer == nullptr || !buffer->valid || buffer->mappedData == nullptr ||
             buffer->mappedDataSize != dataLength) {
             return false;
@@ -133,7 +133,7 @@ namespace dawn_wire { namespace server {
         std::unique_ptr<MapUserdata> data(userdata);
 
         // Skip sending the callback if the buffer has already been destroyed.
-        auto* bufferData = mKnownBuffer.Get(data->buffer.id);
+        auto* bufferData = BufferObjects().Get(data->buffer.id);
         if (bufferData == nullptr || bufferData->serial != data->buffer.serial) {
             return;
         }
@@ -160,7 +160,7 @@ namespace dawn_wire { namespace server {
         std::unique_ptr<MapUserdata> data(userdata);
 
         // Skip sending the callback if the buffer has already been destroyed.
-        auto* bufferData = mKnownBuffer.Get(data->buffer.id);
+        auto* bufferData = BufferObjects().Get(data->buffer.id);
         if (bufferData == nullptr || bufferData->serial != data->buffer.serial) {
             return;
         }

src/dawn_wire/server/ServerQueue.cpp

@@ -21,9 +21,9 @@ namespace dawn_wire { namespace server {
         if (cmd.fence == nullptr) {
             return false;
         }
-        ObjectId fenceId = mFenceIdTable.Get(cmd.fence);
+        ObjectId fenceId = FenceObjectIdTable().Get(cmd.fence);
         ASSERT(fenceId != 0);
-        auto* fence = mKnownFence.Get(fenceId);
+        auto* fence = FenceObjects().Get(fenceId);
         ASSERT(fence != nullptr);
 
         auto* data = new FenceCompletionUserdata;