Move each permission classes to its own files in extensions/permissions

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 19 matching lines @@
 #include "chrome/common/extensions/csp_validator.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/extension_switch_utils.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/features/simple_feature_provider.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/extensions/manifest.h"
+#include "chrome/common/extensions/permissions/permissions_info.h"
 #include "chrome/common/extensions/url_pattern_set.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/url_constants.h"
 #include "crypto/sha2.h"
 #include "googleurl/src/url_util.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "net/base/registry_controlled_domain.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 224 matching lines @@
 }
 
 Extension::InputComponentInfo::~InputComponentInfo() {}
 
 Extension::TtsVoice::TtsVoice() {}
 Extension::TtsVoice::~TtsVoice() {}
 
 Extension::OAuth2Info::OAuth2Info() {}
 Extension::OAuth2Info::~OAuth2Info() {}
 
-ExtensionOAuth2Scopes Extension::OAuth2Info::GetScopesAsSet() {
-  ExtensionOAuth2Scopes result;
+OAuth2Scopes Extension::OAuth2Info::GetScopesAsSet() {
+  OAuth2Scopes result;
   std::copy(scopes.begin(), scopes.end(),
             std::inserter(result, result.begin()));
   return result;
 }
 
 //
 // Extension
 //
 
 // static
@@ skipping 1003 matching lines @@
                            keys::kLaunchHeight,
                            &launch_height_,
                            can_specify_initial_size,
                            error))
       return false;
 
   return true;
 }
 
 bool Extension::LoadSharedFeatures(
-    const ExtensionAPIPermissionSet& api_permissions,
+    const APIPermissionSet& api_permissions,
     string16* error) {
   if (!LoadDescription(error) ||
       !LoadHomepageURL(error) ||
       !LoadUpdateURL(error) ||
       !LoadIcons(error) ||
       !LoadCommands(error) ||
       !LoadPlugins(error) ||
       !LoadNaClModules(error) ||
       !LoadWebAccessibleResources(error) ||
       !LoadSandboxedPages(error) ||
@@ skipping 460 matching lines @@
           errors::kInvalidBackgroundScript, base::IntToString(i));
       return false;
     }
     background_scripts_.push_back(script);
   }
 
   return true;
 }
 
 bool Extension::LoadBackgroundPage(
-    const ExtensionAPIPermissionSet& api_permissions,
+    const APIPermissionSet& api_permissions,
     string16* error) {
   if (is_platform_app()) {
     return LoadBackgroundPage(
         keys::kPlatformAppBackgroundPage, api_permissions, error);
   }
 
   if (!LoadBackgroundPage(keys::kBackgroundPage, api_permissions, error))
     return false;
   if (background_url_.is_empty())
     return LoadBackgroundPage(
         keys::kBackgroundPageLegacy, api_permissions, error);
   return true;
 }
 
 bool Extension::LoadBackgroundPage(
     const std::string& key,
-    const ExtensionAPIPermissionSet& api_permissions,
+    const APIPermissionSet& api_permissions,
     string16* error) {
   base::Value* background_page_value = NULL;
   if (!manifest_->Get(key, &background_page_value))
     return true;
 
   if (!background_scripts_.empty()) {
     *error = ASCIIToUTF16(errors::kInvalidBackgroundCombination);
     return false;
   }
 
 
   std::string background_str;
   if (!background_page_value->GetAsString(&background_str)) {
     *error = ASCIIToUTF16(errors::kInvalidBackground);
     return false;
   }
 
   if (is_hosted_app()) {
     background_url_ = GURL(background_str);
 
     // Make sure "background" permission is set.
-    if (!api_permissions.count(ExtensionAPIPermission::kBackground)) {
+    if (!api_permissions.count(APIPermission::kBackground)) {
       *error = ASCIIToUTF16(errors::kBackgroundPermissionNeeded);
       return false;
     }
     // Hosted apps require an absolute URL.
     if (!background_url_.is_valid()) {
       *error = ASCIIToUTF16(errors::kInvalidBackgroundInHostedApp);
       return false;
     }
 
     if (!(background_url_.SchemeIs("https") ||
           (CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kAllowHTTPBackgroundPage) &&
            background_url_.SchemeIs("http")))) {
       *error = ASCIIToUTF16(errors::kInvalidBackgroundInHostedApp);
       return false;
     }
   } else {
     background_url_ = GetResourceURL(background_str);
   }
 
   return true;
 }
 
 bool Extension::LoadBackgroundPersistent(
-    const ExtensionAPIPermissionSet& api_permissions,
+    const APIPermissionSet& api_permissions,
     string16* error) {
   if (is_platform_app()) {
     background_page_is_persistent_ = false;
     return true;
   }
 
   Value* background_persistent = NULL;
   if (!manifest_->Get(keys::kBackgroundPersistent, &background_persistent))
     return true;
 
   if (!background_persistent->GetAsBoolean(&background_page_is_persistent_)) {
     *error = ASCIIToUTF16(errors::kInvalidBackgroundPersistent);
     return false;
   }
 
   if (!has_background_page()) {
     *error = ASCIIToUTF16(errors::kInvalidBackgroundPersistentNoPage);
     return false;
   }
 
   return true;
 }
 
 bool Extension::LoadBackgroundAllowJSAccess(
-    const ExtensionAPIPermissionSet& api_permissions,
+    const APIPermissionSet& api_permissions,
     string16* error) {
   Value* allow_js_access = NULL;
   if (!manifest_->Get(keys::kBackgroundAllowJsAccess, &allow_js_access))
     return true;
 
   if (!allow_js_access->IsType(Value::TYPE_BOOLEAN) ||
       !allow_js_access->GetAsBoolean(&allow_background_js_access_)) {
     *error = ASCIIToUTF16(errors::kInvalidBackgroundAllowJsAccess);
     return false;
   }
@@ skipping 156 matching lines @@
         *error = ASCIIToUTF16(errors::kInvalidIntent);
         return false;
       }
       if (!LoadWebIntentAction(*iter, *one_service, error))
         return false;
     }
   }
   return true;
 }
 bool Extension::LoadExtensionFeatures(
-    const ExtensionAPIPermissionSet& api_permissions,
+    const APIPermissionSet& api_permissions,
     string16* error) {
   if (manifest_->HasKey(keys::kConvertedFromUserScript))
     manifest_->GetBoolean(keys::kConvertedFromUserScript,
                           &converted_from_user_script_);
 
   if (!LoadDevToolsPage(error) ||
       !LoadInputComponents(api_permissions, error) ||
       !LoadContentScripts(error) ||
       !LoadPageAction(error) ||
       !LoadBrowserAction(error) ||
@@ skipping 15 matching lines @@
   std::string devtools_str;
   if (!manifest_->GetString(keys::kDevToolsPage, &devtools_str)) {
     *error = ASCIIToUTF16(errors::kInvalidDevToolsPage);
     return false;
   }
   devtools_url_ = GetResourceURL(devtools_str);
   return true;
 }
 
 bool Extension::LoadInputComponents(
-    const ExtensionAPIPermissionSet& api_permissions,
+    const APIPermissionSet& api_permissions,
     string16* error) {
   if (!manifest_->HasKey(keys::kInputComponents))
     return true;
   ListValue* list_value = NULL;
   if (!manifest_->GetList(keys::kInputComponents, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidInputComponents);
     return false;
   }
 
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
@@ skipping 605 matching lines @@
     //               default Content-Security-Policy?
     content_security_policy_ = is_platform_app() ?
         kDefaultPlatformAppContentSecurityPolicy :
         kDefaultContentSecurityPolicy;
     CHECK(ContentSecurityPolicyIsSecure(content_security_policy_));
   }
   return true;
 }
 
 bool Extension::LoadAppIsolation(
-    const ExtensionAPIPermissionSet& api_permissions, string16* error) {
+    const APIPermissionSet& api_permissions, string16* error) {
   // Platform apps always get isolated storage.
   if (is_platform_app()) {
     is_storage_isolated_ = true;
     return true;
   }
 
   // Other apps only get it if it is requested _and_ experimental APIs are
   // enabled.
-  if (!api_permissions.count(ExtensionAPIPermission::kExperimental) ||
+  if (!api_permissions.count(APIPermission::kExperimental) ||
       !is_app()) {
     return true;
   }
 
   Value* temp = NULL;
   if (!manifest_->Get(keys::kIsolation, &temp))
     return true;
 
   if (temp->GetType() != Value::TYPE_LIST) {
     *error = ASCIIToUTF16(errors::kInvalidIsolation);
@@ skipping 321 matching lines @@
   return GURL(std::string(chrome::kExtensionScheme) +
               content::kStandardSchemeSeparator + extension_id + "/");
 }
 
 bool Extension::InitFromValue(int flags, string16* error) {
   DCHECK(error);
 
   base::AutoLock auto_lock(runtime_data_lock_);
 
   // Initialize permissions with an empty, default permission set.
-  runtime_data_.SetActivePermissions(new ExtensionPermissionSet());
-  optional_permission_set_ = new ExtensionPermissionSet();
-  required_permission_set_ = new ExtensionPermissionSet();
+  runtime_data_.SetActivePermissions(new PermissionSet());
+  optional_permission_set_ = new PermissionSet();
+  required_permission_set_ = new PermissionSet();
 
   creation_flags_ = flags;
 
   // Important to load manifest version first because many other features
   // depend on its value.
   if (!LoadManifestVersion(error))
     return false;
 
   // Validate minimum Chrome version. We don't need to store this, since the
   // extension is not valid if it is incorrect
   if (!CheckMinimumChromeVersion(error))
     return false;
 
   if (!LoadRequiredFeatures(error))
     return false;
 
   // We don't ned to validate because InitExtensionID already did that.
   manifest_->GetString(keys::kPublicKey, &public_key_);
 
   extension_url_ = Extension::GetBaseURLFromExtensionId(id());
 
   // Load App settings. LoadExtent at least has to be done before
   // ParsePermissions(), because the valid permissions depend on what type of
   // package this is.
   if (is_app() && !LoadAppFeatures(error))
     return false;
 
-  ExtensionAPIPermissionSet api_permissions;
+  APIPermissionSet api_permissions;
   URLPatternSet host_permissions;
   if (!ParsePermissions(keys::kPermissions,
                         error,
                         &api_permissions,
                         &host_permissions)) {
     return false;
   }
 
   // TODO(jeremya/kalman) do this via the features system by exposing the
   // appWindow API to platform apps, with no dependency on any permissions.
   // See http://crbug.com/120069.
   if (is_platform_app())
-    api_permissions.insert(ExtensionAPIPermission::kAppWindow);
+    api_permissions.insert(APIPermission::kAppWindow);
 
-  ExtensionAPIPermissionSet optional_api_permissions;
+  APIPermissionSet optional_api_permissions;
   URLPatternSet optional_host_permissions;
   if (!ParsePermissions(keys::kOptionalPermissions,
                         error,
                         &optional_api_permissions,
                         &optional_host_permissions)) {
     return false;
   }
 
   if (!LoadAppIsolation(api_permissions, error))
     return false;
 
   if (!LoadSharedFeatures(api_permissions, error))
     return false;
 
   if (!LoadExtensionFeatures(api_permissions, error))
     return false;
 
   if (!LoadThemeFeatures(error))
     return false;
 
   if (HasMultipleUISurfaces()) {
     *error = ASCIIToUTF16(errors::kOneUISurfaceOnly);
     return false;
   }
 
-  runtime_data_.SetActivePermissions(new ExtensionPermissionSet(
+  runtime_data_.SetActivePermissions(new PermissionSet(
       this, api_permissions, host_permissions, oauth2_info_.GetScopesAsSet()));
-  required_permission_set_ = new ExtensionPermissionSet(
+  required_permission_set_ = new PermissionSet(
       this, api_permissions, host_permissions, oauth2_info_.GetScopesAsSet());
-  optional_permission_set_ = new ExtensionPermissionSet(
+  optional_permission_set_ = new PermissionSet(
       optional_api_permissions, optional_host_permissions, URLPatternSet());
 
   return true;
 }
 
 GURL Extension::GetHomepageURL() const {
   if (homepage_url_.is_valid())
     return homepage_url_;
 
   if (!UpdatesFromGallery())
@@ skipping 139 matching lines @@
                            ExtensionIconSet::MatchType match_type) const {
   std::string path = icons().Get(size, match_type);
   if (path.empty())
     return GURL();
   else
     return GetResourceURL(path);
 }
 
 bool Extension::ParsePermissions(const char* key,
                                  string16* error,
-                                 ExtensionAPIPermissionSet* api_permissions,
+                                 APIPermissionSet* api_permissions,
                                  URLPatternSet* host_permissions) {
   if (manifest_->HasKey(key)) {
     ListValue* permissions = NULL;
     if (!manifest_->GetList(key, &permissions)) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidPermissions, "");
       return false;
     }
 
     for (size_t i = 0; i < permissions->GetSize(); ++i) {
       std::string permission_str;
       if (!permissions->GetString(i, &permission_str)) {
         *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPermission, base::IntToString(i));
         return false;
       }
 
-      // NOTE: We need to get the ExtensionAPIPermission before the Feature
+      // NOTE: We need to get the APIPermission before the Feature
       // object because the feature system does not know about aliases.
-      ExtensionAPIPermission* permission =
-          ExtensionPermissionsInfo::GetInstance()->GetByName(permission_str);
+      APIPermission* permission =
+          PermissionsInfo::GetInstance()->GetByName(permission_str);
       if (permission) {
         extensions::SimpleFeatureProvider* permission_features =
             extensions::SimpleFeatureProvider::GetPermissionFeatures();
         extensions::Feature* feature =
             permission_features->GetFeature(permission->name());
 
-        // The feature should exist since we just got an ExtensionAPIPermission
+        // The feature should exist since we just got an APIPermission
         // for it. The two systems should be updated together whenever a
         // permission is added.
         CHECK(feature);
 
         extensions::Feature::Availability availability =
             feature->IsAvailableToManifest(
                 id(),
                 GetType(),
                 extensions::Feature::ConvertLocation(location()),
                 manifest_version());
         if (availability != extensions::Feature::IS_AVAILABLE) {
           // Don't fail, but warn the developer that the manifest contains
           // unrecognized permissions. This may happen legitimately if the
           // extensions requests platform- or channel-specific permissions.
           install_warnings_.push_back(
               InstallWarning(InstallWarning::FORMAT_TEXT,
                              feature->GetErrorMessage(availability)));
           continue;
         }
 
-        if (permission->id() == ExtensionAPIPermission::kExperimental) {
+        if (permission->id() == APIPermission::kExperimental) {
           if (!CanSpecifyExperimentalPermission()) {
             *error = ASCIIToUTF16(errors::kExperimentalFlagRequired);
             return false;
           }
         }
 
         api_permissions->insert(permission->id());
         continue;
       }
 
@@ skipping 36 matching lines @@
     }
   }
   return true;
 }
 
 bool Extension::CanSilentlyIncreasePermissions() const {
   return location() != INTERNAL;
 }
 
 bool Extension::CanSpecifyHostPermission(const URLPattern& pattern,
-    const ExtensionAPIPermissionSet& permissions) const {
+    const APIPermissionSet& permissions) const {
   if (!pattern.match_all_urls() &&
       pattern.MatchesScheme(chrome::kChromeUIScheme)) {
     // Regular extensions are only allowed access to chrome://favicon.
     if (pattern.host() == chrome::kChromeUIFaviconHost)
       return true;
 
     // Experimental extensions are also allowed chrome://thumb.
     if (pattern.host() == chrome::kChromeUIThumbnailHost) {
-      return permissions.find(ExtensionAPIPermission::kExperimental) !=
+      return permissions.find(APIPermission::kExperimental) !=
           permissions.end();
     }
 
     // Component extensions can have access to all of chrome://*.
     if (CanExecuteScriptEverywhere())
       return true;
 
     return false;
   }
 
   // Otherwise, the valid schemes were handled by URLPattern.
   return true;
 }
 
 bool Extension::HasAPIPermission(
-    ExtensionAPIPermission::ID permission) const {
+    APIPermission::ID permission) const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions()->HasAPIPermission(permission);
 }
 
 bool Extension::HasAPIPermission(
     const std::string& function_name) const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions()->
       HasAccessToFunction(function_name);
 }
@@ skipping 19 matching lines @@
 bool Extension::HasEffectiveAccessToAllHosts() const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions()->HasEffectiveAccessToAllHosts();
 }
 
 bool Extension::HasFullPermissions() const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions()->HasEffectiveFullAccess();
 }
 
