[Extensions] Convert more callers of CallModuleMethod

extensions/renderer/module_system.h

 // 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.
 
 #ifndef EXTENSIONS_RENDERER_MODULE_SYSTEM_H_
 #define EXTENSIONS_RENDERER_MODULE_SYSTEM_H_
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "extensions/renderer/native_handler.h"
 #include "extensions/renderer/object_backed_native_handler.h"
+#include "extensions/renderer/script_injection_callback.h"
 #include "gin/modules/module_registry_observer.h"
 #include "v8/include/v8.h"
 
 namespace extensions {
 
 class ScriptContext;
 
 // A module system for JS similar to node.js' require() function.
 // Each module has three variables in the global scope:
 //   - exports, an object returned to dependencies who require() this
@@ skipping 57 matching lines @@
 
   // Run |code| in the current context with the name |name| used for stack
   // traces.
   v8::Local<v8::Value> RunString(v8::Local<v8::String> code,
                                  v8::Local<v8::String> name);
 
   // Calls the specified method exported by the specified module. This is
   // equivalent to calling require('module_name').method_name() from JS.
   // DEPRECATED: see crbug.com/629431
   // TODO(devlin): Remove these.
-  v8::Local<v8::Value> CallModuleMethod(
-      const std::string& module_name,
-      const std::string& method_name);
   v8::Local<v8::Value> CallModuleMethod(const std::string& module_name,
                                         const std::string& method_name,
                                         int argc,
                                         v8::Local<v8::Value> argv[]);
 
   // Same as the above, but allows for blocking execution.
   void CallModuleMethodSafe(const std::string& module_name,
                             const std::string& method_name);
   void CallModuleMethodSafe(const std::string& module_name,
                             const std::string& method_name,
                             std::vector<v8::Local<v8::Value>>* args);
   void CallModuleMethodSafe(const std::string& module_name,
                             const std::string& method_name,
                             int argc,
                             v8::Local<v8::Value> argv[]);
+  void CallModuleMethodSafe(
+      const std::string& module_name,
+      const std::string& method_name,
+      int argc,
+      v8::Local<v8::Value> argv[],
+      const ScriptInjectionCallback::CompleteCallback& callback);
 
   // Register |native_handler| as a potential target for requireNative(), so
   // calls to requireNative(|name|) from JS will return a new object created by
   // |native_handler|.
   void RegisterNativeHandler(const std::string& name,
                              std::unique_ptr<NativeHandler> native_handler);
 
   // Causes requireNative(|name|) to look for its module in |source_map_|
   // instead of using a registered native handler. This can be used in unit
   // tests to mock out native modules.
@@ skipping 136 matching lines @@
   std::vector<std::unique_ptr<NativeHandler>> clobbered_native_handlers_;
 
   base::WeakPtrFactory<ModuleSystem> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ModuleSystem);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_RENDERER_MODULE_SYSTEM_H_