Convert app_bindings.js to the schema_generated_bindings.js infrastructure.

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/api/extension_api.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/chrome_private_custom_bindings.h"
+#include "chrome/renderer/extensions/context_menus_custom_bindings.h"
 #include "chrome/renderer/extensions/event_bindings.h"
+#include "chrome/renderer/extensions/experimental.socket_custom_bindings.h"
+#include "chrome/renderer/extensions/extension_custom_bindings.h"
 #include "chrome/renderer/extensions/extension_groups.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/miscellaneous_bindings.h"
+#include "chrome/renderer/extensions/page_actions_custom_bindings.h"
+#include "chrome/renderer/extensions/page_capture_custom_bindings.h"
 #include "chrome/renderer/extensions/schema_generated_bindings.h"
+#include "chrome/renderer/extensions/tabs_custom_bindings.h"
+#include "chrome/renderer/extensions/tts_custom_bindings.h"
 #include "chrome/renderer/extensions/user_script_slave.h"
+#include "chrome/renderer/extensions/web_request_custom_bindings.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/WebScopedUserGesture.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityPolicy.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.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/WebScopedUserGesture.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"
-
 using content::RenderThread;
 using extensions::ChromePrivateCustomBindings;
 using extensions::ContextMenusCustomBindings;
 using extensions::ExperimentalSocketCustomBindings;
+using extensions::ExtensionAPI;
 using extensions::ExtensionCustomBindings;
+using extensions::Feature;
 using extensions::FileBrowserHandlerCustomBindings;
 using extensions::FileBrowserPrivateCustomBindings;
 using extensions::I18NCustomBindings;
 using extensions::MiscellaneousBindings;
 using extensions::PageActionsCustomBindings;
 using extensions::PageCaptureCustomBindings;
 using extensions::SchemaGeneratedBindings;
 using extensions::TTSCustomBindings;
 using extensions::TabsCustomBindings;
 using extensions::WebRequestCustomBindings;
 using WebKit::WebDataSource;
 using WebKit::WebDocument;
 using WebKit::WebFrame;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebString;
 using WebKit::WebScopedUserGesture;
 using WebKit::WebVector;
 using WebKit::WebView;
 
-namespace util = extensions::custom_bindings_util;
-
 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());
@@ skipping 14 matching lines @@
 
     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_;
-};
-
 }
 
 ExtensionDispatcher::ExtensionDispatcher()
     : is_webkit_initialized_(false),
       webrequest_adblock_(false),
       webrequest_adblock_plus_(false),
       webrequest_other_(false),
       source_map_(&ResourceBundle::GetSharedInstance()) {
   const CommandLine& command_line = *(CommandLine::ForCurrentProcess());
   is_extension_process_ =
@@ skipping 17 matching lines @@
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ExtensionDispatcher, message)
     IPC_MESSAGE_HANDLER(ExtensionMsg_MessageInvoke, OnMessageInvoke)
     IPC_MESSAGE_HANDLER(ExtensionMsg_DeliverMessage, OnDeliverMessage)
     IPC_MESSAGE_HANDLER(ExtensionMsg_SetFunctionNames, OnSetFunctionNames)
     IPC_MESSAGE_HANDLER(ExtensionMsg_Loaded, OnLoaded)
     IPC_MESSAGE_HANDLER(ExtensionMsg_Unloaded, OnUnloaded)
     IPC_MESSAGE_HANDLER(ExtensionMsg_SetScriptingWhitelist,
                         OnSetScriptingWhitelist)
     IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateExtension, OnActivateExtension)
-    IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateApplication, OnActivateApplication)
     IPC_MESSAGE_HANDLER(ExtensionMsg_UpdatePermissions, OnUpdatePermissions)
     IPC_MESSAGE_HANDLER(ExtensionMsg_UpdateUserScripts, OnUpdateUserScripts)
     IPC_MESSAGE_HANDLER(ExtensionMsg_UsingWebRequestAPI, OnUsingWebRequestAPI)
     IPC_MESSAGE_HANDLER(ExtensionMsg_ShouldClose, OnShouldClose)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
@@ skipping 129 matching lines @@
   // We don't do anything with existing platform-app stylesheets. They will
   // stay resident, but the URL pattern corresponding to the unloaded
   // extension's URL just won't match anything anymore.
 }
 
 void ExtensionDispatcher::OnSetScriptingWhitelist(
     const Extension::ScriptingWhitelist& extension_ids) {
   Extension::SetScriptingWhitelist(extension_ids);
 }
 
-bool ExtensionDispatcher::IsApplicationActive(
-    const std::string& extension_id) const {
-  return active_application_ids_.find(extension_id) !=
-      active_application_ids_.end();
-}
-
 bool ExtensionDispatcher::IsExtensionActive(
     const std::string& extension_id) const {
   return active_extension_ids_.find(extension_id) !=
       active_extension_ids_.end();
 }
 
 bool ExtensionDispatcher::AllowScriptExtension(
     WebFrame* frame,
     const std::string& v8_extension_name,
     int extension_group) {
@@ skipping 14 matching lines @@
 
 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;
 }
 
-bool ExtensionDispatcher::AllowCustomAPI(
-    WebFrame* frame,
-    const std::string& custom_binding_api_name,
-    int world_id) {
-  std::string extension_id = GetExtensionID(frame, world_id);
-  if (IsTestExtensionId(extension_id))
-    return true;
-  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 util::AllowAPIInjection(
-      custom_binding_api_name, *extension, this);
-}
-
 void ExtensionDispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
                                                  ChromeV8Context* context) {
-  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)));
 
   // Custom bindings.
+  module_system->RegisterNativeHandler("app",
+      scoped_ptr<NativeHandler>(new AppBindings(this, context)));
   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()));