-ExtensionPermissionMessages Extension::GetPermissionMessages() const {
+PermissionMessages Extension::GetPermissionMessages() const {
   base::AutoLock auto_lock(runtime_data_lock_);
   if (IsTrustedId(id()))
-    return ExtensionPermissionMessages();
+    return PermissionMessages();
   else
     return runtime_data_.GetActivePermissions()->GetPermissionMessages();
 }
 
 std::vector<string16> Extension::GetPermissionMessageStrings() const {
   base::AutoLock auto_lock(runtime_data_lock_);
   if (IsTrustedId(id()))
     return std::vector<string16>();
   else
     return runtime_data_.GetActivePermissions()->GetWarningMessages();
 }
 
 void Extension::SetActivePermissions(
-    const ExtensionPermissionSet* permissions) const {
+    const PermissionSet* permissions) const {
   base::AutoLock auto_lock(runtime_data_lock_);
   runtime_data_.SetActivePermissions(permissions);
 }
 
-scoped_refptr<const ExtensionPermissionSet>
+scoped_refptr<const PermissionSet>
     Extension::GetActivePermissions() const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions();
 }
 
 bool Extension::HasMultipleUISurfaces() const {
   int num_surfaces = 0;
 
   if (page_action())
     ++num_surfaces;
@@ skipping 293 matching lines @@
   if (!has_background_page()) {
     *utf8_error = errors::kBackgroundRequiredForPlatformApps;
     return false;
   }
 
   return true;
 }
 
 bool Extension::CheckConflictingFeatures(std::string* utf8_error) {
   if (has_lazy_background_page() &&
-      HasAPIPermission(ExtensionAPIPermission::kWebRequest)) {
+      HasAPIPermission(APIPermission::kWebRequest)) {
     *utf8_error = errors::kWebRequestConflictsWithLazyBackground;
     return false;
   }
 
   return true;
 }
 
 ExtensionInfo::~ExtensionInfo() {}
 
 Extension::RuntimeData::RuntimeData() {}
