Make the templates of webgpu_absl_format flexible

Move the manually parts to src/dawn_native/webgpu_absl_format.cpp/h.
Rename the template webgpu_absl_format.cpp/h to api_absl_format.cpp.h .

BUG=dawn:1201, dawn:563
Change-Id: Ibbeea43227f4fcf7f1d6b1d0bc3927226e79e6c3
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/74300
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
Commit-Queue: Junwei Fu <junwei.fu@intel.com>

generator/dawn_json_generator.py

@@ -923,12 +923,12 @@ class MultiGeneratorFromDawnJSON(Generator):
                            'src/' + native_dir + '/ChainUtils_autogen.cpp',
                            frontend_params))
             renders.append(
-                FileRender('dawn_native/webgpu_absl_format.h',
+                FileRender('dawn_native/api_absl_format.h',
-                           'src/dawn_native/webgpu_absl_format_autogen.h',
+                           'src/' + native_dir + '/' + api + '_absl_format_autogen.h',
                            frontend_params))
             renders.append(
-                FileRender('dawn_native/webgpu_absl_format.cpp',
+                FileRender('dawn_native/api_absl_format.cpp',
-                           'src/dawn_native/webgpu_absl_format_autogen.cpp',
+                           'src/' + native_dir + '/' + api + '_absl_format_autogen.cpp',
                            frontend_params))
             renders.append(
                 FileRender('dawn_native/ObjectType.h',

generator/templates/dawn_native/api_absl_format.cpp

@@ -12,124 +12,15 @@
 //* See the License for the specific language governing permissions and
 //* limitations under the License.
 
-#include "dawn_native/webgpu_absl_format_autogen.h"
+{% set impl_dir = metadata.impl_dir + "/" if metadata.impl_dir else "" %}
+{% set native_namespace = Name(metadata.native_namespace).snake_case() %}
+{% set native_dir = impl_dir + native_namespace %}
+{% set api = metadata.api.lower() %}
+#include "{{native_dir}}/{{api}}_absl_format_autogen.h"
 
-#include "dawn_native/Device.h"
+#include "{{native_dir}}/ObjectType_autogen.h"
-#include "dawn_native/ObjectBase.h"
-#include "dawn_native/ObjectType_autogen.h"
-#include "dawn_native/Texture.h"
 
-namespace dawn_native {
+namespace {{native_namespace}} {
-
-    //
-    // Structs (Manually written)
-    //
-
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const Color* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s) {
-        if (value == nullptr) {
-            s->Append("[null]");
-            return {true};
-        }
-        s->Append(absl::StrFormat("[Color r:%f, g:%f, b:%f, a:%f]",
-            value->r, value->g, value->b, value->a));
-        return {true};
-    }
-
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const Extent3D* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s) {
-        if (value == nullptr) {
-            s->Append("[null]");
-            return {true};
-        }
-        s->Append(absl::StrFormat("[Extent3D width:%u, height:%u, depthOrArrayLayers:%u]",
-            value->width, value->height, value->depthOrArrayLayers));
-        return {true};
-    }
-
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const Origin3D* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s) {
-        if (value == nullptr) {
-            s->Append("[null]");
-            return {true};
-        }
-        s->Append(absl::StrFormat("[Origin3D x:%u, y:%u, z:%u]",
-            value->x, value->y, value->z));
-        return {true};
-    }
-
-    //
-    // Objects
-    //
-
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const DeviceBase* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s) {
-        if (value == nullptr) {
-            s->Append("[null]");
-            return {true};
-        }
-        s->Append("[Device");
-        const std::string& label = value->GetLabel();
-        if (!label.empty()) {
-            s->Append(absl::StrFormat(" \"%s\"", label));
-        }
-        s->Append("]");
-        return {true};
-    }
-
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const ApiObjectBase* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s) {
-        if (value == nullptr) {
-            s->Append("[null]");
-            return {true};
-        }
-        s->Append("[");
-        if (value->IsError()) {
-            s->Append("Invalid ");
-        }
-        s->Append(ObjectTypeAsString(value->GetType()));
-        const std::string& label = value->GetLabel();
-        if (!label.empty()) {
-            s->Append(absl::StrFormat(" \"%s\"", label));
-        }
-        s->Append("]");
-        return {true};
-    }
-
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const TextureViewBase* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s) {
-        if (value == nullptr) {
-            s->Append("[null]");
-            return {true};
-        }
-        s->Append("[");
-        if (value->IsError()) {
-            s->Append("Invalid ");
-        }
-        s->Append(ObjectTypeAsString(value->GetType()));
-        const std::string& label = value->GetLabel();
-        if (!label.empty()) {
-            s->Append(absl::StrFormat(" \"%s\"", label));
-        }
-        const std::string& textureLabel = value->GetTexture()->GetLabel();
-        if (!textureLabel.empty()) {
-            s->Append(absl::StrFormat(" of Texture \"%s\"", textureLabel));
-        }
-        s->Append("]");
-        return {true};
-    }
 
     //
     // Descriptors
