Add module-level permissions to extensions.

chrome/common/extensions/extension.cc

 // Copyright (c) 2009 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/common/extensions/extension.h"
 
 #include "app/resource_bundle.h"
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 13 matching lines @@
 
 #if defined(OS_WIN)
 #include "base/registry.h"
 #endif
 
 namespace keys = extension_manifest_keys;
 namespace values = extension_manifest_values;
 namespace errors = extension_manifest_errors;
 
 namespace {
-  const int kPEMOutputColumns = 65;
+const int kPEMOutputColumns = 65;
 
-  // KEY MARKERS
-  const char kKeyBeginHeaderMarker[] = "-----BEGIN";
-  const char kKeyBeginFooterMarker[] = "-----END";
-  const char kKeyInfoEndMarker[] = "KEY-----";
-  const char kPublic[] = "PUBLIC";
-  const char kPrivate[] = "PRIVATE";
+// KEY MARKERS
+const char kKeyBeginHeaderMarker[] = "-----BEGIN";
+const char kKeyBeginFooterMarker[] = "-----END";
+const char kKeyInfoEndMarker[] = "KEY-----";
+const char kPublic[] = "PUBLIC";
+const char kPrivate[] = "PRIVATE";
 
-  const int kRSAKeySize = 1024;
+const int kRSAKeySize = 1024;
 
-  // Converts a normal hexadecimal string into the alphabet used by extensions.
-  // We use the characters 'a'-'p' instead of '0'-'f' to avoid ever having a
-  // completely numeric host, since some software interprets that as an IP
-  // address.
-  static void ConvertHexadecimalToIDAlphabet(std::string* id) {
-    for (size_t i = 0; i < id->size(); ++i)
-      (*id)[i] = HexStringToInt(id->substr(i, 1)) + 'a';
+// Converts a normal hexadecimal string into the alphabet used by extensions.
+// We use the characters 'a'-'p' instead of '0'-'f' to avoid ever having a
+// completely numeric host, since some software interprets that as an IP
+// address.
+static void ConvertHexadecimalToIDAlphabet(std::string* id) {
+  for (size_t i = 0; i < id->size(); ++i)
+    (*id)[i] = HexStringToInt(id->substr(i, 1)) + 'a';
+}
+
+// Returns true if the given string is an API permission (see kPermissionNames).
+static bool IsAPIPermission(const std::string& str) {
+  for (size_t i = 0; i < Extension::kNumPermissions; ++i) {
+    if (str == Extension::kPermissionNames[i])
+      return true;
   }
-};
+
+  return false;
+}
+
+}  // namespace
 
 // static
 int Extension::id_counter_ = 0;
 
 const char Extension::kManifestFilename[] = "manifest.json";
 
 // A list of all the keys allowed by themes.
 static const wchar_t* kValidThemeKeys[] = {
   keys::kDescription,
   keys::kName,
@@ skipping 14 matching lines @@
 
 const char Extension::kMimeType[] = "application/x-chrome-extension";
 
 const int Extension::kIconSizes[] = {
   EXTENSION_ICON_LARGE,
   EXTENSION_ICON_MEDIUM,
   EXTENSION_ICON_SMALL,
   EXTENSION_ICON_BITTY
 };
 
+const char* Extension::kPermissionNames[] = {
+  "tabs",
+  "bookmarks",
+};
+const size_t Extension::kNumPermissions =
+    arraysize(Extension::kPermissionNames);
+
 Extension::~Extension() {
   for (PageActionMap::iterator i = page_actions_.begin();
        i != page_actions_.end(); ++i)
     delete i->second;
 }
 
 const std::string Extension::VersionString() const {
   return version_->GetString();
 }
 
@@ skipping 747 matching lines @@
       PageAction* page_action =
           LoadPageActionHelper(page_action_value, i, error);
       if (!page_action)
         return false;  // Failed to parse page action definition.
       page_actions_[page_action->id()] = page_action;
     }
   }
 
   // Initialize the permissions (optional).
   if (source.HasKey(keys::kPermissions)) {
-    ListValue* hosts = NULL;
-    if (!source.GetList(keys::kPermissions, &hosts)) {
+    ListValue* permissions = NULL;
+    if (!source.GetList(keys::kPermissions, &permissions)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidPermissions, "");
       return false;
     }
 
-    if (hosts->GetSize() == 0) {
+    if (permissions->GetSize() == 0) {
       ExtensionErrorReporter::GetInstance()->ReportError(
           errors::kInvalidPermissionCountWarning, false);
     }
 
-    for (size_t i = 0; i < hosts->GetSize(); ++i) {
-      std::string host_str;
-      if (!hosts->GetString(i, &host_str)) {
+    for (size_t i = 0; i < permissions->GetSize(); ++i) {
+      std::string permission_str;
+      if (!permissions->GetString(i, &permission_str)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
             errors::kInvalidPermission, IntToString(i));
         return false;
       }
 
+      // Check if it's a module permission.  If so, enable that permission.
+      if (IsAPIPermission(permission_str)) {
+        api_permissions_.push_back(permission_str);
+        continue;
+      }
+
+      // Otherwise, it's a host pattern permission.
       URLPattern pattern;
-      if (!pattern.Parse(host_str)) {
+      if (!pattern.Parse(permission_str)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
             errors::kInvalidPermission, IntToString(i));
         return false;
       }
 
       // Only accept http/https persmissions at the moment.
       if ((pattern.scheme() != chrome::kHttpScheme) &&
           (pattern.scheme() != chrome::kHttpsScheme)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
             errors::kInvalidPermissionScheme, IntToString(i));
         return false;
       }
 
-      permissions_.push_back(pattern);
+      host_permissions_.push_back(pattern);
     }
   }
 
   return true;
 }
 
 std::set<FilePath> Extension::GetBrowserImages() {
   std::set<FilePath> image_paths;
 
   // extension icons
@@ skipping 32 matching lines @@
 }
 
 void Extension::SetBackgroundPageReady() {
   DCHECK(!background_url().is_empty());
   background_page_ready_ = true;
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_BACKGROUND_PAGE_READY,
       Source<Extension>(this),
       NotificationService::NoDetails());
 }