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 "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;
 }
@@ skipping 56 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 143 matching lines @@
 // This is what the extension_group variable will be when DidCreateScriptContext
 // is called. We know because it's the same as what AllowScriptExtension gets
 // passed, and the two functions are called sequentially from WebKit.
 //
 // TODO(koz): Plumb extension_group through to AllowScriptExtension() from
 // WebKit.
 static int hack_DidCreateScriptContext_extension_group = 0;
 
 }
 
 bool ExtensionDispatcher::AllowScriptExtension(

[Aaron Boodman, 2012/02/28 02:42:59]

Can't this entire method and all related code be deleted now? We aren't use v8
extensions anymore.

[koz (OOO until 15th September), 2012/03/01 03:41:56]

Yes, it can. I've removed the custom binding permission check out into a
different function which is now invoked from the JS. Though this may be
redundant (because SGB::GetExtensionAPIDefinition() should only return apis that
are permitted in the calling context), it's isomorphic to what the code does
now.

     WebFrame* frame,
     const std::string& v8_extension_name,
     int extension_group,
     int world_id) {
   hack_DidCreateScriptContext_extension_group = extension_group;
 
   // NULL in unit tests.
   if (!RenderThread::Get())
     return true;
 
@@ skipping 36 matching lines @@
       return custom_bindings_util::AllowAPIInjection(
           custom_binding_api_name, *extension, context_type);
     }
 
     return true;
   }
 
   return false;
 }
 