@@ -157,9 +48,10 @@ namespace dawn_native {
         {% endfor %}
     {% endfor %}
 
-}  // namespace dawn_native
+}  // namespace {{native_namespace}}
 
-namespace wgpu {
+{% set namespace = metadata.namespace %}
+namespace {{namespace}} {
 
     //
     // Enums
@@ -236,4 +128,4 @@ namespace wgpu {
         }
     {% endfor %}
 
-}  // namespace wgpu
+}  // namespace {{namespace}}

generator/templates/dawn_native/api_absl_format.h

@@ -0,0 +1,73 @@
+//* Copyright 2021 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.
+
+{% set API = metadata.api.upper() %}
+#ifndef {{API}}_ABSL_FORMAT_H_
+#define {{API}}_ABSL_FORMAT_H_
+
+{% set impl_dir = metadata.impl_dir + "/" if metadata.impl_dir else "" %}
+{% set native_namespace = Name(metadata.native_namespace).snake_case() %}
+{% set native_dir = impl_dir + native_namespace %}
+{% set prefix = metadata.proc_table_prefix.lower() %}
+#include "{{native_dir}}/{{prefix}}_platform.h"
+
+#include "absl/strings/str_format.h"
+
+namespace {{native_namespace}} {
+
+    //
+    // Descriptors
+    //
+
+    // Only includes structures that have a 'label' member.
+    {% for type in by_category["structure"] %}
+        {% for member in type.members %}
+            {% if member.name.canonical_case() == "label" %}
+                absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+                AbslFormatConvert(const {{as_cppType(type.name)}}* value,
+                                  const absl::FormatConversionSpec& spec,
+                                  absl::FormatSink* s);
+            {% endif %}
+        {% endfor %}
+    {% endfor %}
+} // namespace {{native_namespace}}
+
+{% set namespace = metadata.namespace %}
+namespace {{namespace}} {
+
+    //
+    // Enums
+    //
+
+    {% for type in by_category["enum"] %}
+        absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+        AbslFormatConvert({{as_cppType(type.name)}} value,
+                          const absl::FormatConversionSpec& spec,
+                          absl::FormatSink* s);
+    {% endfor %}
+
+    //
+    // Bitmasks
+    //
+
+    {% for type in by_category["bitmask"] %}
+        absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+        AbslFormatConvert({{as_cppType(type.name)}} value,
+                          const absl::FormatConversionSpec& spec,
+                          absl::FormatSink* s);
+    {% endfor %}
+
+}  // namespace {{namespace}}
+
+#endif // {{API}}_ABSL_FORMAT_H_

generator/templates/dawn_native/webgpu_absl_format.h

