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

chrome/browser/extensions/extension_prefs.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/browser/extensions/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/admin_policy.h"
 #include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
 #include "chrome/browser/extensions/extension_menu_manager.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension_switch_utils.h"
 #include "chrome/common/extensions/manifest.h"
+#include "chrome/common/extensions/permissions/permissions_info.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
+using extensions::APIPermission;
+using extensions::APIPermissionSet;
 using extensions::Extension;
 using extensions::ExtensionInfo;
+using extensions::OAuth2Scopes;
+using extensions::PermissionsInfo;
+using extensions::PermissionSet;
 
 namespace {
 
 // Additional preferences keys
 
 // Where an extension was installed from. (see Extension::Location)
 const char kPrefLocation[] = "location";
 
 // Enabled, disabled, killed, etc. (see Extension::State)
 const char kPrefState[] = "state";
@@ skipping 85 matching lines @@
 const char kBrowserActionPinned[] = "browser_action_pinned";
 
 // Preferences that hold which permissions the user has granted the extension.
 // We explicitly keep track of these so that extensions can contain unknown
 // permissions, for backwards compatibility reasons, and we can still prompt
 // the user to accept them once recognized. We store the active permission
 // permissions because they may differ from those defined in the manifest.
 const char kPrefActivePermissions[] = "active_permissions";
 const char kPrefGrantedPermissions[] = "granted_permissions";
 
-// The preference names for ExtensionPermissionSet values.
+// The preference names for PermissionSet values.
 const char kPrefAPIs[] = "api";
 const char kPrefExplicitHosts[] = "explicit_host";
 const char kPrefScriptableHosts[] = "scriptable_host";
 const char kPrefScopes[] = "scopes";
 
 // The preference names for the old granted permissions scheme.
 const char kPrefOldGrantedFullAccess[] = "granted_permissions.full";
 const char kPrefOldGrantedHosts[] = "granted_permissions.host";
 const char kPrefOldGrantedAPIs[] = "granted_permissions.api";
 
@@ skipping 315 matching lines @@
   return result->Populate(*value, valid_schemes, allow_file_access, NULL);
 }
 
 void ExtensionPrefs::SetExtensionPrefURLPatternSet(
     const std::string& extension_id,
     const std::string& pref_key,
     const URLPatternSet& new_value) {
   UpdateExtensionPref(extension_id, pref_key, new_value.ToValue().release());
 }
 
