gin: Create a DataObjectBuilder class to help create simple data objects.

gin/data_object_builder.h

Index: gin/data_object_builder.h
diff --git a/gin/data_object_builder.h b/gin/data_object_builder.h
new file mode 100644
index 0000000000000000000000000000000000000000..d2f8354b8f327c66155a4223b4f298900ff1f345
--- /dev/null
+++ b/gin/data_object_builder.h
@@ -0,0 +1,66 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef GIN_DATA_OBJECT_BUILDER_H_
+#define GIN_DATA_OBJECT_BUILDER_H_
+
+#include <utility>
+
+#include "base/macros.h"
+#include "base/strings/string_piece.h"
+#include "gin/converter.h"
+#include "gin/gin_export.h"
+#include "v8/include/v8.h"
+
+namespace gin {
+
+// Constructs a JavaScript object with a series of data properties.
+// (As with default data properties in JavaScript, these properties are
+// configurable, writable and enumerable.)
+//
+// Values are automatically converted using gin::Converter, though if
+// using a type where the conversion may fail, callers must convert ahead of
+// time.
+//
+// This class avoids the pitfall of using v8::Object::Set, which may invoke
+// setters on the object prototype.
+//
+// Expected usage:
+// v8::Local<v8::Object> object = gin::DataObjectBuilder(isolate)
+//     .Set("boolean", true)
+//     .Set("integer", 42)
+//     .Finish();
+//
+// Because this builder class contains local handles, callers must ensure it
+// does not outlive the scope in which it is created.
+class GIN_EXPORT DataObjectBuilder {
+ public:
+  explicit DataObjectBuilder(v8::Isolate* isolate);
+
+  template <typename T>
+  DataObjectBuilder& Set(base::StringPiece key, T&& value) {
+    v8::Local<v8::String> v8_key = StringToSymbol(isolate_, key);
+    v8::Local<v8::Value> v8_value =
+        ConvertToV8(isolate_, std::forward<T>(value));
+    CHECK(object_->CreateDataProperty(context_, v8_key, v8_value).ToChecked());
+    return *this;
+  }
+
+  v8::Local<v8::Object> Finish() {

[Devlin, 2017/04/26 18:30:24]

nitty nit: most Builders seem to have a Build() rather than Finish(), so I'd opt
for that.  But I don't feel strongly at all.

[jbroman, 2017/04/27 15:26:31]

OK, done. I agree that it's more usual, though it feels a little silly as this
is the only step that doesn't build anything. :D

+    v8::Local<v8::Object> result = object_;
+    object_.Clear();
+    return result;
+  }
+
+ private:
+  v8::Isolate* isolate_;
+  v8::Local<v8::Context> context_;
+  v8::Local<v8::Object> object_;
+
+  DISALLOW_COPY_AND_ASSIGN(DataObjectBuilder);
+};
+
+}  // namespace gin
+
+#endif  // GIN_DATA_OBJECT_BUILDER_H_