[Extensions] Convert more callers of CallModuleMethod

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 266 matching lines @@
       !exports->IsUndefined())
     return handle_scope.Escape(exports);
 
   exports = LoadModule(*v8::String::Utf8Value(module_name));
   SetPrivateProperty(v8_context, modules, module_name, exports);
   return handle_scope.Escape(exports);
 }
 
 v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
     const std::string& module_name,
-    const std::string& method_name) {
-  v8::EscapableHandleScope handle_scope(GetIsolate());
-  v8::Local<v8::Value> no_args;
-  return handle_scope.Escape(
-      CallModuleMethod(module_name, method_name, 0, &no_args));
-}
-
-v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
-    const std::string& module_name,
     const std::string& method_name,
     int argc,
     v8::Local<v8::Value> argv[]) {
   TRACE_EVENT2("v8",
                "v8.callModuleMethod",
                "module_name",
                module_name,
                "method_name",
                method_name);
 
@@ skipping 18 matching lines @@
       result = v8::Undefined(GetIsolate());
     }
   }
   return handle_scope.Escape(result);
 }
 
 void ModuleSystem::CallModuleMethodSafe(const std::string& module_name,
                                         const std::string& method_name) {
   v8::HandleScope handle_scope(GetIsolate());
   v8::Local<v8::Value> no_args;
-  CallModuleMethodSafe(module_name, method_name, 0, &no_args);
+  CallModuleMethodSafe(module_name, method_name, 0, &no_args,
+                       ScriptInjectionCallback::CompleteCallback());
 }
 
 void ModuleSystem::CallModuleMethodSafe(
     const std::string& module_name,
     const std::string& method_name,
     std::vector<v8::Local<v8::Value>>* args) {
-  CallModuleMethodSafe(module_name, method_name, args->size(), args->data());
+  CallModuleMethodSafe(module_name, method_name, args->size(), args->data(),
+                       ScriptInjectionCallback::CompleteCallback());
 }
 
 void ModuleSystem::CallModuleMethodSafe(const std::string& module_name,
                                         const std::string& method_name,
                                         int argc,
                                         v8::Local<v8::Value> argv[]) {
+  CallModuleMethodSafe(module_name, method_name, argc, argv,
+                       ScriptInjectionCallback::CompleteCallback());
+}
+
+void ModuleSystem::CallModuleMethodSafe(
+    const std::string& module_name,
+    const std::string& method_name,
+    int argc,
+    v8::Local<v8::Value> argv[],
+    const ScriptInjectionCallback::CompleteCallback& callback) {
   TRACE_EVENT2("v8", "v8.callModuleMethodSafe", "module_name", module_name,
                "method_name", method_name);
 
   v8::HandleScope handle_scope(GetIsolate());
   v8::Local<v8::Context> v8_context = context()->v8_context();
   v8::Context::Scope context_scope(v8_context);
 
   v8::Local<v8::Function> function =
       GetModuleFunction(module_name, method_name);
   if (function.IsEmpty()) {
     NOTREACHED() << "GetModuleFunction() returns empty function handle";
     return;
   }
 
   {
     v8::TryCatch try_catch(GetIsolate());
     try_catch.SetCaptureMessage(true);
-    context_->SafeCallFunction(function, argc, argv);
+    context_->SafeCallFunction(function, argc, argv, callback);
     if (try_catch.HasCaught())
       HandleException(try_catch);
   }
 }
 
 void ModuleSystem::RegisterNativeHandler(
     const std::string& name,
     std::unique_ptr<NativeHandler> native_handler) {
   ClobberExistingNativeHandler(name);
   native_handler_map_[name] = std::move(native_handler);
@@ skipping 447 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