Implement a module system for the extension bindings JS.

chrome/renderer/extensions/extension_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/extension_dispatcher.h"
 
+#include "base/callback.h"
 #include "base/command_line.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/string_piece.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/extension_permission_set.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/chrome_render_process_observer.h"
 #include "chrome/renderer/extensions/app_bindings.h"
 #include "chrome/renderer/extensions/chrome_v8_context.h"
 #include "chrome/renderer/extensions/chrome_v8_extension.h"
 #include "chrome/renderer/extensions/custom_bindings_util.h"
 #include "chrome/renderer/extensions/event_bindings.h"
 #include "chrome/renderer/extensions/extension_groups.h"
 #include "chrome/renderer/extensions/miscellaneous_bindings.h"
 #include "chrome/renderer/extensions/schema_generated_bindings.h"
 #include "chrome/renderer/extensions/user_script_slave.h"
 #include "chrome/renderer/extensions/webstore_bindings.h"
+#include "chrome/renderer/module_system.h"
+#include "chrome/renderer/native_handler.h"
+#include "chrome/renderer/resource_bundle_source_map.h"
 #include "content/public/renderer/render_thread.h"
 #include "grit/renderer_resources.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityPolicy.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
 
+#include "chrome/renderer/extensions/chrome_private_custom_bindings.h"
+#include "chrome/renderer/extensions/context_menus_custom_bindings.h"
+#include "chrome/renderer/extensions/experimental.socket_custom_bindings.h"
+#include "chrome/renderer/extensions/extension_custom_bindings.h"
+#include "chrome/renderer/extensions/file_browser_handler_custom_bindings.h"
+#include "chrome/renderer/extensions/file_browser_private_custom_bindings.h"
+#include "chrome/renderer/extensions/i18n_custom_bindings.h"
+#include "chrome/renderer/extensions/page_actions_custom_bindings.h"
+#include "chrome/renderer/extensions/page_capture_custom_bindings.h"
+#include "chrome/renderer/extensions/tabs_custom_bindings.h"
+#include "chrome/renderer/extensions/tts_custom_bindings.h"
+#include "chrome/renderer/extensions/web_request_custom_bindings.h"
+
 namespace {
 
 static const int64 kInitialExtensionIdleHandlerDelayMs = 5*1000;
 static const int64 kMaxExtensionIdleHandlerDelayMs = 5*60*1000;
 
 ChromeV8Context::ContextType ExtensionGroupToContextType(int extension_group) {
   if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS)
     return ChromeV8Context::CONTENT_SCRIPT;
   return ChromeV8Context::OTHER;
 }
 
