[Extensions Bindings] Add a bridge to use current custom bindings

extensions/renderer/module_system.cc

 // Copyright 2014 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/module_system.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 524 matching lines @@
                                       const std::string& field,
                                       const std::string& module_name,
                                       const std::string& module_field) {
   SetLazyField(object,
                field,
                module_name,
                module_field,
                &ModuleSystem::NativeLazyFieldGetter);
 }
 
+void ModuleSystem::OnNativeBindingCreated(
+    const std::string& api_name,
+    v8::Local<v8::Value> api_bridge_value) {
+  v8::HandleScope scope(GetIsolate());
+  if (source_map_->Contains(api_name)) {
+    NativesEnabledScope enabled(this);
+    LoadModuleWithNativeAPIBridge(api_name, api_bridge_value);
+  }
+}
+
 v8::Local<v8::Value> ModuleSystem::RunString(v8::Local<v8::String> code,
                                              v8::Local<v8::String> name) {
   return context_->RunScript(
       name, code, base::Bind(&ExceptionHandler::HandleUncaughtException,
                              base::Unretained(exception_handler_.get())));
 }
 
 void ModuleSystem::RequireNative(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
@@ skipping 60 matching lines @@
   if (module_registry->available_modules().count(module_name) == 0)
     LoadModule(module_name);
 }
 
 v8::Local<v8::String> ModuleSystem::WrapSource(v8::Local<v8::String> source) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   // Keep in order with the arguments in RequireForJsInner.
   v8::Local<v8::String> left = ToV8StringUnsafe(
       GetIsolate(),
       "(function(define, require, requireNative, requireAsync, exports, "
-      "console, privates,"
+      "console, privates, apiBridge,"
       "$Array, $Function, $JSON, $Object, $RegExp, $String, $Error) {"
       "'use strict';");
   v8::Local<v8::String> right = ToV8StringUnsafe(GetIsolate(), "\n})");
   return handle_scope.Escape(v8::Local<v8::String>(
       v8::String::Concat(left, v8::String::Concat(source, right))));
 }
 
 void ModuleSystem::Private(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_EQ(1, args.Length());
   if (!args[0]->IsObject() || args[0]->IsNull()) {
@@ skipping 17 matching lines @@
     v8::Maybe<bool> maybe =
         privates.As<v8::Object>()->SetPrototype(context()->v8_context(),
                                                 v8::Null(args.GetIsolate()));
     CHECK(maybe.IsJust() && maybe.FromJust());
     SetPrivate(obj, "privates", privates);
   }
   args.GetReturnValue().Set(privates);
 }
 
 v8::Local<v8::Value> ModuleSystem::LoadModule(const std::string& module_name) {
+  return LoadModuleWithNativeAPIBridge(module_name, v8::Local<v8::Value>());

[jbroman, 2016/12/16 19:00:50]

Any reason to pass an empty local here and then override it later on? Could just
put

return LoadModuleWithNativeAPIBridge(module_name, v8::Undefined(GetIsolate()));

here, and then not assume the Local<Value> is non-empty?

[Devlin, 2016/12/16 20:31:17]

Works for me. Done.

+}
+
+v8::Local<v8::Value> ModuleSystem::LoadModuleWithNativeAPIBridge(
+    const std::string& module_name,
+    v8::Local<v8::Value> api_bridge) {
   v8::EscapableHandleScope handle_scope(GetIsolate());
   v8::Local<v8::Context> v8_context = context()->v8_context();
   v8::Context::Scope context_scope(v8_context);
 
   v8::Local<v8::String> source =
       source_map_->GetSource(GetIsolate(), module_name);
   if (source.IsEmpty()) {
     Fatal(context_, "No source for require(" + module_name + ")");
     return v8::Undefined(GetIsolate());
   }
@@ skipping 33 matching lines @@
     NOTREACHED();
     return v8::Undefined(GetIsolate());
   }
 
   exports->DefineOwnProperty(v8_context, v8_key, function, v8::ReadOnly)
       .FromJust();
 
   v8::Local<v8::Object> natives(NewInstance());
   CHECK(!natives.IsEmpty());  // this can fail if v8 has issues
 
+  if (api_bridge.IsEmpty())
+    api_bridge = v8::Undefined(v8_context->GetIsolate());
+
   // These must match the argument order in WrapSource.
   v8::Local<v8::Value> args[] = {
       // AMD.
       GetPropertyUnsafe(v8_context, define_object, "define"),
       // CommonJS.
       GetPropertyUnsafe(v8_context, natives, "require",
                         v8::NewStringType::kInternalized),
       GetPropertyUnsafe(v8_context, natives, "requireNative",
                         v8::NewStringType::kInternalized),
       GetPropertyUnsafe(v8_context, natives, "requireAsync",
                         v8::NewStringType::kInternalized),
       exports,
       // Libraries that we magically expose to every module.
       console::AsV8Object(GetIsolate()),
       GetPropertyUnsafe(v8_context, natives, "privates",
                         v8::NewStringType::kInternalized),
       // Each safe builtin. Keep in order with the arguments in WrapSource.
-      context_->safe_builtins()->GetArray(),
+      api_bridge, context_->safe_builtins()->GetArray(),
       context_->safe_builtins()->GetFunction(),
       context_->safe_builtins()->GetJSON(),
       context_->safe_builtins()->GetObjekt(),
       context_->safe_builtins()->GetRegExp(),
       context_->safe_builtins()->GetString(),
       context_->safe_builtins()->GetError(),
   };
   {
     v8::TryCatch try_catch(GetIsolate());
     try_catch.SetCaptureMessage(true);
@@ skipping 75 matching lines @@
       !value->IsFunction()) {
     Fatal(context_, module_name + "." + method_name + " is not a function");
     return function;
   }
 
   function = v8::Local<v8::Function>::Cast(value);
   return function;
 }
 
 }  // namespace extensions