[Extensions Bindings] Add support for custom property types

extensions/renderer/storage_area.cc

Index: extensions/renderer/storage_area.cc
diff --git a/extensions/renderer/storage_area.cc b/extensions/renderer/storage_area.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8a3bfbe49abdca6a1065f9ac77d76b6a918f99f1
--- /dev/null
+++ b/extensions/renderer/storage_area.cc
@@ -0,0 +1,237 @@
+// 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.
+
+#include "extensions/renderer/storage_area.h"
+
+#include "base/memory/ptr_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/values.h"
+#include "extensions/common/api/storage.h"
+#include "extensions/common/extension_api.h"
+#include "extensions/renderer/api_request_handler.h"
+#include "extensions/renderer/api_signature.h"
+#include "gin/arguments.h"
+#include "gin/handle.h"
+#include "gin/object_template_builder.h"
+#include "gin/wrappable.h"
+
+namespace extensions {
+
+namespace {
+
+// gin::Wrappables for each of the storage areas. Since each has slightly
+// different properties, and the object template is shared between all
+// instances, this is a little verbose.
+class LocalStorageArea final : public gin::Wrappable<LocalStorageArea> {
+ public:
+  LocalStorageArea(APIRequestHandler* request_handler,
+                   const APITypeReferenceMap* type_refs)
+      : storage_area_(request_handler, type_refs, "local") {}
+  ~LocalStorageArea() override = default;
+
+  static gin::WrapperInfo kWrapperInfo;
+
+  gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override {
+    gin::ObjectTemplateBuilder builder =
+        Wrappable<LocalStorageArea>::GetObjectTemplateBuilder(isolate);
+    storage_area_.DecorateTemplate(&builder);
+    builder.SetValue("QUOTA_BYTES", api::storage::local::QUOTA_BYTES);
+    return builder;
+  }
+
+ private:
+  StorageArea storage_area_;
+
+  DISALLOW_COPY_AND_ASSIGN(LocalStorageArea);
+};
+
+gin::WrapperInfo LocalStorageArea::kWrapperInfo = {gin::kEmbedderNativeGin};
+
+class SyncStorageArea final : public gin::Wrappable<SyncStorageArea> {
+ public:
+  SyncStorageArea(APIRequestHandler* request_handler,
+                  const APITypeReferenceMap* type_refs)
+      : storage_area_(request_handler, type_refs, "sync") {}
+  ~SyncStorageArea() override = default;
+
+  static gin::WrapperInfo kWrapperInfo;
+
+  gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override {
+    gin::ObjectTemplateBuilder builder =
+        Wrappable<SyncStorageArea>::GetObjectTemplateBuilder(isolate);
+    storage_area_.DecorateTemplate(&builder);
+    builder.SetValue("QUOTA_BYTES", api::storage::sync::QUOTA_BYTES);
+    builder.SetValue("QUOTA_BYTES_PER_ITEM",
+                     api::storage::sync::QUOTA_BYTES_PER_ITEM);
+    builder.SetValue("MAX_ITEMS", api::storage::sync::MAX_ITEMS);
+    builder.SetValue("MAX_WRITE_OPERATIONS_PER_HOUR",
+                     api::storage::sync::MAX_WRITE_OPERATIONS_PER_HOUR);
+    builder.SetValue("MAX_WRITE_OPERATIONS_PER_MINUTE",
+                     api::storage::sync::MAX_WRITE_OPERATIONS_PER_MINUTE);
+    builder.SetValue(
+        "MAX_SUSTAINED_WRITE_OPERATIONS_PER_MINUTE",
+        api::storage::sync::MAX_SUSTAINED_WRITE_OPERATIONS_PER_MINUTE);
+    return builder;
+  }
+
+ private:
+  StorageArea storage_area_;
+
+  DISALLOW_COPY_AND_ASSIGN(SyncStorageArea);
+};
+
+gin::WrapperInfo SyncStorageArea::kWrapperInfo = {gin::kEmbedderNativeGin};
+
+class ManagedStorageArea final : public gin::Wrappable<ManagedStorageArea> {
+ public:
+  ManagedStorageArea(APIRequestHandler* request_handler,
+                     const APITypeReferenceMap* type_refs)
+      : storage_area_(request_handler, type_refs, "managed") {}
+  ~ManagedStorageArea() override = default;
+
+  static gin::WrapperInfo kWrapperInfo;
+
+  gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) override {
+    gin::ObjectTemplateBuilder builder =
+        Wrappable<ManagedStorageArea>::GetObjectTemplateBuilder(isolate);
+    storage_area_.DecorateTemplate(&builder);
+    return builder;
+  }
+
+ private:
+  StorageArea storage_area_;
+
+  DISALLOW_COPY_AND_ASSIGN(ManagedStorageArea);
+};
+
+gin::WrapperInfo ManagedStorageArea::kWrapperInfo = {gin::kEmbedderNativeGin};
+
+}  // namespace
+
+StorageArea::StorageArea(APIRequestHandler* request_handler,
+                         const APITypeReferenceMap* type_refs,
+                         const std::string& name)
+    : request_handler_(request_handler), type_refs_(type_refs), name_(name) {}
+StorageArea::~StorageArea() = default;
+
+// static
+v8::Local<v8::Object> StorageArea::CreateStorageArea(
+    v8::Local<v8::Context> context,
+    const std::string& property_name,
+    APIRequestHandler* request_handler,
+    APITypeReferenceMap* type_refs) {
+  v8::Context::Scope context_scope(context);
+  v8::Local<v8::Object> object;
+  if (property_name == "local") {
+    gin::Handle<LocalStorageArea> handle =
+        gin::CreateHandle(context->GetIsolate(),
+                          new LocalStorageArea(request_handler, type_refs));
+    object = handle.ToV8().As<v8::Object>();
+  } else if (property_name == "sync") {
+    gin::Handle<SyncStorageArea> handle = gin::CreateHandle(
+        context->GetIsolate(), new SyncStorageArea(request_handler, type_refs));
+    object = handle.ToV8().As<v8::Object>();
+  } else {
+    CHECK_EQ("managed", property_name);
+    gin::Handle<ManagedStorageArea> handle =
+        gin::CreateHandle(context->GetIsolate(),
+                          new ManagedStorageArea(request_handler, type_refs));
+    object = handle.ToV8().As<v8::Object>();
+  }
+  return object;
+}
+
+void StorageArea::DecorateTemplate(gin::ObjectTemplateBuilder* builder) {
+  builder
+      ->SetMethod("get", base::Bind(&StorageArea::HandleFunctionCall,
+                                    base::Unretained(this), "get"))

[jbroman, 2017/02/21 16:47:37]

The object template is per-isolate-cached, but |this| will not remain valid for
that lifetime (at best, it'll last as long as the context does -- but not even
that long, as I don't see anything preventing script from dropping the last GC
reference). You should be getting the |StorageArea| pointer from the holder,
somehow. One approach might be something like:

template <typename T>
void DecorateObjectTemplate(gin::ObjectTemplateBuilder* builder) {
  builder
      ->SetMethod("get", &T::get)
      .SetMethod("set", &T::set)
      .SetMethod("remove", &T::remove)
      .SetMethod("clear", &T::clear)
      .SetMethod("getBytesInUse", &T::getBytesInUse);
}

// and then provide implementations of all of these for each different wrappable
type

If you want to shed a little more of the gin magic (but keep
StorageArea::HandleFunctionCall more like it is now), then something like this
would work:

template <typename T>
void DecorateTemplateBuilder(gin::ObjectTemplateBuilder* builder) {
  for (const char* key : {"get", "set", "remove", "clear", "getBytesInUse"}) {
    builder->SetMethod(key, base::Bind([](const char* method_name,
gin::Arguments* arguments) {
      T* holder = nullptr;
      if (!arguments->GetHolder(&holder)) {
        arguments->ThrowTypeError("Invalid receiver for StorageArea method.");
        return;
      }
      holder->storage_area().HandleFunctionCall(method_name, arguments);
    }, key));
  }
}

[Devlin, 2017/02/21 18:05:40]

Opted for the second - I'm really not keen on re-implementing each of these
three times when the only thing that really needs to change is the value of the
properties (and none of the implementation).

+      .SetMethod("set", base::Bind(&StorageArea::HandleFunctionCall,
+                                   base::Unretained(this), "set"))
+      .SetMethod("remove", base::Bind(&StorageArea::HandleFunctionCall,
+                                      base::Unretained(this), "remove"))
+      .SetMethod("clear", base::Bind(&StorageArea::HandleFunctionCall,
+                                     base::Unretained(this), "clear"))
+      .SetMethod("getBytesInUse",
+                 base::Bind(&StorageArea::HandleFunctionCall,
+                            base::Unretained(this), "getBytesInUse"));
+}
+
+void StorageArea::HandleFunctionCall(const std::string& method_name,
+                                     gin::Arguments* arguments) {
+  v8::Isolate* isolate = arguments->isolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  std::vector<v8::Local<v8::Value>> argument_list;
+  if (arguments->Length() > 0) {
+    // Just copying handles should never fail.
+    CHECK(arguments->GetRemaining(&argument_list));
+  }
+
+  std::unique_ptr<base::ListValue> converted_arguments;
+  v8::Local<v8::Function> callback;
+  std::string error;
+  if (!GetFunctionSchema("storage", "storage.StorageArea", method_name)
+           .ParseArgumentsToJSON(context, argument_list, *type_refs_,
+                                 &converted_arguments, &callback, &error)) {
+    arguments->ThrowTypeError("Invalid invocation");
+    return;
+  }
+
+  converted_arguments->Insert(0u, base::MakeUnique<base::Value>(name_));
+  request_handler_->StartRequest(context, "storage." + method_name,
+                                 std::move(converted_arguments), callback,
+                                 v8::Local<v8::Function>());
+}
+
+const APISignature& StorageArea::GetFunctionSchema(
+    base::StringPiece api_name,
+    base::StringPiece type_name,
+    base::StringPiece function_name) {
+  std::string full_name = base::StringPrintf(
+      "%s.%s.%s", api_name.data(), type_name.data(), function_name.data());
+  auto iter = signatures_.find(full_name);
+  if (iter != signatures_.end())
+    return *iter->second;
+
+  const base::DictionaryValue* full_schema =
+      ExtensionAPI::GetSharedInstance()->GetSchema(api_name.as_string());
+  const base::ListValue* types = nullptr;
+  CHECK(full_schema->GetList("types", &types));
+  const base::DictionaryValue* type_schema = nullptr;
+  for (const auto& type : *types) {
+    const base::DictionaryValue* type_dict = nullptr;
+    CHECK(type->GetAsDictionary(&type_dict));
+    std::string id;
+    CHECK(type_dict->GetString("id", &id));
+    if (id == type_name) {
+      type_schema = type_dict;
+      break;
+    }
+  }
+  CHECK(type_schema);
+  const base::ListValue* type_functions = nullptr;
+  CHECK(type_schema->GetList("functions", &type_functions));
+  const base::ListValue* parameters = nullptr;
+  for (const auto& function : *type_functions) {
+    const base::DictionaryValue* function_dict = nullptr;
+    CHECK(function->GetAsDictionary(&function_dict));
+    std::string name;
+    CHECK(function_dict->GetString("name", &name));
+    if (name == function_name) {
+      CHECK(function_dict->GetList("parameters", &parameters));
+      break;
+    }
+  }
+  CHECK(parameters);
+  auto signature = base::MakeUnique<APISignature>(*parameters);
+  auto raw_signature = signature.get();
+  signatures_[full_name] = std::move(signature);
+  return *raw_signature;
+}
+
+}  // namespace extensions