+class ChromeHiddenNativeHandler : public NativeHandler {
+ public:
+  ChromeHiddenNativeHandler() {
+    RouteFunction("GetChromeHidden",
+        base::Bind(&ChromeHiddenNativeHandler::GetChromeHidden,
+                   base::Unretained(this)));
+  }
+
+  v8::Handle<v8::Value> GetChromeHidden(const v8::Arguments& args) {
+    return ChromeV8Context::GetOrCreateChromeHidden(v8::Context::GetCurrent());
+  }
+};
+
+class PrintNativeHandler : public NativeHandler {
+ public:
+  PrintNativeHandler() {
+    RouteFunction("Print",
+        base::Bind(&PrintNativeHandler::Print,
+                   base::Unretained(this)));
+  }
+
+  v8::Handle<v8::Value> Print(const v8::Arguments& args) {
+    if (args.Length() < 1)
+      return v8::Undefined();
+
+    std::vector<std::string> components;
+    for (int i = 0; i < args.Length(); ++i)
+      components.push_back(*v8::String::Utf8Value(args[i]->ToString()));
+
+    LOG(ERROR) << JoinString(components, ',');
+    return v8::Undefined();
+  }
+};
+
+class ContextInfoNativeHandler : public NativeHandler {
+ public:
+  explicit ContextInfoNativeHandler(ExtensionDispatcher* extension_dispatcher,
+                                    bool is_bindings_allowed,
+                                    WebKit::WebFrame* frame,
+                                    int world_id)
+      : extension_dispatcher_(extension_dispatcher),
+        is_bindings_allowed_(is_bindings_allowed),
+        frame_(frame),
+        world_id_(world_id) {
+    RouteFunction("IsBindingsAllowed",
+        base::Bind(&ContextInfoNativeHandler::IsBindingsAllowed,
+            base::Unretained(this)));
+    RouteFunction("IsAPIAllowed",
+        base::Bind(&ContextInfoNativeHandler::IsAPIAllowed,
+            base::Unretained(this)));
+  }
+
+  v8::Handle<v8::Value> IsBindingsAllowed(const v8::Arguments& args) {
+    return v8::Boolean::New(is_bindings_allowed_);
+  }
+
+  v8::Handle<v8::Value> IsAPIAllowed(const v8::Arguments& args) {
+    std::string custom_api_name = *v8::String::AsciiValue(args[0]->ToString());
+    return v8::Boolean::New(extension_dispatcher_->AllowCustomAPI(
+        frame_, custom_api_name, world_id_));
+  }
+
+ private:
+  ExtensionDispatcher* extension_dispatcher_;
+  bool is_bindings_allowed_;
+  WebKit::WebFrame* frame_;
+  int world_id_;
+};
+
 }
 
 using namespace extensions;
 
 using WebKit::WebDataSource;
 using WebKit::WebDocument;
 using WebKit::WebFrame;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebString;
 using WebKit::WebVector;
 using WebKit::WebView;
 using content::RenderThread;
 
 ExtensionDispatcher::ExtensionDispatcher()
     : is_webkit_initialized_(false),
       webrequest_adblock_(false),
       webrequest_adblock_plus_(false),
-      webrequest_other_(false) {
+      webrequest_other_(false),
+      source_map_(&ResourceBundle::GetSharedInstance()) {
   const CommandLine& command_line = *(CommandLine::ForCurrentProcess());
   is_extension_process_ =
       command_line.HasSwitch(switches::kExtensionProcess) ||
       command_line.HasSwitch(switches::kSingleProcess);
 
   if (is_extension_process_) {
     RenderThread::Get()->SetIdleNotificationDelayInMs(
         kInitialExtensionIdleHandlerDelayMs);
   }
 
   user_script_slave_.reset(new UserScriptSlave(&extensions_));
+  PopulateSourceMap();
 }
 
 ExtensionDispatcher::~ExtensionDispatcher() {
 }
 
 bool ExtensionDispatcher::OnControlMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ExtensionDispatcher, message)
     IPC_MESSAGE_HANDLER(ExtensionMsg_MessageInvoke, OnMessageInvoke)
@@ skipping 17 matching lines @@
 
 void ExtensionDispatcher::WebKitInitialized() {
   // For extensions, we want to ensure we call the IdleHandler every so often,
   // even if the extension keeps up activity.
   if (is_extension_process_) {
     forced_idle_timer_.Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(kMaxExtensionIdleHandlerDelayMs),
         RenderThread::Get(), &RenderThread::IdleHandler);
   }
 
-  RegisterExtension(new AppBindings(this), false);
-  RegisterExtension(new WebstoreBindings(this), false);
-
-  // Add v8 extensions related to chrome extensions.
-  RegisterExtension(new ChromeV8Extension(
-      "extensions/json_schema.js", IDR_JSON_SCHEMA_JS, NULL), true);
-  RegisterExtension(EventBindings::Get(this), true);
-  RegisterExtension(MiscellaneousBindings::Get(this), true);
-  RegisterExtension(SchemaGeneratedBindings::Get(this), true);
-  RegisterExtension(new ChromeV8Extension(
-      "extensions/apitest.js", IDR_EXTENSION_APITEST_JS, NULL), true);
-
-  std::vector<v8::Extension*> custom_bindings =
-      custom_bindings_util::GetAll(this);
-  for (std::vector<v8::Extension*>::iterator it = custom_bindings.begin();
-      it != custom_bindings.end(); ++it) {
-    RegisterExtension(*it, true);
-  }
-
   // Initialize host permissions for any extensions that were activated before
   // WebKit was initialized.
   for (std::set<std::string>::iterator iter = active_extension_ids_.begin();
        iter != active_extension_ids_.end(); ++iter) {
     const Extension* extension = extensions_.GetByID(*iter);
     if (extension)
       InitOriginPermissions(extension);
   }
 
   is_webkit_initialized_ = true;
