[Extensions Bindings] Add support for custom property types

extensions/renderer/api_binding.cc

 // Copyright 2016 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/api_binding.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 54 matching lines @@
   if (!IsContextValid(args.isolate()->GetCurrentContext()))
     return;
 
   v8::Local<v8::External> external;
   CHECK(args.GetData(&external));
   auto* callback = static_cast<APIBinding::HandlerCallback*>(external->Value());
 
   callback->Run(&args);
 }
 
-// Decorates |object_template| with the properties specified by |properties|.
-void DecorateTemplateWithProperties(
-    v8::Isolate* isolate,
-    v8::Local<v8::ObjectTemplate> object_template,
-    const base::DictionaryValue& properties) {
-  static const char kValueKey[] = "value";
-  for (base::DictionaryValue::Iterator iter(properties); !iter.IsAtEnd();
-       iter.Advance()) {
-    const base::DictionaryValue* dict = nullptr;
-    CHECK(iter.value().GetAsDictionary(&dict));
-    bool optional = false;
-    if (dict->GetBoolean("optional", &optional)) {
-      // TODO(devlin): What does optional even mean here? It's only used, it
-      // seems, for lastError and inIncognitoContext, which are both handled
-      // with custom bindings. Investigate, and remove.
-      continue;
-    }
-    std::string ref;
-    if (dict->GetString("$ref", &ref)) {
-      // TODO(devlin): Handle refs. These are tricky(er), because they represent
-      // a type that's defined in (currently) JS.
-      continue;
-    }
-    std::string type;
-    CHECK(dict->GetString("type", &type));
-    if (type != "object" && !dict->HasKey(kValueKey)) {
-      // TODO(devlin): What does a fundamental property not having a value mean?
-      // It doesn't seem useful, and looks like it's only used by runtime.id,
-      // which is set by custom bindings. Investigate, and remove.
-      continue;
-    }
-    if (type == "integer") {
-      int val = 0;
-      CHECK(dict->GetInteger(kValueKey, &val));
-      object_template->Set(isolate, iter.key().c_str(),
-                           v8::Integer::New(isolate, val));
-    } else if (type == "boolean") {
-      bool val = false;
-      CHECK(dict->GetBoolean(kValueKey, &val));
-      object_template->Set(isolate, iter.key().c_str(),
-                           v8::Boolean::New(isolate, val));
-    } else if (type == "string") {
-      std::string val;
-      CHECK(dict->GetString(kValueKey, &val)) << iter.key();
-      object_template->Set(isolate, iter.key().c_str(),
-                           gin::StringToSymbol(isolate, val));
-    } else if (type == "object") {
-      v8::Local<v8::ObjectTemplate> property_template =
-          v8::ObjectTemplate::New(isolate);
-      const base::DictionaryValue* property_dict = nullptr;
-      CHECK(dict->GetDictionary("properties", &property_dict));
-      DecorateTemplateWithProperties(isolate, property_template,
-                                     *property_dict);
-      object_template->Set(isolate, iter.key().c_str(), property_template);
-    }
-  }
-}
-
 }  // namespace
 
 struct APIBinding::MethodData {
   MethodData(std::string full_name,
              const base::ListValue& method_signature)
       : full_name(std::move(full_name)),
         signature(method_signature) {}
 
   // The fully-qualified name of this api (e.g. runtime.sendMessage instead of
   // sendMessage).
@@ skipping 16 matching lines @@
   std::string exposed_name;
   // The fully-specified name of the event (e.g. tabs.onCreated).
   std::string full_name;
   // The associated event handler. This raw pointer is safe because the
   // EventData is only accessed from the callbacks associated with the
   // APIBinding, and both the APIBinding and APIEventHandler are owned by the
   // same object (the APIBindingsSystem).
   APIEventHandler* event_handler;
 };
 
+struct APIBinding::CustomPropertyData {
+  CustomPropertyData(const std::string& type_name,
+                     const std::string& property_name,
+                     const CreateCustomType& create_custom_type)
+      : type_name(type_name),
+        property_name(property_name),
+        create_custom_type(create_custom_type) {}
+
+  std::string type_name;

[lazyboy, 2017/02/22 03:37:03]

I find giving examples of these are helpful to navigate the code.
e.g. chrome.storage.local refers to type StorageArea, type_name would be
"storage.StorageArea", property_name would be "local"

[Devlin, 2017/02/22 20:56:45]

Done.

+  std::string property_name;
+  CreateCustomType create_custom_type;
+};
+
 APIBinding::APIBinding(const std::string& api_name,
                        const base::ListValue* function_definitions,
                        const base::ListValue* type_definitions,
                        const base::ListValue* event_definitions,
                        const base::DictionaryValue* property_definitions,
+                       const CreateCustomType& create_custom_type,
                        std::unique_ptr<APIBindingHooks> binding_hooks,
                        APITypeReferenceMap* type_refs,
                        APIRequestHandler* request_handler,
                        APIEventHandler* event_handler)
     : api_name_(api_name),
       property_definitions_(property_definitions),
+      create_custom_type_(create_custom_type),
       binding_hooks_(std::move(binding_hooks)),
       type_refs_(type_refs),
       request_handler_(request_handler),
       weak_factory_(this) {
   // TODO(devlin): It might make sense to instantiate the object_template_
   // directly here, which would avoid the need to hold on to
   // |property_definitions_| and |enums_|. However, there are *some* cases where
   // we don't immediately stamp out an API from the template following
   // construction.
 
@@ skipping 130 matching lines @@
   }
 
   if (property_definitions_) {
     DecorateTemplateWithProperties(isolate, object_template,
                                    *property_definitions_);
   }
 
   object_template_.Set(isolate, object_template);
 }
 
