Reland r57788 - Expose Extension Bindings to Component Applications

chrome/renderer/extensions/extension_process_bindings.cc

 // Copyright (c) 2010 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_process_bindings.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/scoped_ptr.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/render_messages_params.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/extensions/bindings_utils.h"
 #include "chrome/renderer/extensions/event_bindings.h"
+#include "chrome/renderer/extensions/extension_renderer_info.h"
 #include "chrome/renderer/extensions/js_only_v8_extensions.h"
 #include "chrome/renderer/extensions/renderer_extension_bindings.h"
 #include "chrome/renderer/user_script_slave.h"
 #include "chrome/renderer/render_thread.h"
 #include "chrome/renderer/render_view.h"
 #include "chrome/renderer/render_view_visitor.h"
 #include "grit/common_resources.h"
 #include "grit/renderer_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 13 matching lines @@
 using bindings_utils::ExtensionBase;
 using WebKit::WebFrame;
 using WebKit::WebSecurityPolicy;
 using WebKit::WebView;
 
 namespace {
 
 // A map of extension ID to vector of page action ids.
 typedef std::map< std::string, std::vector<std::string> > PageActionIdMap;
 
-// A map of permission name to whether its enabled for this extension.
-typedef std::map<std::string, bool> PermissionsMap;
+// A list of permissions that are enabled for this extension.
+typedef std::vector<std::string> PermissionsList;
 
 // A map of extension ID to permissions map.
-typedef std::map<std::string, PermissionsMap> ExtensionPermissionsMap;
+typedef std::map<std::string, PermissionsList> ExtensionPermissionsList;
 
 // A map of extension ID to whether this extension was enabled in incognito.
 typedef std::map<std::string, bool> IncognitoEnabledMap;
 
 const char kExtensionName[] = "chrome/ExtensionProcessBindings";
 const char* kExtensionDeps[] = {
   BaseJsV8Extension::kName,
   EventBindings::kName,
   JsonSchemaJsV8Extension::kName,
   RendererExtensionBindings::kName,
   ExtensionApiTestV8Extension::kName,
 };
 
-// A list of the API packages which have no associated permission.
-// TODO(erikkay) It might be nice if for consistency we could merge these with
-// the permissions list, or at least have them in one place.
-const char* kNonPermissionExtensionPackages[] = {
-  "extension",
-  // TODO(erikkay): We're inconsistent about the the package name in the events
-  // for pageAction and browserAction.
-  "pageAction",
-  "pageActions",
-  "browserAction",
-  "browserActions",
-  "i18n",
-  "devtools",
-  "test"
-};
-
 struct SingletonData {
   std::set<std::string> function_names_;
   PageActionIdMap page_action_ids_;
-  ExtensionPermissionsMap permissions_;
+  ExtensionPermissionsList permissions_;
   IncognitoEnabledMap incognito_enabled_map_;
 };
 
 static std::set<std::string>* GetFunctionNameSet() {
   return &Singleton<SingletonData>()->function_names_;
 }
 
 static PageActionIdMap* GetPageActionMap() {
   return &Singleton<SingletonData>()->page_action_ids_;
 }
 
-static PermissionsMap* GetPermissionsMap(const std::string& extension_id) {
+static PermissionsList* GetPermissionsList(const std::string& extension_id) {
   return &Singleton<SingletonData>()->permissions_[extension_id];
 }
 
 static IncognitoEnabledMap* GetIncognitoEnabledMap() {
   return &Singleton<SingletonData>()->incognito_enabled_map_;
 }
 
 static void GetActiveExtensionIDs(std::set<std::string>* extension_ids) {
-  ExtensionPermissionsMap& permissions =
+  ExtensionPermissionsList& permissions =
       Singleton<SingletonData>()->permissions_;
 
-  for (ExtensionPermissionsMap::iterator iter = permissions.begin();
+  for (ExtensionPermissionsList::iterator iter = permissions.begin();
        iter != permissions.end(); ++iter) {
     extension_ids->insert(iter->first);
   }
 }
 
 // A RenderViewVisitor class that iterates through the set of available
 // views, looking for a view of the given type, in the given browser window
 // and within the given extension.
 // Used to accumulate the list of views associated with an extension.
 class ExtensionViewAccumulator : public RenderViewVisitor {
@@ skipping 96 matching lines @@
 
   // Note: do not call this function before or during the chromeHidden.onLoad
   // event dispatch. The URL might not have been committed yet and might not
   // be an extension URL.
   static std::string ExtensionIdForCurrentContext() {
     RenderView* renderview = bindings_utils::GetRenderViewForCurrentContext();
     if (!renderview)
       return std::string();  // this can happen as a tab is closing.
 
     GURL url = renderview->webview()->mainFrame()->url();
-    if (!url.SchemeIs(chrome::kExtensionScheme))
+    if (!ExtensionRendererInfo::ExtensionBindingsAllowed(url))
       return std::string();
 
-    return url.host();
+    return ExtensionRendererInfo::GetIdByURL(url);
   }
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) {
     if (name->Equals(v8::String::New("GetExtensionAPIDefinition"))) {
       return v8::FunctionTemplate::New(GetExtensionAPIDefinition);
     } else if (name->Equals(v8::String::New("GetExtensionViews"))) {
       return v8::FunctionTemplate::New(GetExtensionViews);
     } else if (name->Equals(v8::String::New("GetNextRequestId"))) {
       return v8::FunctionTemplate::New(GetNextRequestId);
@@ skipping 383 matching lines @@
   } else {
     if (page_action_map.find(extension_id) != page_action_map.end())
       page_action_map.erase(extension_id);
   }
 }
 
 // static
 void ExtensionProcessBindings::SetAPIPermissions(
     const std::string& extension_id,
     const std::vector<std::string>& permissions) {
-  PermissionsMap& permissions_map = *GetPermissionsMap(extension_id);
-
-  // Default all the API permissions to off. We will reset them below.
-  for (size_t i = 0; i < Extension::kNumPermissions; ++i)
-    permissions_map[Extension::kPermissionNames[i]] = false;
-  for (size_t i = 0; i < permissions.size(); ++i)
-    permissions_map[permissions[i]] = true;
+  PermissionsList& permissions_list = *GetPermissionsList(extension_id);
+  permissions_list.assign(permissions.begin(), permissions.end());
 }
 
 // static
 void ExtensionProcessBindings::SetHostPermissions(
     const GURL& extension_url,
     const std::vector<URLPattern>& permissions) {
   for (size_t i = 0; i < permissions.size(); ++i) {
     const char* schemes[] = {
       chrome::kHttpScheme,
       chrome::kHttpsScheme,
@@ skipping 24 matching lines @@
                                              const std::string& permission) {
   std::string permission_name = permission;
 
   // See if this is a function or event name first and strip out the package.
   // Functions will be of the form package.function
   // Events will be of the form package/id or package.optional.stuff
   size_t separator = permission.find_first_of("./");
   if (separator != std::string::npos)
     permission_name = permission.substr(0, separator);
 
-  // windows and tabs are the same permission.
-  if (permission_name == "windows")
-    permission_name = Extension::kTabPermission;
-
-  for (size_t i = 0; i < arraysize(kNonPermissionExtensionPackages); ++i)
-    if (permission_name == kNonPermissionExtensionPackages[i])
-      return true;
-
-  PermissionsMap& permissions_map = *GetPermissionsMap(extension_id);
-  PermissionsMap::iterator it = permissions_map.find(permission_name);
-  return (it != permissions_map.end() && it->second);
+  PermissionsList& permissions_list = *GetPermissionsList(extension_id);
+  return Extension::HasApiPermission(permissions_list, permission_name);
 }
 
 // static
 v8::Handle<v8::Value>
     ExtensionProcessBindings::ThrowPermissionDeniedException(
       const std::string& function_name) {
   static const char kMessage[] =
       "You do not have permission to use '%s'. Be sure to declare"
       " in your manifest what permissions you need.";
   std::string error_msg = StringPrintf(kMessage, function_name.c_str());
 
   return v8::ThrowException(v8::Exception::Error(
       v8::String::New(error_msg.c_str())));
 }