@@ skipping 141 matching lines @@
 static int g_hack_extension_group = 0;
 
 }
 
 bool ExtensionDispatcher::AllowScriptExtension(
     WebFrame* frame,
     const std::string& v8_extension_name,
     int extension_group,
     int world_id) {
   g_hack_extension_group = extension_group;
+  return true;
+}
 
-  // NULL in unit tests.
-  if (!RenderThread::Get())
-    return true;
+bool ExtensionDispatcher::AllowCustomAPI(
+    WebFrame* frame,
+    const std::string& custom_binding_api_name,
+    int world_id) {
+  std::string extension_id = GetExtensionID(frame, world_id);
+  const Extension* extension = extensions_.GetByID(extension_id);
+  if (!extension) {
+    // This can happen when a resource is blocked due to CSP; a valid
+    // chrome-extension:// URL is navigated to, so it passes the initial
+    // checks, but the URL gets changed to "chrome-extension://invalid"
+    // afterwards (see chrome_content_renderer_client.cc). An extension
+    // page still gets loaded, just for the extension with ID "invalid",
+    // which of course isn't found so GetById extension will be NULL.
+    //
+    // Reference: http://crbug.com/111614.
+    CHECK_EQ("invalid", extension_id);
+    return false;
+  }
+  return custom_bindings_util::AllowAPIInjection(
+      custom_binding_api_name, *extension, this);
+}
 
-  // If we don't know about it, it was added by WebCore, so we should allow it.
-  if (!RenderThread::Get()->IsRegisteredExtension(v8_extension_name))
-    return true;
+void ExtensionDispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
+                                                 ChromeV8Context* context,
+                                                 bool is_bindings_allowed) {
+  module_system->RegisterNativeHandler("app",
+      scoped_ptr<NativeHandler>(new AppBindings(this, context)));
+  module_system->RegisterNativeHandler("webstore",
+      scoped_ptr<NativeHandler>(new WebstoreBindings(this, context)));
+  module_system->RegisterNativeHandler("event_bindings",
+      scoped_ptr<NativeHandler>(EventBindings::Get(this)));
+  module_system->RegisterNativeHandler("miscellaneous_bindings",
+      scoped_ptr<NativeHandler>(MiscellaneousBindings::Get(this)));
+  module_system->RegisterNativeHandler("schema_generated_bindings",
+      scoped_ptr<NativeHandler>(SchemaGeneratedBindings::Get(this)));
 
-  // If the V8 extension is not restricted, allow it to run anywhere.
-  if (!restricted_v8_extensions_.count(v8_extension_name))
-    return true;
+  // Custom bindings.
+  module_system->RegisterNativeHandler("chrome_private",
+      scoped_ptr<NativeHandler>(
+          new ChromePrivateCustomBindings(this)));
+  module_system->RegisterNativeHandler("context_menus",
+      scoped_ptr<NativeHandler>(new ContextMenusCustomBindings()));
+  module_system->RegisterNativeHandler("extension",
+      scoped_ptr<NativeHandler>(
+          new ExtensionCustomBindings(this)));
+  module_system->RegisterNativeHandler("experimental_socket",
+      scoped_ptr<NativeHandler>(new ExperimentalSocketCustomBindings()));
+  module_system->RegisterNativeHandler("file_browser_handler",
+      scoped_ptr<NativeHandler>(new FileBrowserHandlerCustomBindings()));
+  module_system->RegisterNativeHandler("file_browser_private",
+      scoped_ptr<NativeHandler>(new FileBrowserPrivateCustomBindings()));
+  module_system->RegisterNativeHandler("i18n",
+      scoped_ptr<NativeHandler>(new I18NCustomBindings()));
+  module_system->RegisterNativeHandler("page_actions",
+      scoped_ptr<NativeHandler>(
+          new PageActionsCustomBindings(this)));
+  module_system->RegisterNativeHandler("page_capture",
+      scoped_ptr<NativeHandler>(new PageCaptureCustomBindings()));
+  module_system->RegisterNativeHandler("tabs",
+      scoped_ptr<NativeHandler>(new TabsCustomBindings()));
+  module_system->RegisterNativeHandler("tts",
+      scoped_ptr<NativeHandler>(new TTSCustomBindings()));
+  module_system->RegisterNativeHandler("web_request",
+      scoped_ptr<NativeHandler>(new WebRequestCustomBindings()));
+}
 
-  // Extension-only bindings should be restricted to content scripts and
-  // extension-blessed URLs.
-  ChromeV8Context::ContextType context_type =
-      ExtensionGroupToContextType(extension_group);
+void ExtensionDispatcher::PopulateSourceMap() {
+  source_map_.RegisterSource("app", IDR_APP_BINDINGS_JS);
+  source_map_.RegisterSource("webstore", IDR_WEBSTORE_BINDINGS_JS);
+  source_map_.RegisterSource("event_bindings", IDR_EVENT_BINDINGS_JS);
+  source_map_.RegisterSource("miscellaneous_bindings",
+      IDR_MISCELLANEOUS_BINDINGS_JS);
+  source_map_.RegisterSource("schema_generated_bindings",
+      IDR_SCHEMA_GENERATED_BINDINGS_JS);
+  source_map_.RegisterSource("json_schema", IDR_JSON_SCHEMA_JS);
+  source_map_.RegisterSource("apitest", IDR_EXTENSION_APITEST_JS);
+  source_map_.RegisterSource("setup_bindings", IDR_SETUP_BINDINGS_JS);
 
-  if (context_type == ChromeV8Context::CONTENT_SCRIPT ||
-      extensions_.ExtensionBindingsAllowed(ExtensionURLInfo(
-          frame->document().securityOrigin(),
-          UserScriptSlave::GetDataSourceURLForFrame(frame)))) {
-    // If the extension is a custom API binding, only allow if the extension
-    // has permission to use the API.
-    std::string custom_binding_api_name =
-        custom_bindings_util::GetAPIName(v8_extension_name);
-    if (!custom_binding_api_name.empty()) {
-      std::string extension_id = GetExtensionID(frame, world_id);
-      const Extension* extension = extensions_.GetByID(extension_id);
-      if (!extension) {
-        // This can happen when a resource is blocked due to CSP; a valid
-        // chrome-extension:// URL is navigated to, so it passes the initial
-        // checks, but the URL gets changed to "chrome-extension://invalid"
-        // afterwards (see chrome_content_renderer_client.cc). An extension
-        // page still gets loaded, just for the extension with ID "invalid",
-        // which of course isn't found so GetById extension will be NULL.
-        //
-        // Reference: http://crbug.com/111614.
-        CHECK_EQ("invalid", extension_id);
-        return false;
-      }
-      return custom_bindings_util::AllowAPIInjection(
-          custom_binding_api_name, *extension, this);
-    }
-
-    return true;
-  }
-
-  return false;
+    // Custom bindings.
+  source_map_.RegisterSource("browserAction",
+                             IDR_BROWSER_ACTION_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("chromePrivate",
+                             IDR_CHROME_PRIVATE_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("contentSettings",
+                             IDR_CONTENT_SETTINGS_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("contextMenus",
+                             IDR_CONTEXT_MENUS_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("devtools", IDR_DEVTOOLS_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("experimental.declarative",
+                             IDR_EXPERIMENTAL_DECLARATIVE_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("experimental.socket",
+                             IDR_EXPERIMENTAL_SOCKET_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("extension", IDR_EXTENSION_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("fileBrowserHandler",
+                             IDR_FILE_BROWSER_HANDLER_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("fileBrowserPrivate",
+                             IDR_FILE_BROWSER_PRIVATE_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("i18n", IDR_I18N_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("input.ime", IDR_INPUT_IME_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("omnibox", IDR_OMNIBOX_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("pageActions",
+                             IDR_PAGE_ACTIONS_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("pageAction", IDR_PAGE_ACTION_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("pageCapture",
+                             IDR_PAGE_CAPTURE_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("storage", IDR_STORAGE_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("tabs", IDR_TABS_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("tts", IDR_TTS_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("ttsEngine", IDR_TTS_ENGINE_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("types", IDR_TYPES_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("webRequest", IDR_WEB_REQUEST_CUSTOM_BINDINGS_JS);
+  source_map_.RegisterSource("windows", IDR_WINDOWS_CUSTOM_BINDINGS_JS);
 }
 
 void ExtensionDispatcher::DidCreateScriptContext(
     WebFrame* frame, v8::Handle<v8::Context> v8_context, int extension_group,
     int world_id) {
   // TODO(koz): If the caller didn't pass extension_group, use the last value.
   if (extension_group == -1)
     extension_group = g_hack_extension_group;
   ChromeV8Context* context =
       new ChromeV8Context(
           v8_context,
           frame,
           GetExtensionID(frame, world_id),
           ExtensionGroupToContextType(extension_group));
   v8_context_set_.Add(context);
 
+  bool is_bindings_allowed =
+      context->context_type() == ChromeV8Context::CONTENT_SCRIPT ||
+      extensions_.ExtensionBindingsAllowed(ExtensionURLInfo(
+          frame->document().securityOrigin(),
+          UserScriptSlave::GetDataSourceURLForFrame(frame)));
+
+  scoped_ptr<ModuleSystem> module_system(new ModuleSystem(&source_map_));
+  RegisterNativeHandlers(module_system.get(), context, is_bindings_allowed);
+
+  module_system->RegisterNativeHandler("chrome_hidden",
+      scoped_ptr<NativeHandler>(new ChromeHiddenNativeHandler()));
+  module_system->RegisterNativeHandler("print",
+      scoped_ptr<NativeHandler>(new PrintNativeHandler()));
+  module_system->RegisterNativeHandler("context_info",
+      scoped_ptr<NativeHandler>(new ContextInfoNativeHandler(
+          this,
+          is_bindings_allowed,
+          frame,
+          world_id)));
+
+  context->set_module_system(module_system.Pass());
+
   const Extension* extension = extensions_.GetByID(context->extension_id());
   int manifest_version = 1;
   if (extension)
     manifest_version = extension->manifest_version();
 
+  module_system->Require("setup_bindings");
+
   context->DispatchOnLoadEvent(
       is_extension_process_,
       ChromeRenderProcessObserver::is_incognito_process(),
       manifest_version);
 
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
 }
 
 std::string ExtensionDispatcher::GetExtensionID(WebFrame* frame, int world_id) {
   if (!test_extension_id_.empty()) {
@@ skipping 10 matching lines @@
 }
 
 void ExtensionDispatcher::WillReleaseScriptContext(
     WebFrame* frame, v8::Handle<v8::Context> v8_context, int world_id) {
   ChromeV8Context* context = v8_context_set_.GetByV8Context(v8_context);
   if (!context)
     return;
 
   context->DispatchOnUnloadEvent();
 
-  ChromeV8Extension::InstanceSet extensions = ChromeV8Extension::GetAll();
-  for (ChromeV8Extension::InstanceSet::const_iterator iter = extensions.begin();
-       iter != extensions.end(); ++iter) {
-    (*iter)->ContextWillBeReleased(context);
-  }
-
   v8_context_set_.Remove(context);
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
 }
 
 void ExtensionDispatcher::SetTestExtensionId(const std::string& id) {
   test_extension_id_ = id;
 }
 
 bool ExtensionDispatcher::IsTestExtensionId(const std::string& id) {
   return id == test_extension_id_;
@@ skipping 124 matching lines @@
   webrequest_adblock_ = adblock;
   webrequest_adblock_plus_ = adblock_plus;
   webrequest_other_ = other;
 }
 
 void ExtensionDispatcher::OnShouldClose(const std::string& extension_id,
                                         int sequence_id) {
   RenderThread::Get()->Send(
       new ExtensionHostMsg_ShouldCloseAck(extension_id, sequence_id));
 }