+base::StringPiece GetResource(int resource_id) {
+  return ResourceBundle::GetSharedInstance().GetRawDataResource(resource_id);
+}
+
+std::map<std::string, base::StringPiece>* GetOrCreateSourceMap() {
+  static std::map<std::string, base::StringPiece>* source_map = NULL;

[Aaron Boodman, 2012/02/28 02:42:59]

Sadly, we do not static non-pod types in Chrome. You have to use LazyInstance
instead. Search the codebase for examples.

Alternately, I believe only one instance of ExtensionDispatcher gets created
per-process. In that case, there is really no need for this to be static.
source_map could just be an instance member.

[koz (OOO until 15th September), 2012/03/01 03:41:56]

I've made it an instance member.

+  if (source_map == NULL) {
+    source_map = new std::map<std::string, base::StringPiece>();
+    (*source_map)["app"] = GetResource(IDR_APP_BINDINGS_JS);
+    (*source_map)["webstore"] = GetResource(IDR_WEBSTORE_BINDINGS_JS);
+    (*source_map)["event_bindings"] = GetResource(IDR_EVENT_BINDINGS_JS);
+    (*source_map)["miscellaneous_bindings"] =
+        GetResource(IDR_MISCELLANEOUS_BINDINGS_JS);
+    (*source_map)["schema_generated_bindings"] =
+        GetResource(IDR_SCHEMA_GENERATED_BINDINGS_JS);
+    (*source_map)["json_schema"] = GetResource(IDR_JSON_SCHEMA_JS);
+    (*source_map)["apitest"] = GetResource(IDR_EXTENSION_APITEST_JS);
+    (*source_map)["setup_bindings"] = GetResource(IDR_SETUP_BINDINGS_JS);
+
+    // Custom bindings.
+    (*source_map)["browserAction"] =
+        GetResource(IDR_BROWSER_ACTION_CUSTOM_BINDINGS_JS);
+    (*source_map)["chromePrivate"] =
+        GetResource(IDR_CHROME_PRIVATE_CUSTOM_BINDINGS_JS);
+    (*source_map)["contentSettings"] =
+        GetResource(IDR_CONTENT_SETTINGS_CUSTOM_BINDINGS_JS);
+    (*source_map)["contextMenus"] =
+        GetResource(IDR_CONTEXT_MENUS_CUSTOM_BINDINGS_JS);
+    (*source_map)["devtools"] = GetResource(IDR_DEVTOOLS_CUSTOM_BINDINGS_JS);
+    (*source_map)["experimental.declarative"] =
+        GetResource(IDR_EXPERIMENTAL_DECLARATIVE_CUSTOM_BINDINGS_JS);
+    (*source_map)["experimental.socket"] =
+        GetResource(IDR_EXPERIMENTAL_SOCKET_CUSTOM_BINDINGS_JS);
+    (*source_map)["extension"] = GetResource(IDR_EXTENSION_CUSTOM_BINDINGS_JS);
+    (*source_map)["fileBrowserHandler"] =
+        GetResource(IDR_FILE_BROWSER_HANDLER_CUSTOM_BINDINGS_JS);
+    (*source_map)["fileBrowserPrivate"] =
+        GetResource(IDR_FILE_BROWSER_PRIVATE_CUSTOM_BINDINGS_JS);
+    (*source_map)["i18n"] = GetResource(IDR_I18N_CUSTOM_BINDINGS_JS);
+    (*source_map)["input.ime"] = GetResource(IDR_INPUT_IME_CUSTOM_BINDINGS_JS);
+    (*source_map)["omnibox"] = GetResource(IDR_OMNIBOX_CUSTOM_BINDINGS_JS);
+    (*source_map)["pageActions"] =
+        GetResource(IDR_PAGE_ACTIONS_CUSTOM_BINDINGS_JS);
+    (*source_map)["pageAction"] =
+        GetResource(IDR_PAGE_ACTION_CUSTOM_BINDINGS_JS);
+    (*source_map)["pageCapture"] =
+        GetResource(IDR_PAGE_CAPTURE_CUSTOM_BINDINGS_JS);
+    (*source_map)["storage"] = GetResource(IDR_STORAGE_CUSTOM_BINDINGS_JS);
+    (*source_map)["tabs"] = GetResource(IDR_TABS_CUSTOM_BINDINGS_JS);
+    (*source_map)["tts"] = GetResource(IDR_TTS_CUSTOM_BINDINGS_JS);
+    (*source_map)["ttsEngine"] =
+        GetResource(IDR_TTS_ENGINE_CUSTOM_BINDINGS_JS);
+    (*source_map)["types"] = GetResource(IDR_TYPES_CUSTOM_BINDINGS_JS);
+    (*source_map)["webRequest"] =
+        GetResource(IDR_WEB_REQUEST_CUSTOM_BINDINGS_JS);
+    (*source_map)["windows"] = GetResource(IDR_WINDOWS_CUSTOM_BINDINGS_JS);
+  }
+
+  return source_map;
+}
+
+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(bool is_bindings_allowed)
+      : is_bindings_allowed_(is_bindings_allowed) {
+    RouteFunction("IsBindingsAllowed",
+        base::Bind(&ContextInfoNativeHandler::IsBindingsAllowed,
+            base::Unretained(this)));
+  }
+
+  v8::Handle<v8::Value> IsBindingsAllowed(const v8::Arguments& args) {
+    return v8::Boolean::New(is_bindings_allowed_);
+  }
+
+ private:
+  bool is_bindings_allowed_;
+};
+
+void ExtensionDispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
+                                                 ChromeV8Context* context,
+                                                 bool is_bindings_allowed) {
+  module_system->RegisterNativeHandler("app",
+    scoped_ptr<NativeHandler>(new AppBindings(this, context)));

[Matt Perry, 2012/02/28 20:34:20]

+2 indent

[Matt Perry, 2012/02/28 20:34:20]

fyi: make_scoped_ptr(new X) looks nicer

[koz (OOO until 15th September), 2012/03/01 03:41:56]

Done.

[koz (OOO until 15th September), 2012/03/01 03:41:56]

I think it doesn't work here because we need to upcast the arguments.

+  module_system->RegisterNativeHandler("webstore",
+      scoped_ptr<NativeHandler>(new WebstoreBindings(this, context)));
+  module_system->RegisterNativeHandler("event_bindings",
+    scoped_ptr<NativeHandler>(EventBindings::Get(this)));

[Matt Perry, 2012/02/28 20:34:20]

+2 indent

[koz (OOO until 15th September), 2012/03/01 03:41:56]

Done.

+  module_system->RegisterNativeHandler("miscellaneous_bindings",
+      scoped_ptr<NativeHandler>(MiscellaneousBindings::Get(this)));
+  module_system->RegisterNativeHandler("schema_generated_bindings",
+      scoped_ptr<NativeHandler>(SchemaGeneratedBindings::Get(this)));
+
+  // 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()));
+
+  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(
+          is_bindings_allowed)));
+}
+
 void ExtensionDispatcher::DidCreateScriptContext(
     WebFrame* frame, v8::Handle<v8::Context> v8_context, int world_id) {
   ChromeV8Context* context =
       new ChromeV8Context(
           v8_context,
           frame,
           GetExtensionID(frame, world_id),
           ExtensionGroupToContextType(
               hack_DidCreateScriptContext_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)));
+
+  ModuleSystem* module_system = new ModuleSystem(GetOrCreateSourceMap());
+  RegisterNativeHandlers(module_system, context, is_bindings_allowed);
+
+  context->set_module_system(scoped_ptr<ModuleSystem>(module_system));

[Matt Perry, 2012/02/28 20:34:20]

Why is there one module system per context, rather than one shared one per
process? Looks like every module system is the same.

[koz (OOO until 15th September), 2012/03/01 03:41:56]

ModuleSystem injects JS into a particular context and holds on to that context's
require() function, so it can be called through Require(), so ModuleSystem is
tied to the context it is created in. The code that ModuleSystems inject (the
source map) is shared between them.

Also, having each ModuleSystem be separate means that NativeHandlers are scoped
to each context, rather than being static, which means we can migrate away from
static methods in bindings classes towards member functions.

+
+
   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;
 }
 
 void ExtensionDispatcher::OnActivateApplication(
     const std::string& extension_id) {
@@ skipping 114 matching lines @@
 
   RenderThread::Get()->RegisterExtension(extension);
 }
 
 void ExtensionDispatcher::OnUsingWebRequestAPI(
     bool adblock, bool adblock_plus, bool other) {
   webrequest_adblock_ = adblock;
   webrequest_adblock_plus_ = adblock_plus;
   webrequest_other_ = other;
 }