-ExtensionPermissionSet* ExtensionPrefs::ReadExtensionPrefPermissionSet(
+PermissionSet* ExtensionPrefs::ReadExtensionPrefPermissionSet(
     const std::string& extension_id,
     const std::string& pref_key) {
   if (!GetExtensionPref(extension_id))
     return NULL;
 
   // Retrieve the API permissions.
-  ExtensionAPIPermissionSet apis;
+  APIPermissionSet apis;
   const ListValue* api_values = NULL;
   std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
   if (ReadExtensionPrefList(extension_id, api_pref, &api_values)) {
-    ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+    PermissionsInfo* info = PermissionsInfo::GetInstance();
     for (size_t i = 0; i < api_values->GetSize(); ++i) {
       std::string permission_name;
       if (api_values->GetString(i, &permission_name)) {
-        ExtensionAPIPermission *permission = info->GetByName(permission_name);
+        APIPermission *permission = info->GetByName(permission_name);
         if (permission)
           apis.insert(permission->id());
       }
     }
   }
 
   // Retrieve the explicit host permissions.
   URLPatternSet explicit_hosts;
   ReadExtensionPrefURLPatternSet(
       extension_id, JoinPrefs(pref_key, kPrefExplicitHosts),
       &explicit_hosts, Extension::kValidHostPermissionSchemes);
 
   // Retrieve the scriptable host permissions.
   URLPatternSet scriptable_hosts;
   ReadExtensionPrefURLPatternSet(
       extension_id, JoinPrefs(pref_key, kPrefScriptableHosts),
       &scriptable_hosts, UserScript::kValidUserScriptSchemes);
 
   // Retrieve the oauth2 scopes.
-  ExtensionOAuth2Scopes scopes;
+  OAuth2Scopes scopes;
   const ListValue* scope_values = NULL;
   std::string scope_pref = JoinPrefs(pref_key, kPrefScopes);
   if (ReadExtensionPrefList(extension_id, scope_pref, &scope_values)) {
     for (size_t i = 0; i < scope_values->GetSize(); ++i) {
       std::string scope;
       if (scope_values->GetString(i, &scope))
         scopes.insert(scope);
     }
   }
 
-  return new ExtensionPermissionSet(
+  return new PermissionSet(
       apis, explicit_hosts, scriptable_hosts, scopes);
 }
 
 void ExtensionPrefs::SetExtensionPrefPermissionSet(
     const std::string& extension_id,
     const std::string& pref_key,
-    const ExtensionPermissionSet* new_value) {
+    const PermissionSet* new_value) {
   // Set the API permissions.
   ListValue* api_values = new ListValue();
-  ExtensionAPIPermissionSet apis = new_value->apis();
-  ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+  APIPermissionSet apis = new_value->apis();
+  PermissionsInfo* info = PermissionsInfo::GetInstance();
   std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
-  for (ExtensionAPIPermissionSet::const_iterator i = apis.begin();
+  for (APIPermissionSet::const_iterator i = apis.begin();
        i != apis.end(); ++i) {
-    ExtensionAPIPermission* perm = info->GetByID(*i);
+    APIPermission* perm = info->GetByID(*i);
     if (perm)
       api_values->Append(Value::CreateStringValue(perm->name()));
   }
   UpdateExtensionPref(extension_id, api_pref, api_values);
 
   // Set the explicit host permissions.
   if (!new_value->explicit_hosts().is_empty()) {
     SetExtensionPrefURLPatternSet(extension_id,
                                   JoinPrefs(pref_key, kPrefExplicitHosts),
                                   new_value->explicit_hosts());
   }
 
   // Set the scriptable host permissions.
   if (!new_value->scriptable_hosts().is_empty()) {
     SetExtensionPrefURLPatternSet(extension_id,
                                   JoinPrefs(pref_key, kPrefScriptableHosts),
                                   new_value->scriptable_hosts());
   }
 
   // Set the oauth2 scopes.
-  ExtensionOAuth2Scopes scopes = new_value->scopes();
+  OAuth2Scopes scopes = new_value->scopes();
   if (!scopes.empty()) {
     ListValue* scope_values = new ListValue();
-    for (ExtensionOAuth2Scopes::iterator i = scopes.begin();
+    for (OAuth2Scopes::iterator i = scopes.begin();
          i != scopes.end(); ++i) {
       scope_values->Append(Value::CreateStringValue(*i));
     }
     std::string scope_pref = JoinPrefs(pref_key, kPrefScopes);
     UpdateExtensionPref(extension_id, scope_pref, scope_values);
   }
 }
 
 // static
 bool ExtensionPrefs::IsBlacklistBitSet(DictionaryValue* ext) {
@@ skipping 279 matching lines @@
   return false;
 }
 
 void ExtensionPrefs::SetActiveBit(const std::string& extension_id,
                                   bool active) {
   UpdateExtensionPref(extension_id, kActiveBit,
                       Value::CreateBooleanValue(active));
 }
 
 void ExtensionPrefs::MigratePermissions(const ExtensionIdSet& extension_ids) {
-  ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+  PermissionsInfo* info = PermissionsInfo::GetInstance();
   for (ExtensionIdSet::const_iterator ext_id =
        extension_ids.begin(); ext_id != extension_ids.end(); ++ext_id) {
 
     // An extension's granted permissions need to be migrated if the
     // full_access bit is present. This bit was always present in the previous
     // scheme and is never present now.
     bool full_access;
     const DictionaryValue* ext = GetExtensionPref(*ext_id);
     if (!ext || !ext->GetBoolean(kPrefOldGrantedFullAccess, &full_access))
       continue;
 
     // Remove the full access bit (empty list will get trimmed).
     UpdateExtensionPref(
         *ext_id, kPrefOldGrantedFullAccess, new ListValue());
 
     // Add the plugin permission if the full access bit was set.
     if (full_access) {
       ListValue* apis = NULL;
       ListValue* new_apis = NULL;
 
       std::string granted_apis =
           JoinPrefs(kPrefGrantedPermissions, kPrefAPIs);
       if (ext->GetList(kPrefOldGrantedAPIs, &apis))
         new_apis = apis->DeepCopy();
       else
         new_apis = new ListValue();
 
       std::string plugin_name = info->GetByID(
-          ExtensionAPIPermission::kPlugin)->name();
+          APIPermission::kPlugin)->name();
       new_apis->Append(Value::CreateStringValue(plugin_name));
       UpdateExtensionPref(*ext_id, granted_apis, new_apis);
     }
 
     // The granted permissions originally only held the effective hosts,
     // which are a combination of host and user script host permissions.
     // We now maintain these lists separately. For migration purposes, it
     // does not matter how we treat the old effective hosts as long as the
     // new effective hosts will be the same, so we move them to explicit
     // host permissions.
     ListValue* hosts;
     std::string explicit_hosts =
         JoinPrefs(kPrefGrantedPermissions, kPrefExplicitHosts);
     if (ext->GetList(kPrefOldGrantedHosts, &hosts)) {
       UpdateExtensionPref(
           *ext_id, explicit_hosts, hosts->DeepCopy());
 
       // We can get rid of the old one by setting it to an empty list.
       UpdateExtensionPref(*ext_id, kPrefOldGrantedHosts, new ListValue());
     }
   }
 }
 
-ExtensionPermissionSet* ExtensionPrefs::GetGrantedPermissions(
+PermissionSet* ExtensionPrefs::GetGrantedPermissions(
     const std::string& extension_id) {
   CHECK(Extension::IdIsValid(extension_id));
   return ReadExtensionPrefPermissionSet(extension_id, kPrefGrantedPermissions);
 }
 
 void ExtensionPrefs::AddGrantedPermissions(
     const std::string& extension_id,
-    const ExtensionPermissionSet* permissions) {
+    const PermissionSet* permissions) {
   CHECK(Extension::IdIsValid(extension_id));
 
-  scoped_refptr<ExtensionPermissionSet> granted_permissions(
+  scoped_refptr<PermissionSet> granted_permissions(
       GetGrantedPermissions(extension_id));
 
   // The new granted permissions are the union of the already granted
   // permissions and the newly granted permissions.
-  scoped_refptr<ExtensionPermissionSet> new_perms(
-      ExtensionPermissionSet::CreateUnion(
+  scoped_refptr<PermissionSet> new_perms(
+      PermissionSet::CreateUnion(
           permissions, granted_permissions.get()));
 
   SetExtensionPrefPermissionSet(
       extension_id, kPrefGrantedPermissions, new_perms.get());
 }
 
-ExtensionPermissionSet* ExtensionPrefs::GetActivePermissions(
+PermissionSet* ExtensionPrefs::GetActivePermissions(
     const std::string& extension_id) {
   CHECK(Extension::IdIsValid(extension_id));
   return ReadExtensionPrefPermissionSet(extension_id, kPrefActivePermissions);
 }
 
 void ExtensionPrefs::SetActivePermissions(
     const std::string& extension_id,
-    const ExtensionPermissionSet* permissions) {
+    const PermissionSet* permissions) {
   SetExtensionPrefPermissionSet(
       extension_id, kPrefActivePermissions, permissions);
 }
 
 std::set<std::string> ExtensionPrefs::GetRegisteredEvents(
     const std::string& extension_id) {
   std::set<std::string> events;
   const DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return events;
@@ skipping 932 matching lines @@
                             PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kLastExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionAllowedInstallSites,
                           PrefService::UNSYNCABLE_PREF);
 }