@@ -1,118 +0,0 @@
-//* Copyright 2021 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 WEBGPU_ABSL_FORMAT_H_
-#define WEBGPU_ABSL_FORMAT_H_
-
-#include "dawn_native/dawn_platform.h"
-
-#include "absl/strings/str_format.h"
-
-namespace dawn_native {
-
-    // TODO(dawn:563):
-    //  - Split the file between autogenerated parts and manually written parts.
-    //  - Forward declare common Dawn enums and have AbslFormatConvert for them.
-    //  - Support AbslFormatConvert for Dawn's typed integers.
-
-    //
-    // Structs (Manually written)
-    //
-
-    struct Color;
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const Color* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s);
-
-    struct Extent3D;
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const Extent3D* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s);
-
-    struct Origin3D;
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const Origin3D* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s);
-
-    //
-    // Objects
-    //
-
-    class DeviceBase;
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const DeviceBase* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s);
-
-    class ApiObjectBase;
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const ApiObjectBase* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s);
-
-    // Special case for TextureViews, since frequently the texture will be the
-    // thing that's labeled.
-    class TextureViewBase;
-    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-    AbslFormatConvert(const TextureViewBase* value,
-                      const absl::FormatConversionSpec& spec,
-                      absl::FormatSink* s);
-
-    //
-    // Descriptors
-    //
-
-    // Only includes structures that have a 'label' member.
-    {% for type in by_category["structure"] %}
-        {% for member in type.members %}
-            {% if member.name.canonical_case() == "label" %}
-                absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-                AbslFormatConvert(const {{as_cppType(type.name)}}* value,
-                                  const absl::FormatConversionSpec& spec,
-                                  absl::FormatSink* s);
-            {% endif %}
-        {% endfor %}
-    {% endfor %}
-}
-
-namespace wgpu {
-
-    //
-    // Enums
-    //
-
-    {% for type in by_category["enum"] %}
-        absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-        AbslFormatConvert({{as_cppType(type.name)}} value,
-                          const absl::FormatConversionSpec& spec,
-                          absl::FormatSink* s);
-    {% endfor %}
-
-    //
-    // Bitmasks
-    //
-
-    {% for type in by_category["bitmask"] %}
-        absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
-        AbslFormatConvert({{as_cppType(type.name)}} value,
-                          const absl::FormatConversionSpec& spec,
-                          absl::FormatSink* s);
-    {% endfor %}
-
-}  // namespace dawn_native
-
-#endif // WEBGPU_ABSL_FORMAT_H_

src/dawn_native/BUILD.gn

@@ -331,6 +331,8 @@ source_set("dawn_native_sources") {
     "VertexFormat.cpp",
     "VertexFormat.h",
     "dawn_platform.h",
+    "webgpu_absl_format.cpp",
+    "webgpu_absl_format.h",
     "utils/WGPUHelpers.cpp",
     "utils/WGPUHelpers.h",
   ]

src/dawn_native/CMakeLists.txt

@@ -176,6 +176,8 @@ target_sources(dawn_native PRIVATE
     "VertexFormat.cpp"
     "VertexFormat.h"
     "dawn_platform.h"
+    "webgpu_absl_format.cpp"
+    "webgpu_absl_format.h"
     "utils/WGPUHelpers.cpp"
     "utils/WGPUHelpers.h"
 )

src/dawn_native/Error.h

@@ -18,7 +18,7 @@
 #include "absl/strings/str_format.h"
 #include "common/Result.h"
 #include "dawn_native/ErrorData.h"
-#include "dawn_native/webgpu_absl_format_autogen.h"
+#include "dawn_native/webgpu_absl_format.h"
 
 #include <string>
 

src/dawn_native/webgpu_absl_format.cpp

