Make ExtensionMsg_MessageInvoke run a module system function rather than a

chrome/renderer/extensions/module_system.cc

 // Copyright (c) 2012 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 "chrome/renderer/extensions/module_system.h"
 
 #include "base/bind.h"
+#include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "chrome/renderer/extensions/console.h"
 #include "content/public/renderer/render_view.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScopedMicrotaskSuppression.h"
 
 namespace extensions {
 
 namespace {
 
 const char* kModuleSystem = "module_system";
 const char* kModuleName = "module_name";
 const char* kModuleField = "module_field";
 const char* kModulesField = "modules";
 
-// Formats |try_catch| as a nice string.
-std::string CreateExceptionString(const v8::TryCatch& try_catch) {
+// Default exception handler which logs the exception.
+class DefaultExceptionHandler : public ModuleSystem::ExceptionHandler {
+ public:
+  // Fatally dumps the debug info from |try_catch| to the console.
+  // Make sure this is never used for exceptions that originate in external
+  // code!
+  virtual void HandleUncaughtException(const v8::TryCatch& try_catch) OVERRIDE {
+    v8::HandleScope handle_scope;
+    std::string stack_trace = "<stack trace unavailable>";
+    if (!try_catch.StackTrace().IsEmpty()) {
+      v8::String::Utf8Value stack_value(try_catch.StackTrace());
+      if (*stack_value)
+        stack_trace.assign(*stack_value, stack_value.length());
+      else
+        stack_trace = "<could not convert stack trace to string>";
+    }
+    console::Fatal(v8::Context::GetCalling(),
+                   CreateExceptionString(try_catch) + "{" + stack_trace + "}");
+  }
+};
+
+} // namespace
+
+std::string ModuleSystem::ExceptionHandler::CreateExceptionString(
+    const v8::TryCatch& try_catch) {
   v8::Handle<v8::Message> message(try_catch.Message());
   if (message.IsEmpty()) {
     return "try_catch has no message";
   }
 
   std::string resource_name = "<unknown resource>";
   if (!message->GetScriptResourceName().IsEmpty()) {
     v8::String::Utf8Value resource_name_v8(
         message->GetScriptResourceName()->ToString());
     resource_name.assign(*resource_name_v8, resource_name_v8.length());
   }
 
   std::string error_message = "<no error message>";
   if (!message->Get().IsEmpty()) {
     v8::String::Utf8Value error_message_v8(message->Get());
     error_message.assign(*error_message_v8, error_message_v8.length());
   }
 
   return base::StringPrintf("%s:%d: %s",
                             resource_name.c_str(),
                             message->GetLineNumber(),
                             error_message.c_str());
 }
 
-// Fatally dumps the debug info from |try_catch| to the console.
-// Don't use this for logging exceptions that might originate in external code!
-void DumpException(const v8::TryCatch& try_catch) {
-  v8::HandleScope handle_scope;
-
-  std::string stack_trace = "<stack trace unavailable>";
-  if (!try_catch.StackTrace().IsEmpty()) {
-    v8::String::Utf8Value stack_value(try_catch.StackTrace());
-    if (*stack_value)
-      stack_trace.assign(*stack_value, stack_value.length());
-    else
-      stack_trace = "<could not convert stack trace to string>";
-  }
-
-  console::Fatal(v8::Context::GetCalling(),
-                 CreateExceptionString(try_catch) + "{" + stack_trace + "}");
-}
-
-} // namespace
-
 ModuleSystem::ModuleSystem(ChromeV8Context* context,
                            SourceMap* source_map)
     : ObjectBackedNativeHandler(context),
+      context_(context),
       source_map_(source_map),
-      natives_enabled_(0) {
+      natives_enabled_(0),
+      exception_handler_(new DefaultExceptionHandler()) {
   RouteFunction("require",
       base::Bind(&ModuleSystem::RequireForJs, base::Unretained(this)));
   RouteFunction("requireNative",
       base::Bind(&ModuleSystem::RequireNative, base::Unretained(this)));
 
   v8::Handle<v8::Object> global(context->v8_context()->Global());
   global->SetHiddenValue(v8::String::New(kModulesField), v8::Object::New());
   global->SetHiddenValue(v8::String::New(kModuleSystem),
                          v8::External::New(this));
 }
@@ skipping 29 matching lines @@
     : module_system_(module_system) {
   module_system_->natives_enabled_++;
 }
 
 ModuleSystem::NativesEnabledScope::~NativesEnabledScope() {
   module_system_->natives_enabled_--;
   CHECK_GE(module_system_->natives_enabled_, 0);
 }
 
 void ModuleSystem::HandleException(const v8::TryCatch& try_catch) {
-  if (exception_handler_)
-    exception_handler_->HandleUncaughtException();
-  else
-    DumpException(try_catch);
+  exception_handler_->HandleUncaughtException(try_catch);
 }
 
 v8::Handle<v8::Value> ModuleSystem::Require(const std::string& module_name) {
   v8::HandleScope handle_scope;
   return handle_scope.Close(
       RequireForJsInner(v8::String::New(module_name.c_str())));
 }
 
 v8::Handle<v8::Value> ModuleSystem::RequireForJs(const v8::Arguments& args) {
   v8::HandleScope handle_scope;
@@ skipping 43 matching lines @@
   v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(func_as_value);
 
   exports = v8::Object::New();
   v8::Handle<v8::Object> natives(NewInstance());
   v8::Handle<v8::Value> args[] = {
     natives->Get(v8::String::NewSymbol("require")),
     natives->Get(v8::String::NewSymbol("requireNative")),
     exports,
   };
   {
-    WebKit::WebScopedMicrotaskSuppression suppression;
     v8::TryCatch try_catch;
     try_catch.SetCaptureMessage(true);
-    func->Call(global, 3, args);
+    context_->CallFunction(func, arraysize(args), args);
     if (try_catch.HasCaught()) {
       HandleException(try_catch);
       return v8::Undefined();
     }
   }
   modules->Set(module_name, exports);
   return handle_scope.Close(exports);
 }
 
 v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
     const std::string& module_name,
     const std::string& method_name) {
-  std::vector<v8::Handle<v8::Value> > args;
-  return CallModuleMethod(module_name, method_name, &args);
+  v8::HandleScope handle_scope;
+  v8::Handle<v8::Value> no_args;
+  return CallModuleMethod(module_name, method_name, 0, &no_args);
 }
 
 v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
     const std::string& module_name,
     const std::string& method_name,
     std::vector<v8::Handle<v8::Value> >* args) {
+  return CallModuleMethod(
+      module_name, method_name, args->size(), vector_as_array(args));
+}
+
+v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
+    const std::string& module_name,
+    const std::string& method_name,
+    int argc,
+    v8::Handle<v8::Value> argv[]) {
+  TRACE_EVENT2("v8", "v8.callModuleMethod",
+               "module_name", module_name,
+               "method_name", method_name);
+
   v8::HandleScope handle_scope;
-  v8::Local<v8::Value> module =
-      v8::Local<v8::Value>::New(
-          RequireForJsInner(v8::String::New(module_name.c_str())));
+  v8::Context::Scope context_scope(context()->v8_context());
+
+  v8::Local<v8::Value> module;
+  {
+    NativesEnabledScope natives_enabled(this);
+    module = v8::Local<v8::Value>::New(
+        RequireForJsInner(v8::String::New(module_name.c_str())));
+  }
+
   if (module.IsEmpty() || !module->IsObject()) {
     console::Error(
         v8::Context::GetCalling(),
         "Failed to get module " + module_name + " to call " + method_name);
     return handle_scope.Close(v8::Undefined());
   }
 
   v8::Local<v8::Value> value =
       v8::Handle<v8::Object>::Cast(module)->Get(
           v8::String::New(method_name.c_str()));
   if (value.IsEmpty() || !value->IsFunction()) {
     console::Error(v8::Context::GetCalling(),
                    module_name + "." + method_name + " is not a function");
     return handle_scope.Close(v8::Undefined());
   }
 
-  v8::Handle<v8::Function> func =
-      v8::Handle<v8::Function>::Cast(value);
-  v8::Handle<v8::Object> global(context()->v8_context()->Global());
+  v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value);
   v8::Local<v8::Value> result;
   {
-    WebKit::WebScopedMicrotaskSuppression suppression;
     v8::TryCatch try_catch;
     try_catch.SetCaptureMessage(true);
-    result = func->Call(global, args->size(), vector_as_array(args));
+    result = context_->CallFunction(func, argc, argv);
     if (try_catch.HasCaught())
       HandleException(try_catch);
   }
   return handle_scope.Close(result);
 }
 
 void ModuleSystem::RegisterNativeHandler(const std::string& name,
     scoped_ptr<NativeHandler> native_handler) {
   native_handler_map_[name] =
       linked_ptr<NativeHandler>(native_handler.release());
@@ skipping 125 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);
 }
 
 v8::Handle<v8::Value> ModuleSystem::RunString(v8::Handle<v8::String> code,
                                               v8::Handle<v8::String> name) {
   v8::HandleScope handle_scope;
+  v8::Context::Scope context_scope(context()->v8_context());
 
   WebKit::WebScopedMicrotaskSuppression suppression;
   v8::TryCatch try_catch;
   try_catch.SetCaptureMessage(true);
   v8::Handle<v8::Script> script(v8::Script::New(code, name));
   if (try_catch.HasCaught()) {
     HandleException(try_catch);
     return v8::Undefined();
   }
 
@@ skipping 48 matching lines @@
 v8::Handle<v8::String> ModuleSystem::WrapSource(v8::Handle<v8::String> source) {
   v8::HandleScope handle_scope;
   v8::Handle<v8::String> left = v8::String::New(
       "(function(require, requireNative, exports) {'use strict';");
   v8::Handle<v8::String> right = v8::String::New("\n})");
   return handle_scope.Close(
       v8::String::Concat(left, v8::String::Concat(source, right)));
 }
 
 }  // extensions