[Extensions Bindings] Add APIBindingsSystem

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 142 matching lines @@
   CHECK(args.GetData(&external));
   auto callback = static_cast<APIBinding::HandlerCallback*>(external->Value());
   callback->Run(&args);
 }
 
 }  // namespace
 
 APIBinding::APIPerContextData::APIPerContextData() {}
 APIBinding::APIPerContextData::~APIPerContextData() {}
 
-APIBinding::APIBinding(const std::string& name,
+APIBinding::APIBinding(const std::string& api_name,
                        const base::ListValue& function_definitions,
                        const base::ListValue& type_definitions,
                        const APIMethodCallback& callback,
                        ArgumentSpec::RefMap* type_refs)
-    : method_callback_(callback), type_refs_(type_refs), weak_factory_(this) {
+    : api_name_(api_name),
+      method_callback_(callback),
+      type_refs_(type_refs),
+      weak_factory_(this) {
   DCHECK(!method_callback_.is_null());
   for (const auto& func : function_definitions) {
     const base::DictionaryValue* func_dict = nullptr;
     CHECK(func->GetAsDictionary(&func_dict));
     std::string name;
     CHECK(func_dict->GetString("name", &name));
     std::unique_ptr<APISignature> spec = GetAPISignature(*func_dict);
     signatures_[name] = std::move(spec);
   }
   for (const auto& type : type_definitions) {
@@ skipping 20 matching lines @@
   DCHECK(per_context_data);
   APIPerContextData* data = static_cast<APIPerContextData*>(
       per_context_data->GetUserData(kExtensionAPIPerContextKey));
   if (!data) {
     auto api_data = base::MakeUnique<APIPerContextData>();
     data = api_data.get();
     per_context_data->SetUserData(kExtensionAPIPerContextKey,
                                   api_data.release());
   }
   for (const auto& sig : signatures_) {
+    std::string full_method_name =
+        base::StringPrintf("%s.%s", api_name_.c_str(), sig.first.c_str());
     auto handler_callback = base::MakeUnique<HandlerCallback>(
         base::Bind(&APIBinding::HandleCall, weak_factory_.GetWeakPtr(),
-                   sig.first, sig.second.get()));
+                   full_method_name, sig.second.get()));
     // TODO(devlin): We should be able to cache these in a function template.
     v8::MaybeLocal<v8::Function> maybe_function =
         v8::Function::New(context, &CallbackHelper,
                           v8::External::New(isolate, handler_callback.get()),
                           0, v8::ConstructorBehavior::kThrow);
     data->context_callbacks.push_back(std::move(handler_callback));
     v8::Maybe<bool> success = object->CreateDataProperty(
         context, gin::StringToSymbol(isolate, sig.first),
         maybe_function.ToLocalChecked());
     DCHECK(success.IsJust());
@@ skipping 26 matching lines @@
     return;
   }
 
   // Since this is called synchronously from the JS entry point,
   // GetCurrentContext() should always be correct.
   method_callback_.Run(name, std::move(parsed_arguments), isolate,
                        isolate->GetCurrentContext(), callback);
 }
 
 }  // namespace extensions