@@ -0,0 +1,133 @@
+// Copyright 2021 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_native/webgpu_absl_format.h"
+
+#include "dawn_native/Device.h"
+#include "dawn_native/ObjectBase.h"
+#include "dawn_native/Texture.h"
+
+namespace dawn_native {
+
+    //
+    // Structs
+    //
+
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const Color* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s) {
+        if (value == nullptr) {
+            s->Append("[null]");
+            return {true};
+        }
+        s->Append(absl::StrFormat("[Color r:%f, g:%f, b:%f, a:%f]",
+            value->r, value->g, value->b, value->a));
+        return {true};
+    }
+
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const Extent3D* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s) {
+        if (value == nullptr) {
+            s->Append("[null]");
+            return {true};
+        }
+        s->Append(absl::StrFormat("[Extent3D width:%u, height:%u, depthOrArrayLayers:%u]",
+            value->width, value->height, value->depthOrArrayLayers));
+        return {true};
+    }
+
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const Origin3D* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s) {
+        if (value == nullptr) {
+            s->Append("[null]");
+            return {true};
+        }
+        s->Append(absl::StrFormat("[Origin3D x:%u, y:%u, z:%u]",
+            value->x, value->y, value->z));
+        return {true};
+    }
+
+    //
+    // Objects
+    //
+
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const DeviceBase* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s) {
+        if (value == nullptr) {
+            s->Append("[null]");
+            return {true};
+        }
+        s->Append("[Device");
+        const std::string& label = value->GetLabel();
+        if (!label.empty()) {
+            s->Append(absl::StrFormat(" \"%s\"", label));
+        }
+        s->Append("]");
+        return {true};
+    }
+
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const ApiObjectBase* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s) {
+        if (value == nullptr) {
+            s->Append("[null]");
+            return {true};
+        }
+        s->Append("[");
+        if (value->IsError()) {
+            s->Append("Invalid ");
+        }
+        s->Append(ObjectTypeAsString(value->GetType()));
+        const std::string& label = value->GetLabel();
+        if (!label.empty()) {
+            s->Append(absl::StrFormat(" \"%s\"", label));
+        }
+        s->Append("]");
+        return {true};
+    }
+
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const TextureViewBase* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s) {
+        if (value == nullptr) {
+            s->Append("[null]");
+            return {true};
+        }
+        s->Append("[");
+        if (value->IsError()) {
+            s->Append("Invalid ");
+        }
+        s->Append(ObjectTypeAsString(value->GetType()));
+        const std::string& label = value->GetLabel();
+        if (!label.empty()) {
+            s->Append(absl::StrFormat(" \"%s\"", label));
+        }
+        const std::string& textureLabel = value->GetTexture()->GetLabel();
+        if (!textureLabel.empty()) {
+            s->Append(absl::StrFormat(" of Texture \"%s\"", textureLabel));
+        }
+        s->Append("]");
+        return {true};
+    }
+
+}  // namespace dawn_native

src/dawn_native/webgpu_absl_format.h

@@ -0,0 +1,72 @@
+// Copyright 2021 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 DAWNNATIVE_WEBGPUABSLFORMAT_H_
+#define DAWNNATIVE_WEBGPUABSLFORMAT_H_
+
+#include "absl/strings/str_format.h"
+#include "dawn_native/dawn_platform.h"
+#include "dawn_native/webgpu_absl_format_autogen.h"
+
+namespace dawn_native {
+
+    //
+    // Structs
+    //
+
+    struct Color;
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const Color* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s);
+
+    struct Extent3D;
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const Extent3D* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s);
+
+    struct Origin3D;
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const Origin3D* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s);
+
+    //
+    // Objects
+    //
+
+    class DeviceBase;
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const DeviceBase* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s);
+
+    class ApiObjectBase;
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const ApiObjectBase* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s);
+
+    // Special case for TextureViews, since frequently the texture will be the
+    // thing that's labeled.
+    class TextureViewBase;
+    absl::FormatConvertResult<absl::FormatConversionCharSet::kString>
+    AbslFormatConvert(const TextureViewBase* value,
+                      const absl::FormatConversionSpec& spec,
+                      absl::FormatSink* s);
+
+}  // namespace dawn_native
+
+#endif  // DAWNNATIVE_WEBGPUABSLFORMAT_H_