Make miscellaneous_bindings and event_bindings Required as needed. Previously

chrome/renderer/extensions/dispatcher.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/dispatcher.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
+#include "base/values.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/api/extension_api.h"
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/features/base_feature_provider.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/manifest.h"
@@ skipping 67 matching lines @@
 using WebKit::WebView;
 using content::RenderThread;
 using content::RenderView;
 
 namespace extensions {
 
 namespace {
 
 static const int64 kInitialExtensionIdleHandlerDelayMs = 5*1000;
 static const int64 kMaxExtensionIdleHandlerDelayMs = 5*60*1000;
-static const char kEventDispatchFunction[] = "Event.dispatchEvent";
+static const char kEventModule[] = "event_bindings";
+static const char kEventDispatchFunction[] = "dispatchEvent";
 static const char kOnSuspendEvent[] = "runtime.onSuspend";
 static const char kOnSuspendCanceledEvent[] = "runtime.onSuspendCanceled";
 
 static v8::Handle<v8::Object> GetOrCreateChrome(
     v8::Handle<v8::Context> context) {
   v8::Handle<v8::String> chrome_string(v8::String::New("chrome"));
   v8::Handle<v8::Object> global(context->Global());
   v8::Handle<v8::Value> chrome(global->Get(chrome_string));
   if (chrome.IsEmpty() || chrome->IsUndefined()) {
     v8::Handle<v8::Object> chrome_object(v8::Object::New());
@@ skipping 208 matching lines @@
                    base::Unretained(this)));
     RouteFunction("InIncognitoContext",
         base::Bind(&ProcessInfoNativeHandler::InIncognitoContext,
                    base::Unretained(this)));
     RouteFunction("GetManifestVersion",
         base::Bind(&ProcessInfoNativeHandler::GetManifestVersion,
                    base::Unretained(this)));
     RouteFunction("IsSendRequestDisabled",
         base::Bind(&ProcessInfoNativeHandler::IsSendRequestDisabled,
                    base::Unretained(this)));
+    RouteFunction("Log",
+        base::Bind(&ProcessInfoNativeHandler::Log, base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> GetExtensionId(const v8::Arguments& args) {
     return v8::String::New(extension_id_.c_str());
   }
 
   v8::Handle<v8::Value> GetContextType(const v8::Arguments& args) {
     return v8::String::New(context_type_.c_str());
   }
 
   v8::Handle<v8::Value> InIncognitoContext(const v8::Arguments& args) {
     return v8::Boolean::New(is_incognito_context_);
   }
 
   v8::Handle<v8::Value> GetManifestVersion(const v8::Arguments& args) {
     return v8::Integer::New(manifest_version_);
   }
 
   v8::Handle<v8::Value> IsSendRequestDisabled(const v8::Arguments& args) {
     if (send_request_disabled_) {
       return v8::String::New(
           "sendRequest and onRequest are obsolete."
           " Please use sendMessage and onMessage instead.");
     }
     return v8::Undefined();
   }
 
+  v8::Handle<v8::Value> Log(const v8::Arguments& args) {
+    LOG(WARNING) << *v8::String::AsciiValue(args[0]);
+    return v8::Undefined();
+  }
+
  private:
   std::string extension_id_;
   std::string context_type_;
   bool is_incognito_context_;
   int manifest_version_;
   bool send_request_disabled_;
 };
 
 class LoggingNativeHandler : public ObjectBackedNativeHandler {
  public:
   explicit LoggingNativeHandler(v8::Handle<v8::Context> context)
       : ObjectBackedNativeHandler(context) {
     RouteFunction("DCHECK",
         base::Bind(&LoggingNativeHandler::Dcheck, base::Unretained(this)));
     RouteFunction("CHECK",
         base::Bind(&LoggingNativeHandler::Check, base::Unretained(this)));
+    RouteFunction("DCHECK_IS_ON",
+        base::Bind(&LoggingNativeHandler::DcheckIsOn, base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> Check(const v8::Arguments& args) {
     bool check_value;
     std::string error_message;
     ParseArgs(args, &check_value, &error_message);
     CHECK(check_value) << error_message;
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> Dcheck(const v8::Arguments& args) {
     bool check_value;
     std::string error_message;
     ParseArgs(args, &check_value, &error_message);
     DCHECK(check_value) << error_message;
     return v8::Undefined();
   }
 
+  v8::Handle<v8::Value> DcheckIsOn(const v8::Arguments& args) {
+    return v8::Boolean::New(DCHECK_IS_ON());
+  }
+
  private:
   void ParseArgs(const v8::Arguments& args,
                  bool* check_value,
                  std::string* error_message) {
     CHECK_LE(args.Length(), 2);
     *check_value = args[0]->BooleanValue();
     if (args.Length() == 2)
       *error_message = "Error: " + std::string(
           *v8::String::AsciiValue(args[1]));
 
@@ skipping 20 matching lines @@
       return dflt;
     std::string ascii_value = *v8::String::AsciiValue(v8_string);
     return ascii_value.empty() ? dflt : ascii_value;
   }
 };
 
 void InstallAppBindings(ModuleSystem* module_system,
                         v8::Handle<v8::Object> chrome,
                         v8::Handle<v8::Object> chrome_hidden) {
   module_system->SetLazyField(chrome, "app", "app", "chromeApp");
-  module_system->SetLazyField(chrome_hidden, "app", "app",
-                              "chromeHiddenApp");
 }
 
 void InstallWebstoreBindings(ModuleSystem* module_system,
                              v8::Handle<v8::Object> chrome,
                              v8::Handle<v8::Object> chrome_hidden) {
   module_system->SetLazyField(chrome, "webstore", "webstore", "chromeWebstore");
   module_system->SetLazyField(chrome_hidden, "webstore", "webstore",
                               "chromeHiddenWebstore");
 }
 
@@ skipping 99 matching lines @@
   for (size_t i = 0; i < names.size(); ++i)
     function_names_.insert(names[i]);
 }
 
 void Dispatcher::OnSetChannel(int channel) {
   Feature::SetCurrentChannel(
       static_cast<chrome::VersionInfo::Channel>(channel));
 }
 
 void Dispatcher::OnMessageInvoke(const std::string& extension_id,
+                                 const std::string& module_name,
                                  const std::string& function_name,
                                  const base::ListValue& args,
                                  bool user_gesture) {
   scoped_ptr<WebScopedUserGesture> web_user_gesture;
   if (user_gesture) {
     web_user_gesture.reset(new WebScopedUserGesture);
   }
 
-  v8_context_set_.DispatchChromeHiddenMethod(
-      extension_id, function_name, args, NULL);
+  v8_context_set_.ForEach(
+      extension_id,
+      NULL,
+      base::Bind(&CallModuleMethod, module_name, function_name, &args));
 
   // Reset the idle handler each time there's any activity like event or message
   // dispatch, for which Invoke is the chokepoint.
   if (is_extension_process_) {
     RenderThread::Get()->ScheduleIdleHandler(
         kInitialExtensionIdleHandlerDelayMs);
   }
 
   // Tell the browser process when an event has been dispatched with a lazy
   // background page active.
   const Extension* extension = extensions_.GetByID(extension_id);
   if (extension && BackgroundInfo::HasLazyBackgroundPage(extension) &&
+      module_name == kEventModule &&
       function_name == kEventDispatchFunction) {
     RenderView* background_view =
         ExtensionHelper::GetBackgroundPage(extension_id);
     if (background_view) {
       background_view->Send(new ExtensionHostMsg_EventAck(
           background_view->GetRoutingID()));
     }
   }
 }
 
 void Dispatcher::OnDispatchOnConnect(
     int target_port_id,
     const std::string& channel_name,
     const base::DictionaryValue& source_tab,
     const ExtensionMsg_ExternalConnectionInfo& info) {
   MiscellaneousBindings::DispatchOnConnect(
       v8_context_set_.GetAll(),
       target_port_id, channel_name, source_tab,
       info.source_id, info.target_id, info.source_url,
       NULL);  // All render views.
 }
 
 void Dispatcher::OnDeliverMessage(int target_port_id,
-                                  const std::string& message) {
+                                  const base::ListValue& message) {
   MiscellaneousBindings::DeliverMessage(
       v8_context_set_.GetAll(),
       target_port_id,
       message,
       NULL);  // All render views.
 }
 
 void Dispatcher::OnDispatchOnDisconnect(int port_id,
                                         const std::string& error_message) {
   MiscellaneousBindings::DispatchOnDisconnect(
@@ skipping 175 matching lines @@
                                   api_name,
                                   "binding");
     }
   }
 }
 
 void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
                                         ChromeV8Context* context) {
   v8::Handle<v8::Context> v8_context = context->v8_context();
 
-  module_system->RegisterNativeHandler("event_bindings",
+  module_system->RegisterNativeHandler("event_natives",
       scoped_ptr<NativeHandler>(EventBindings::Create(this, v8_context)));
-  module_system->RegisterNativeHandler("miscellaneous_bindings",
+  module_system->RegisterNativeHandler("miscellaneous_bindings_natives",
       scoped_ptr<NativeHandler>(MiscellaneousBindings::Get(this, v8_context)));
   module_system->RegisterNativeHandler("apiDefinitions",
       scoped_ptr<NativeHandler>(new ApiDefinitionsNatives(this, context)));
   module_system->RegisterNativeHandler("sendRequest",
       scoped_ptr<NativeHandler>(
           new SendRequestNatives(this, request_sender_.get(), context)));
   module_system->RegisterNativeHandler("setIcon",
       scoped_ptr<NativeHandler>(
           new SetIconNatives(this, request_sender_.get(), context)));
   module_system->RegisterNativeHandler(
       "contentWatcherNative",
       content_watcher_->MakeNatives(v8_context));
   module_system->RegisterNativeHandler("activityLogger",
       scoped_ptr<NativeHandler>(new APIActivityLogger(this, v8_context)));
 
   // Natives used by multiple APIs.
   module_system->RegisterNativeHandler("file_system_natives",
       scoped_ptr<NativeHandler>(new FileSystemNatives(v8_context)));
 
   // Custom bindings.
   module_system->RegisterNativeHandler("app",
       scoped_ptr<NativeHandler>(new AppBindings(this, context)));
   module_system->RegisterNativeHandler("app_runtime",
       scoped_ptr<NativeHandler>(
           new AppRuntimeCustomBindings(this, v8_context)));
-  module_system->RegisterNativeHandler("app_window",
+  module_system->RegisterNativeHandler("app_window_natives",
       scoped_ptr<NativeHandler>(
           new AppWindowCustomBindings(this, v8_context)));
   module_system->RegisterNativeHandler("context_menus",
       scoped_ptr<NativeHandler>(
           new ContextMenusCustomBindings(this, v8_context)));
   module_system->RegisterNativeHandler("extension",
       scoped_ptr<NativeHandler>(
           new ExtensionCustomBindings(this, v8_context)));
   module_system->RegisterNativeHandler("sync_file_system",
       scoped_ptr<NativeHandler>(
@@ skipping 23 matching lines @@
   module_system->RegisterNativeHandler("tts",
       scoped_ptr<NativeHandler>(new TTSCustomBindings(this, v8_context)));
   module_system->RegisterNativeHandler("web_request",
       scoped_ptr<NativeHandler>(
           new WebRequestCustomBindings(this, v8_context)));
   module_system->RegisterNativeHandler("webstore",
       scoped_ptr<NativeHandler>(new WebstoreBindings(this, context)));
 }
 
 void Dispatcher::PopulateSourceMap() {
-  source_map_.RegisterSource("event_bindings", IDR_EVENT_BINDINGS_JS);
-  source_map_.RegisterSource("miscellaneous_bindings",
-      IDR_MISCELLANEOUS_BINDINGS_JS);
+  // Libraries.
+  source_map_.RegisterSource("contentWatcher", IDR_CONTENT_WATCHER_JS);
+  source_map_.RegisterSource("entryIdManager", IDR_ENTRY_ID_MANAGER);
+  source_map_.RegisterSource(kEventModule, IDR_EVENT_BINDINGS_JS);
+  source_map_.RegisterSource("imageUtil", IDR_IMAGE_UTIL_JS);
   source_map_.RegisterSource("json", IDR_JSON_JS);
   source_map_.RegisterSource("json_schema", IDR_JSON_SCHEMA_JS);
-  source_map_.RegisterSource("test", IDR_TEST_CUSTOM_BINDINGS_JS);
-
-  // Libraries.
-  source_map_.RegisterSource("contentWatcher", IDR_CONTENT_WATCHER_JS);
-  source_map_.RegisterSource("imageUtil", IDR_IMAGE_UTIL_JS);
   source_map_.RegisterSource("lastError", IDR_LAST_ERROR_JS);
+  source_map_.RegisterSource("miscellaneous_bindings",
+                             IDR_MISCELLANEOUS_BINDINGS_JS);
+  source_map_.RegisterSource("on_unload", IDR_ON_UNLOAD_JS);
   source_map_.RegisterSource("schemaUtils", IDR_SCHEMA_UTILS_JS);
   source_map_.RegisterSource("sendRequest", IDR_SEND_REQUEST_JS);
   source_map_.RegisterSource("setIcon", IDR_SET_ICON_JS);
+  source_map_.RegisterSource("test", IDR_TEST_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("utils", IDR_UTILS_JS);
-  source_map_.RegisterSource("entryIdManager", IDR_ENTRY_ID_MANAGER);
 
   // Custom bindings.
   source_map_.RegisterSource("app", IDR_APP_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("app.runtime", IDR_APP_RUNTIME_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("app.window", IDR_APP_WINDOW_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("bluetooth", IDR_BLUETOOTH_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("browserAction",
                              IDR_BROWSER_ACTION_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("contextMenus",
                              IDR_CONTEXT_MENUS_CUSTOM_BINDINGS_JS);
@@ skipping 119 matching lines @@
   ExtensionURLInfo url_info(frame->document().securityOrigin(),
       UserScriptSlave::GetDataSourceURLForFrame(frame));
 
   Feature::Context context_type =
       ClassifyJavaScriptContext(extension_id, extension_group, url_info);
 
   ChromeV8Context* context =
       new ChromeV8Context(v8_context, frame, extension, context_type);
   v8_context_set_.Add(context);
 
-  scoped_ptr<ModuleSystem> module_system(new ModuleSystem(v8_context,
-                                                          &source_map_));
+  scoped_ptr<ModuleSystem> module_system(
+      new ModuleSystem(context, &source_map_));
   // Enable natives in startup.
   ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system.get());
 
   RegisterNativeHandlers(module_system.get(), context);
 
   module_system->RegisterNativeHandler("chrome",
       scoped_ptr<NativeHandler>(new ChromeNativeHandler(v8_context)));
   module_system->RegisterNativeHandler("chrome_hidden",
       scoped_ptr<NativeHandler>(new ChromeHiddenNativeHandler(v8_context)));
   module_system->RegisterNativeHandler("print",
@@ skipping 29 matching lines @@
   switch (context_type) {
     case Feature::UNSPECIFIED_CONTEXT:
     case Feature::WEB_PAGE_CONTEXT:
       // TODO(kalman): see comment below about ExtensionAPI.
       InstallBindings(module_system.get(), v8_context, "app");
       InstallBindings(module_system.get(), v8_context, "webstore");
       break;
     case Feature::BLESSED_EXTENSION_CONTEXT:
     case Feature::UNBLESSED_EXTENSION_CONTEXT:
     case Feature::CONTENT_SCRIPT_CONTEXT:
-      if (extension && !extension->is_platform_app())
-        module_system->Require("miscellaneous_bindings");
       module_system->Require("json");  // see paranoid comment in json.js
 
       // TODO(kalman): move this code back out of the switch and execute it
       // regardless of |context_type|. ExtensionAPI knows how to return the
       // correct APIs, however, until it doesn't have a 2MB overhead we can't
       // load it in every process.
       RegisterSchemaGeneratedBindings(module_system.get(), context);
       break;
   }
 
@@ skipping 266 matching lines @@
 
 void Dispatcher::OnSuspend(const std::string& extension_id) {
   // Dispatch the suspend event. This doesn't go through the standard event
   // dispatch machinery because it requires special handling. We need to let
   // the browser know when we are starting and stopping the event dispatch, so
   // that it still considers the extension idle despite any activity the suspend
   // event creates.
   base::ListValue args;
   args.Set(0, new base::StringValue(kOnSuspendEvent));
   args.Set(1, new base::ListValue());
-  v8_context_set_.DispatchChromeHiddenMethod(
-      extension_id, kEventDispatchFunction, args, NULL);
-
+  v8_context_set_.ForEach(
+      extension_id,
+      NULL,
+      base::Bind(&CallModuleMethod,
+                 kEventModule,
+                 kEventDispatchFunction,
+                 &args));
   RenderThread::Get()->Send(new ExtensionHostMsg_SuspendAck(extension_id));
 }
 
 void Dispatcher::OnCancelSuspend(const std::string& extension_id) {
   base::ListValue args;
   args.Set(0, new base::StringValue(kOnSuspendCanceledEvent));
   args.Set(1, new base::ListValue());
-  v8_context_set_.DispatchChromeHiddenMethod(
-      extension_id, kEventDispatchFunction, args, NULL);
+  v8_context_set_.ForEach(
+      extension_id,
+      NULL,
+      base::Bind(&CallModuleMethod,
+                 kEventModule,
+                 kEventDispatchFunction,
+                 &args));
 }
 
 Feature::Context Dispatcher::ClassifyJavaScriptContext(
     const std::string& extension_id,
     int extension_group,
     const ExtensionURLInfo& url_info) {
   if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS) {
     return extensions_.Contains(extension_id) ?
         Feature::CONTENT_SCRIPT_CONTEXT : Feature::UNSPECIFIED_CONTEXT;
   }
@@ skipping 75 matching lines @@
         "%s cannot be used within a sandboxed frame.";
     std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
     v8::ThrowException(
         v8::Exception::Error(v8::String::New(error_msg.c_str())));
     return false;
   }
 
   return true;
 }
 
+// static
+void Dispatcher::CallModuleMethod(const std::string& module_name,
+                                  const std::string& method_name,
+                                  const base::ListValue* args,
+                                  ChromeV8Context* context) {
+  v8::HandleScope handle_scope;
+  v8::Context::Scope context_scope(context->v8_context());
+
+  scoped_ptr<content::V8ValueConverter> converter(
+      content::V8ValueConverter::create());
+
+  std::vector<v8::Handle<v8::Value> > arguments;
+  for (base::ListValue::const_iterator it = args->begin(); it != args->end();
+       ++it) {
+    arguments.push_back(converter->ToV8Value(*it, context->v8_context()));
+  }
+
+  context->module_system()->CallModuleMethod(
+      module_name, method_name, &arguments);
+}
+
 }  // namespace extensions