Add wire_cmd.py and dawn_wire.json to autogenerate all wire commands.

Unify code generation for Client->Server and Server->Client commands.
Methods in dawn.json are converted into command records and additional
commands are specified in dawn_wire.json. This can then be used to
completely generate the command handlers and command struct definitions.

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

src/dawn_wire/WireCmd.h

@@ -1,83 +0,0 @@
-// Copyright 2017 The Dawn Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef DAWNWIRE_WIRECMD_H_
-#define DAWNWIRE_WIRECMD_H_
-
-#include <dawn/dawn.h>
-
-#include "dawn_wire/WireCmd_autogen.h"
-
-namespace dawn_wire {
-
-    struct ReturnDeviceErrorCallbackCmd {
-        ReturnWireCmd commandId = ReturnWireCmd::DeviceErrorCallback;
-
-        size_t messageStrlen;
-    };
-
-    struct BufferMapAsyncCmd {
-        WireCmd commandId = WireCmd::BufferMapAsync;
-
-        ObjectId bufferId;
-        ObjectSerial requestSerial;
-        uint32_t start;
-        uint32_t size;
-        bool isWrite;
-    };
-
-    struct ReturnBufferMapReadAsyncCallbackCmd {
-        ReturnWireCmd commandId = ReturnWireCmd::BufferMapReadAsyncCallback;
-
-        ObjectId bufferId;
-        ObjectSerial bufferSerial;
-        uint32_t requestSerial;
-        uint32_t status;
-        uint32_t dataLength;
-    };
-
-    struct ReturnBufferMapWriteAsyncCallbackCmd {
-        ReturnWireCmd commandId = ReturnWireCmd::BufferMapWriteAsyncCallback;
-
-        ObjectId bufferId;
-        ObjectSerial bufferSerial;
-        uint32_t requestSerial;
-        uint32_t status;
-    };
-
-    struct ReturnFenceUpdateCompletedValueCmd {
-        ReturnWireCmd commandId = ReturnWireCmd::FenceUpdateCompletedValue;
-
-        ObjectId fenceId;
-        ObjectSerial fenceSerial;
-        uint64_t value;
-    };
-
-    struct BufferUpdateMappedDataCmd {
-        WireCmd commandId = WireCmd::BufferUpdateMappedDataCmd;
-
-        ObjectId bufferId;
-        uint32_t dataLength;
-    };
-
-    struct DestroyObjectCmd {
-        WireCmd commandId = WireCmd::DestroyObject;
-
-        ObjectType objectType;
-        ObjectId objectId;
-    };
-
-}  // namespace dawn_wire
-
-#endif  // DAWNWIRE_WIRECMD_H_

src/dawn_wire/WireDeserializeAllocator.cpp

@@ -0,0 +1,60 @@
+// Copyright 2019 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "dawn_wire/WireDeserializeAllocator.h"
+
+#include <algorithm>
+
+namespace dawn_wire {
+    WireDeserializeAllocator::WireDeserializeAllocator() {
+        Reset();
+    }
+
+    WireDeserializeAllocator::~WireDeserializeAllocator() {
+        Reset();
+    }
+
+    void* WireDeserializeAllocator::GetSpace(size_t size) {
+        // Return space in the current buffer if possible first.
+        if (mRemainingSize >= size) {
+            char* buffer = mCurrentBuffer;
+            mCurrentBuffer += size;
+            mRemainingSize -= size;
+            return buffer;
+        }
+
+        // Otherwise allocate a new buffer and try again.
+        size_t allocationSize = std::max(size, size_t(2048));
+        char* allocation = static_cast<char*>(malloc(allocationSize));
+        if (allocation == nullptr) {
+            return nullptr;
+        }
+
+        mAllocations.push_back(allocation);
+        mCurrentBuffer = allocation;
+        mRemainingSize = allocationSize;
+        return GetSpace(size);
+    }
+
+    void WireDeserializeAllocator::Reset() {
+        for (auto allocation : mAllocations) {
+            free(allocation);
+        }
+        mAllocations.clear();
+
+        // The initial buffer is the inline buffer so that some allocations can be skipped
+        mCurrentBuffer = mStaticBuffer;
+        mRemainingSize = sizeof(mStaticBuffer);
+    }
+}  // namespace dawn_wire

src/dawn_wire/WireDeserializeAllocator.h

@@ -0,0 +1,43 @@
+// Copyright 2019 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef DAWNWIRE_WIREDESERIALIZEALLOCATOR_H_
+#define DAWNWIRE_WIREDESERIALIZEALLOCATOR_H_
+
+#include "dawn_wire/WireCmd_autogen.h"
+
+#include <vector>
+
+namespace dawn_wire {
+    // A really really simple implementation of the DeserializeAllocator. It's main feature
+    // is that it has some inline storage so as to avoid allocations for the majority of
+    // commands.
+    class WireDeserializeAllocator : public DeserializeAllocator {
+      public:
+        WireDeserializeAllocator();
+        ~WireDeserializeAllocator();
+
+        void* GetSpace(size_t size) override;
+
+        void Reset();
+
+      private:
+        size_t mRemainingSize = 0;
+        char* mCurrentBuffer = nullptr;
+        char mStaticBuffer[2048];
+        std::vector<char*> mAllocations;
+    };
+}  // namespace dawn_wire
+
+#endif  // DAWNWIRE_WIREDESERIALIZEALLOCATOR_H_