@@ skipping 10 matching lines @@
       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()));
 }
 
 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);
 
-    // Custom bindings.
+  // Custom bindings.
+  source_map_.RegisterSource("app", IDR_APP_CUSTOM_BINDINGS_JS);
   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",
@@ skipping 22 matching lines @@
 }
 
 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;
 
   std::string extension_id = GetExtensionID(frame, world_id);
+  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_id,
-          ExtensionGroupToContextType(extension_group));
+      new ChromeV8Context(v8_context, frame, extension_id, context_type);
   v8_context_set_.Add(context);
 
   scoped_ptr<ModuleSystem> module_system(new ModuleSystem(&source_map_));
   RegisterNativeHandlers(module_system.get(), context);
 
-  bool is_bindings_allowed =
-      IsTestExtensionId(extension_id) ||
-      context->context_type() == ChromeV8Context::CONTENT_SCRIPT ||
-      extensions_.ExtensionBindingsAllowed(ExtensionURLInfo(
-          frame->document().securityOrigin(),
-          UserScriptSlave::GetDataSourceURLForFrame(frame)));
-
   module_system->RegisterNativeHandler("chrome_hidden",
       scoped_ptr<NativeHandler>(new ChromeHiddenNativeHandler()));
-  module_system->RegisterNativeHandler("context_info",
-      scoped_ptr<NativeHandler>(new ContextInfoNativeHandler(
-          this,
-          is_bindings_allowed,
-          frame,
-          world_id)));
   module_system->RegisterNativeHandler("print",
       scoped_ptr<NativeHandler>(new PrintNativeHandler()));
 
-  const Extension* extension = extensions_.GetByID(context->extension_id());
   int manifest_version = 1;
+  const Extension* extension = extensions_.GetByID(extension_id);
   if (extension)
     manifest_version = extension->manifest_version();
 
   // Create the 'chrome' variable if it doesn't already exist.
   {
     v8::HandleScope handle_scope;
     v8::Handle<v8::String> chrome_string(v8::String::New("chrome"));
     v8::Handle<v8::Object> global(v8::Context::GetCurrent()->Global());
     if (global->Get(chrome_string)->IsUndefined())
       global->Set(chrome_string, v8::Object::New());
   }
-  module_system->Require("app");
+
+  if (context_type != Feature::WEB_PAGE_CONTEXT) {
+    module_system->Require("json_schema");
+    module_system->Require("event_bindings");
+    module_system->Require("miscellaneous_bindings");
+    module_system->Require("schema_generated_bindings");
+    module_system->Require("apitest");
+  }

[not at google - send to devlin, 2012/03/20 03:32:13]

This is what setup_bindings.js used to do.

+
+  // TODO(kalman): include this in the APIs returned from GetAPIsForContext.
   module_system->Require("webstore");
-  if (is_bindings_allowed) {
-    module_system->Require("setup_bindings");
+
+  scoped_ptr<std::set<std::string> > apis =
+      ExtensionAPI::GetInstance()->GetAPIsForContext(
+          context_type, extension, url_info.url());
+  for (std::set<std::string>::iterator i = apis->begin(); i != apis->end();
+      ++i) {
+    module_system->Require(*i);
   }

[not at google - send to devlin, 2012/03/20 03:32:13]

So this is now the crux of the change. For performance reasons we can't load
schema_generated_bindings in every web page, so we still use the handwritten
app.js (now called... app_custom_bindings.js).

However, at least now we get things like: declarative/sensible integration with
the permissions system, fewer special cases, a nice abstraction for running APIs
in web pages, and the possibility (when we reconcile the performance
consequences) of fully converting app.js later.

+
   module_system->set_natives_enabled(false);
 
   context->set_module_system(module_system.Pass());
 
   context->DispatchOnLoadEvent(
       is_extension_process_,
       ChromeRenderProcessObserver::is_incognito_process(),
       manifest_version);
 
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
@@ skipping 19 matching lines @@
   if (!context)
     return;
 
   context->DispatchOnUnloadEvent();
 
   v8_context_set_.Remove(context);
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
 }
 
 void ExtensionDispatcher::SetTestExtensionId(const std::string& id) {
+  CHECK(!id.empty());
   test_extension_id_ = id;
 }
 
 bool ExtensionDispatcher::IsTestExtensionId(const std::string& id) {
   return !test_extension_id_.empty() && id == test_extension_id_;
 }
 
-void ExtensionDispatcher::OnActivateApplication(
-    const std::string& extension_id) {
-  active_application_ids_.insert(extension_id);
-}
-
 void ExtensionDispatcher::OnActivateExtension(
     const std::string& extension_id) {
   active_extension_ids_.insert(extension_id);
 
   // This is called when starting a new extension page, so start the idle
   // handler ticking.
   RenderThread::Get()->ScheduleIdleHandler(kInitialExtensionIdleHandlerDelayMs);
 
   UpdateActiveExtensions();
 
@@ skipping 107 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));
 }
+
+Feature::Context ExtensionDispatcher::ClassifyJavaScriptContext(
+    const std::string& extension_id,
+    int extension_group,
+    const ExtensionURLInfo& url_info) {
+  if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS)
+    return Feature::CONTENT_SCRIPT_CONTEXT;
+
+  if (IsExtensionActive(extension_id))
+    return Feature::PRIVILEGED_CONTEXT;
+
+  if (extensions_.ExtensionBindingsAllowed(url_info))
+    return Feature::UNPRIVILEGED_CONTEXT;
+
+  if (url_info.url().is_valid())
+    return Feature::WEB_PAGE_CONTEXT;
+
+  return Feature::UNSPECIFIED_CONTEXT;
+}