-Extension::RuntimeData::RuntimeData(const ExtensionPermissionSet* active)
+Extension::RuntimeData::RuntimeData(const PermissionSet* active)
     : active_permissions_(active) {}
 Extension::RuntimeData::~RuntimeData() {}
 
-scoped_refptr<const ExtensionPermissionSet>
+scoped_refptr<const PermissionSet>
     Extension::RuntimeData::GetActivePermissions() const {
   return active_permissions_;
 }
 
 void Extension::RuntimeData::SetActivePermissions(
-    const ExtensionPermissionSet* active) {
+    const PermissionSet* active) {
   active_permissions_ = active;
 }
 
 const URLPatternSet*
     Extension::RuntimeData::GetTabSpecificHostPermissions(int tab_id) const {
   CHECK_GE(tab_id, 0);
   TabHostPermissionsMap::const_iterator it =
       tab_specific_host_permissions_.find(tab_id);
   return (it != tab_specific_host_permissions_.end()) ? it->second.get() : NULL;
 }
@@ skipping 13 matching lines @@
 
 UnloadedExtensionInfo::UnloadedExtensionInfo(
     const Extension* extension,
     extension_misc::UnloadedExtensionReason reason)
   : reason(reason),
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
-    const ExtensionPermissionSet* permissions,
+    const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions