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/command_line.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/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 "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"
 
 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;
-}
-
 }
 
 using namespace extensions;
 
 using WebKit::WebDataSource;
 using WebKit::WebDocument;
 using WebKit::WebFrame;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebString;
 using WebKit::WebVector;
@@ skipping 26 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_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 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);
+  // Unrestricted extension-related v8-extensions.
+  RegisterExtension(EventBindings::Get(this), false);
+  RegisterExtension(SchemaGeneratedBindings::Get(this), false);
+  RegisterExtension(new ChromeV8Extension(
+      "extensions/json_schema.js", IDR_JSON_SCHEMA_JS, NULL), false);
+  // TODO(kalman): move this to the custom_bindings infrastructure.
   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);
+  // Permissions-checked extension-related v8-extensions.
   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);
   }
 
@@ skipping 122 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 24 matching lines @@
     return true;
 
   // 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;
 
   // If the V8 extension is not restricted, allow it to run anywhere.
   if (!restricted_v8_extensions_.count(v8_extension_name))
     return true;
 
-  // Extension-only bindings should be restricted to content scripts and
-  // extension-blessed URLs.
   ChromeV8Context::ContextType context_type =
-      ExtensionGroupToContextType(extension_group);
+      GetContextType(extension_group, frame);
 
-  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;
+  std::string custom_binding_api_name =

[Aaron Boodman, 2012/02/29 01:03:58]

If you make the change I suggested in schema_generated_bindings.cc, would it be
possible to replace this code with a call to ExtensionAPI?

return ExtensionAPI::GetInstance()->IsModuleAvailable(ContextType, Extension,
GURL)

[not at google - send to devlin, 2012/03/05 07:46:54]

Done... kinda.

I consolidated all the logic in ExtensionAPI, and this all became a lot simpler
after koz's change.

The only method that deals with any of this is now
ExtensionAPI::GetAvailableAPIs. It's up to the callers to do what they want with
this. IsModuleAvailable is implemented as GetAvailableAPIs().count(api).

+      custom_bindings_util::GetAPIName(v8_extension_name);
+  if (!custom_binding_api_name.empty()) {
+    switch (context_type) {
+      case ChromeV8Context::PRIVILEGED:
+      case ChromeV8Context::CONTENT_SCRIPT:
+      case ChromeV8Context::UNPRIVILEGED: {
+        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, context_type);
       }
-      return custom_bindings_util::AllowAPIInjection(
-          custom_binding_api_name, *extension, this);
+
+      case ChromeV8Context::WEB_PAGE:
+        return ExtensionAPI::GetInstance()->MatchesURL(
+            custom_binding_api_name,
+            UserScriptSlave::GetDataSourceURLForFrame(frame));
     }
-
-    return true;
   }
 
-  return false;
+  return context_type != ChromeV8Context::WEB_PAGE;
 }
 
 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));
+          GetContextType(hack_DidCreateScriptContext_extension_group, frame));
   v8_context_set_.Add(context);
 
   const Extension* extension = extensions_.GetByID(context->extension_id());
   int manifest_version = 1;
   if (extension)
     manifest_version = extension->manifest_version();
 
   context->DispatchOnLoadEvent(
       is_extension_process_,
       ChromeRenderProcessObserver::is_incognito_process(),
@@ skipping 35 matching lines @@
 }
 
 void ExtensionDispatcher::SetTestExtensionId(const std::string& id) {
   test_extension_id_ = id;
 }
 
 bool ExtensionDispatcher::IsTestExtensionId(const std::string& id) {
   return 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 101 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;
 }
+
+ChromeV8Context::ContextType ExtensionDispatcher::GetContextType(

[Aaron Boodman, 2012/02/29 01:03:58]

Naming suggestion: ClassifyJavaScriptContext ?

[not at google - send to devlin, 2012/03/05 07:46:54]

Done.

+    int extension_group, WebFrame* frame) {
+  if (extension_group == EXTENSION_GROUP_CONTENT_SCRIPTS)
+    return ChromeV8Context::CONTENT_SCRIPT;
+
+  ExtensionURLInfo url_info(frame->document().securityOrigin(),
+      UserScriptSlave::GetDataSourceURLForFrame(frame));
+
+  const Extension* extension = extensions_.GetExtensionOrAppByURL(url_info);
+  if (extension && IsExtensionActive(extension->id()))
+    return ChromeV8Context::PRIVILEGED;
+
+  if (extensions_.ExtensionBindingsAllowed(url_info))
+    return ChromeV8Context::UNPRIVILEGED;
+
+  return ChromeV8Context::WEB_PAGE;
+}