[Extensions Bindings] Add support for custom property types

extensions/renderer/api_bindings_system.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_bindings_system.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "extensions/renderer/api_binding_hooks.h"
@@ skipping 52 matching lines @@
   auto iter = binding_hooks_.find(api_name);
   if (iter != binding_hooks_.end()) {
     hooks = std::move(iter->second);
     binding_hooks_.erase(iter);
   } else {
     hooks = base::MakeUnique<APIBindingHooks>(call_js_sync_);
   }
 
   return base::MakeUnique<APIBinding>(
       api_name, function_definitions, type_definitions, event_definitions,
-      property_definitions, std::move(hooks), &type_reference_map_,
-      &request_handler_, &event_handler_);
+      property_definitions,
+      base::Bind(&APIBindingsSystem::CreateCustomType, base::Unretained(this)),
+      std::move(hooks), &type_reference_map_, &request_handler_,
+      &event_handler_);
 }
 
 void APIBindingsSystem::InitializeType(const std::string& type_name) {
   // In order to initialize the type, we just initialize the full binding. This
   // seems like a lot of work, but in practice, trying to extract out only the
   // types from the schema, and then update the reference map based on that, is
   // close enough to the same cost. Additionally, this happens lazily on API
   // use, and relatively few APIs specify types from another API. Finally, this
   // will also go away if/when we generate all these specifications.
   std::string::size_type dot = type_name.rfind('.');
@@ skipping 23 matching lines @@
 APIBindingHooks* APIBindingsSystem::GetHooksForAPI(
     const std::string& api_name) {
   DCHECK(api_bindings_.empty())
       << "Hook registration must happen before creating any binding instances.";
   std::unique_ptr<APIBindingHooks>& hooks = binding_hooks_[api_name];
   if (!hooks)
     hooks = base::MakeUnique<APIBindingHooks>(call_js_sync_);
   return hooks.get();
 }
 
+void APIBindingsSystem::RegisterCustomType(const std::string& type_name,
+                                           const CustomTypeHandler& function) {
+  DCHECK(custom_types_.find(type_name) == custom_types_.end())
+      << "Custom type already registered: " << type_name;
+  custom_types_[type_name] = function;
+}
+
+v8::Local<v8::Object> APIBindingsSystem::CreateCustomType(
+    v8::Local<v8::Context> context,
+    const std::string& type_name,
+    const std::string& property_name) {
+  auto iter = custom_types_.find(type_name);
+  DCHECK(iter != custom_types_.end()) << "Custom type not found: " << type_name;
+  return iter->second.Run(context, property_name, &request_handler_,
+                          &type_reference_map_);
+}
+
 }  // namespace extensions