+void APIBinding::DecorateTemplateWithProperties(
+    v8::Isolate* isolate,
+    v8::Local<v8::ObjectTemplate> object_template,
+    const base::DictionaryValue& properties) {
+  static const char kValueKey[] = "value";
+  for (base::DictionaryValue::Iterator iter(properties); !iter.IsAtEnd();
+       iter.Advance()) {
+    const base::DictionaryValue* dict = nullptr;
+    CHECK(iter.value().GetAsDictionary(&dict));
+    bool optional = false;
+    if (dict->GetBoolean("optional", &optional)) {
+      // TODO(devlin): What does optional even mean here? It's only used, it
+      // seems, for lastError and inIncognitoContext, which are both handled
+      // with custom bindings. Investigate, and remove.
+      continue;
+    }
+
+    v8::Local<v8::String> v8_key = gin::StringToSymbol(isolate, iter.key());
+    std::string ref;
+    if (dict->GetString("$ref", &ref)) {

[lazyboy, 2017/02/22 03:37:03]

For storage, we would get "StorageArea" as $ref in JSON and since we registered
the custom type "storage.StorageArea" in native_extensions_bindings_system.cc,
we will be able to retrieve the custom type?

So the custom bindings need to be implemented in c++ but we need to express its
presence in JSON schema, right? I'd document that in
APIBindingsSystem::RegisterCustomType()

[Devlin, 2017/02/22 20:56:45]

In our json generation/compression, we fully specify all types, so the ref
becomes storage.StorageArea.  Check out
src/out/Debug/gen/extensions/common/api/generated_schemas.cc.
Sg; done.

+      auto property_data = base::MakeUnique<CustomPropertyData>(
+          ref, iter.key(), create_custom_type_);
+      object_template->SetLazyDataProperty(
+          v8_key, &APIBinding::GetCustomPropertyObject,
+          v8::External::New(isolate, property_data.get()));
+      custom_properties_.push_back(std::move(property_data));
+      continue;
+    }
+
+    std::string type;
+    CHECK(dict->GetString("type", &type));
+    if (type != "object" && !dict->HasKey(kValueKey)) {
+      // TODO(devlin): What does a fundamental property not having a value mean?
+      // It doesn't seem useful, and looks like it's only used by runtime.id,
+      // which is set by custom bindings. Investigate, and remove.
+      continue;
+    }
+    if (type == "integer") {
+      int val = 0;
+      CHECK(dict->GetInteger(kValueKey, &val));
+      object_template->Set(v8_key, v8::Integer::New(isolate, val));
+    } else if (type == "boolean") {
+      bool val = false;
+      CHECK(dict->GetBoolean(kValueKey, &val));
+      object_template->Set(v8_key, v8::Boolean::New(isolate, val));
+    } else if (type == "string") {
+      std::string val;
+      CHECK(dict->GetString(kValueKey, &val)) << iter.key();
+      object_template->Set(v8_key, gin::StringToSymbol(isolate, val));
+    } else if (type == "object" || !ref.empty()) {
+      v8::Local<v8::ObjectTemplate> property_template =
+          v8::ObjectTemplate::New(isolate);
+      const base::DictionaryValue* property_dict = nullptr;
+      CHECK(dict->GetDictionary("properties", &property_dict));
+      DecorateTemplateWithProperties(isolate, property_template,
+                                     *property_dict);
+      object_template->Set(v8_key, property_template);
+    }
+  }
+}
+
 // static
 void APIBinding::GetEventObject(
     v8::Local<v8::Name> property,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   v8::Isolate* isolate = info.GetIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = info.Holder()->CreationContext();
   if (!IsContextValid(context))
     return;
 
   CHECK(info.Data()->IsExternal());
   auto* event_data =
       static_cast<EventData*>(info.Data().As<v8::External>()->Value());
   info.GetReturnValue().Set(event_data->event_handler->CreateEventInstance(
       event_data->full_name, context));
 }
 
+void APIBinding::GetCustomPropertyObject(
+    v8::Local<v8::Name> property_name,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  v8::Isolate* isolate = info.GetIsolate();
+  v8::HandleScope handle_scope(isolate);
+  v8::Local<v8::Context> context = info.Holder()->CreationContext();
+  if (!IsContextValid(context))
+    return;
+
+  CHECK(info.Data()->IsExternal());
+  auto* property_data =
+      static_cast<CustomPropertyData*>(info.Data().As<v8::External>()->Value());
+
+  v8::Local<v8::Object> property = property_data->create_custom_type.Run(
+      context, property_data->type_name, property_data->property_name);
+  if (property.IsEmpty())
+    return;
+
+  info.GetReturnValue().Set(property);
+}
+
 void APIBinding::HandleCall(const std::string& name,
                             const APISignature* signature,
                             gin::Arguments* arguments) {
   std::string error;
   v8::Isolate* isolate = arguments->isolate();
   v8::HandleScope handle_scope(isolate);
 
   // Since this is called synchronously from the JS entry point,
   // GetCurrentContext() should always be correct.
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
@@ skipping 52 matching lines @@
   if (invalid_invocation) {
     arguments->ThrowTypeError("Invalid invocation");
     return;
   }
 
   request_handler_->StartRequest(context, name, std::move(converted_arguments),
                                  callback, custom_callback);
 }
 
 }  // namespace extensions