[Extensions Bindings] Add support for custom property types

extensions/renderer/api_binding_unittest.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 "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "extensions/renderer/api_binding.h"
@@ skipping 156 matching lines @@
   void SetProperties(const char* properties) {
     binding_properties_ = DictionaryValueFromString(properties);
     ASSERT_TRUE(binding_properties_);
   }
 
   void SetHooks(std::unique_ptr<APIBindingHooks> hooks) {
     binding_hooks_ = std::move(hooks);
     ASSERT_TRUE(binding_hooks_);
   }
 
+  void SetCreateCustomType(const APIBinding::CreateCustomType& callback) {
+    create_custom_type_ = callback;
+  }
+
   void InitializeBinding() {
     if (!binding_hooks_) {
       binding_hooks_ =
           base::MakeUnique<APIBindingHooks>(binding::RunJSFunctionSync());
     }
     event_handler_ = base::MakeUnique<APIEventHandler>(
         base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
         base::Bind(&OnEventListenersChanged));
     binding_ = base::MakeUnique<APIBinding>(
         "test", binding_functions_.get(), binding_types_.get(),
-        binding_events_.get(), binding_properties_.get(),
+        binding_events_.get(), binding_properties_.get(), create_custom_type_,
         std::move(binding_hooks_), &type_refs_, request_handler_.get(),
         event_handler_.get());
     EXPECT_EQ(!binding_types_.get(), type_refs_.empty());
   }
 
   void ExpectPass(v8::Local<v8::Object> object,
                   const std::string& script_source,
                   const std::string& expected_json_arguments_single_quotes,
                   bool expect_callback) {
     ExpectPass(ContextLocal(), object, script_source,
@@ skipping 40 matching lines @@
   std::unique_ptr<APIBinding> binding_;
   std::unique_ptr<APIEventHandler> event_handler_;
   std::unique_ptr<APIRequestHandler> request_handler_;
   APITypeReferenceMap type_refs_;
 
   std::unique_ptr<base::ListValue> binding_functions_;
   std::unique_ptr<base::ListValue> binding_events_;
   std::unique_ptr<base::ListValue> binding_types_;
   std::unique_ptr<base::DictionaryValue> binding_properties_;
   std::unique_ptr<APIBindingHooks> binding_hooks_;
+  APIBinding::CreateCustomType create_custom_type_;
 
   DISALLOW_COPY_AND_ASSIGN(APIBindingUnittest);
 };
 
 void APIBindingUnittest::RunTest(v8::Local<v8::Context> context,
                                  v8::Local<v8::Object> object,
                                  const std::string& script_source,
                                  bool should_pass,
                                  const std::string& expected_json_arguments,
                                  bool expect_callback,
@@ skipping 299 matching lines @@
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
   v8::Local<v8::Object> binding_object =
       binding()->CreateInstance(context, isolate(), base::Bind(&AllowAllAPIs));
   EXPECT_EQ("17",
             GetStringPropertyFromObject(binding_object, context, "prop1"));
   EXPECT_EQ(R"({"subprop1":"some value","subprop2":true})",
             GetStringPropertyFromObject(binding_object, context, "prop2"));
 }
 
+TEST_F(APIBindingUnittest, TestRefProperties) {
+  SetProperties(
+      "{"
+      "  'alpha': {"
+      "    '$ref': 'AlphaRef'"
+      "  },"
+      "  'beta': {"
+      "    '$ref': 'BetaRef'"
+      "  }"
+      "}");
+  auto create_custom_type = [](v8::Local<v8::Context> context,
+                               const std::string& type_name,
+                               const std::string& property_name) {
+    v8::Isolate* isolate = context->GetIsolate();
+    v8::Local<v8::Object> result = v8::Object::New(isolate);
+    if (type_name == "AlphaRef") {
+      EXPECT_EQ("alpha", property_name);
+      result
+          ->Set(context, gin::StringToSymbol(isolate, "alphaProp"),
+                gin::StringToV8(isolate, "alphaVal"))
+          .ToChecked();
+    } else if (type_name == "BetaRef") {
+      EXPECT_EQ("beta", property_name);
+      result
+          ->Set(context, gin::StringToSymbol(isolate, "betaProp"),
+                gin::StringToV8(isolate, "betaVal"))
+          .ToChecked();
+    } else {
+      EXPECT_TRUE(false) << type_name;
+    }
+    return result;
+  };
+
+  SetCreateCustomType(base::Bind(create_custom_type));
+
+  InitializeBinding();
+
+  v8::HandleScope handle_scope(isolate());
+  v8::Local<v8::Context> context = ContextLocal();
+  v8::Local<v8::Object> binding_object =
+      binding()->CreateInstance(context, isolate(), base::Bind(&AllowAllAPIs));
+  EXPECT_EQ(R"({"alphaProp":"alphaVal"})",
+            GetStringPropertyFromObject(binding_object, context, "alpha"));
+  EXPECT_EQ(
+      R"({"betaProp":"betaVal"})",
+      GetStringPropertyFromObject(binding_object, context, "beta"));
+}
+
 TEST_F(APIBindingUnittest, TestDisposedContext) {
   SetFunctions(kFunctions);
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = ContextLocal();
 
   v8::Local<v8::Object> binding_object =
       binding()->CreateInstance(context, isolate(), base::Bind(&AllowAllAPIs));
 
@@ skipping 468 matching lines @@
 
   blink::WebScopedUserGesture user_gesture(nullptr);
   RunFunction(function, context, arraysize(argv), argv);
   ASSERT_TRUE(last_request());
   EXPECT_TRUE(last_request()->has_user_gesture);
 
   reset_last_request();
 }
 
 }  // namespace extensions