Start refractoring extension permissions into ExtensionPermissionSet.

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2011 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/extension_pref_store.h"
@@ skipping 49 matching lines @@
 
 // Path for settings specific to blacklist update.
 const char kExtensionsBlacklistUpdate[] = "extensions.blacklistupdate";
 
 // Path and sub-keys for the idle install info dictionary preference.
 const char kIdleInstallInfo[] = "idle_install_info";
 const char kIdleInstallInfoCrxPath[] = "crx_path";
 const char kIdleInstallInfoVersion[] = "version";
 const char kIdleInstallInfoFetchTime[] = "fetch_time";
 
-
 // A preference that, if true, will allow this extension to run in incognito
 // mode.
 const char kPrefIncognitoEnabled[] = "incognito";
 
 // A preference to control whether an extension is allowed to inject script in
 // pages with file URLs.
 const char kPrefAllowFileAccess[] = "allowFileAccess";
 
 // A preference set by the web store to indicate login information for
 // purchased apps.
@@ skipping 15 matching lines @@
 // A preference for storing extra data sent in update checks for an extension.
 const char kUpdateUrlData[] = "update_url_data";
 
 // Whether the browser action is visible in the toolbar.
 const char kBrowserActionVisible[] = "browser_action_visible";
 
 // 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.
-const char kPrefGrantedPermissionsAPI[] = "granted_permissions.api";
-const char kPrefGrantedPermissionsHost[] = "granted_permissions.host";
-const char kPrefGrantedPermissionsAll[] = "granted_permissions.full";
+const char kPrefGrantedAPIs[] = "granted_permissions.api";
+const char kPrefGrantedExplicitHosts[] = "granted_permissions.explicit_host";
+const char kPrefGrantedScriptableHosts[] =
+    "granted_permissions.scriptable_host";
+
+// 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";
 
 // A preference that indicates when an extension was installed.
 const char kPrefInstallTime[] = "install_time";
 
 // A preference that contains any extension-controlled preferences.
 const char kPrefPreferences[] = "preferences";
 
 // A preference that contains any extension-controlled incognito preferences.
 const char kPrefIncognitoPreferences[] = "incognito_preferences";
 
@@ skipping 130 matching lines @@
       Value* extension_prefs = NULL;
       CHECK(update_dictionary->RemoveWithoutPathExpansion(
           i->first, &extension_prefs));
       update_dictionary->SetWithoutPathExpansion(i->second, extension_prefs);
     }
 
     prefs->ScheduleSavePersistentPrefs();
   }
 }
 
-static void ExtentToStringSet(const URLPatternSet& host_extent,
-                              std::set<std::string>* result) {
-  URLPatternList patterns = host_extent.patterns();
-  URLPatternList::const_iterator i;
-
-  for (i = patterns.begin(); i != patterns.end(); ++i)
-    result->insert(i->GetAsString());
-}
-
 }  // namespace
 
 ExtensionPrefs::ExtensionPrefs(
     PrefService* prefs,
     const FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map)
     : prefs_(prefs),
       install_directory_(root_dir),
       extension_pref_value_map_(extension_pref_value_map),
       content_settings_store_(new ExtensionContentSettingsStore()) {
@@ skipping 152 matching lines @@
     const ListValue** out_value) {
   const DictionaryValue* ext = GetExtensionPref(extension_id);
   ListValue* out = NULL;
   if (!ext || !ext->GetList(pref_key, &out))
     return false;
   *out_value = out;
 
   return out_value != NULL;
 }
 
-bool ExtensionPrefs::ReadExtensionPrefStringSet(
+bool ExtensionPrefs::ReadExtensionPrefURLPatternSet(
     const std::string& extension_id,
     const std::string& pref_key,
-    std::set<std::string>* result) {
+    URLPatternSet* result,
+    int valid_schemes) {
   const ListValue* value = NULL;
   if (!ReadExtensionPrefList(extension_id, pref_key, &value))
     return false;
 
-  result->clear();
+  result->ClearPatterns();
+  bool allow_file_access = AllowFileAccess(extension_id);
 
   for (size_t i = 0; i < value->GetSize(); ++i) {
     std::string item;
     if (!value->GetString(i, &item))
       return false;
-    result->insert(item);
+    URLPattern pattern(valid_schemes);
+    if (pattern.Parse(item, URLPattern::PARSE_LENIENT) !=
+        URLPattern::PARSE_SUCCESS) {
+      NOTREACHED();
+      return false;
+    }
+    if (!allow_file_access && pattern.MatchesScheme(chrome::kFileScheme)) {
+      pattern.set_valid_schemes(
+          pattern.valid_schemes() & ~URLPattern::SCHEME_FILE);
+    }
+    result->AddPattern(pattern);
   }
 
   return true;
 }
 
-void ExtensionPrefs::AddToExtensionPrefStringSet(
+void ExtensionPrefs::SetExtensionPrefURLPatternSet(
     const std::string& extension_id,
     const std::string& pref_key,
-    const std::set<std::string>& added_value) {
-  std::set<std::string> old_value;
-  std::set<std::string> new_value;
-  ReadExtensionPrefStringSet(extension_id, pref_key, &old_value);
-
-  std::set_union(old_value.begin(), old_value.end(),
-                 added_value.begin(), added_value.end(),
-                 std::inserter(new_value, new_value.begin()));
-
+    const URLPatternSet& new_value) {
   ListValue* value = new ListValue();
-  for (std::set<std::string>::const_iterator iter = new_value.begin();
-       iter != new_value.end(); ++iter)
-    value->Append(Value::CreateStringValue(*iter));
+  for (URLPatternList::const_iterator i = new_value.patterns().begin();
+       i != new_value.patterns().end(); ++i)
+    value->AppendIfNotPresent(Value::CreateStringValue(i->GetAsString()));
 
   UpdateExtensionPref(extension_id, pref_key, value);
 }
 
 void ExtensionPrefs::SavePrefs() {
   prefs_->ScheduleSavePersistentPrefs();
 }
 
 // static
 bool ExtensionPrefs::IsBlacklistBitSet(DictionaryValue* ext) {
@@ skipping 177 matching lines @@
     return result;
   return false;
 }
 
 void ExtensionPrefs::SetActiveBit(const std::string& extension_id,
                                   bool active) {
   UpdateExtensionPref(extension_id, kActiveBit,
                       Value::CreateBooleanValue(active));
 }
 
-bool ExtensionPrefs::GetGrantedPermissions(
-    const std::string& extension_id,
-    bool* full_access,
-    std::set<std::string>* api_permissions,
-    URLPatternSet* host_extent) {
+void ExtensionPrefs::MigratePermissions(const ExtensionIdSet& extension_ids) {
+  ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::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;
+
+      if (ext->GetList(kPrefGrantedAPIs, &apis))
+        new_apis = apis->DeepCopy();
+      else
+        new_apis = new ListValue();
+
+      std::string plugin_name = info->GetByID(
+          ExtensionAPIPermission::kPlugin)->name();
+      new_apis->Append(Value::CreateStringValue(plugin_name));
+      UpdateExtensionPref(*ext_id, kPrefGrantedAPIs, 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;
+    if (ext->GetList(kPrefOldGrantedHosts, &hosts)) {
+      UpdateExtensionPref(
+          *ext_id, kPrefGrantedExplicitHosts, hosts->DeepCopy());
+
+      // We can get rid of the old one by setting it to an empty list.
+      UpdateExtensionPref(*ext_id, kPrefOldGrantedHosts, new ListValue());
+    }
+  }
+  SavePrefs();
+}
+
+ExtensionPermissionSet* ExtensionPrefs::GetGrantedPermissions(
+    const std::string& extension_id) {
   CHECK(Extension::IdIsValid(extension_id));
 
   const DictionaryValue* ext = GetExtensionPref(extension_id);
-  if (!ext || !ext->GetBoolean(kPrefGrantedPermissionsAll, full_access))
-    return false;
+  if (!ext)
+    return NULL;
 
-  ReadExtensionPrefStringSet(
-      extension_id, kPrefGrantedPermissionsAPI, api_permissions);
-
-  std::set<std::string> host_permissions;
-  ReadExtensionPrefStringSet(
-      extension_id, kPrefGrantedPermissionsHost, &host_permissions);
-  bool allow_file_access = AllowFileAccess(extension_id);
-
-  // The granted host permissions contain hosts from the manifest's
-  // "permissions" array and from the content script "matches" arrays,
-  // so the URLPattern needs to accept valid schemes from both types.
-  for (std::set<std::string>::iterator i = host_permissions.begin();
-       i != host_permissions.end(); ++i) {
-    URLPattern pattern(
-        Extension::kValidHostPermissionSchemes |
-        UserScript::kValidUserScriptSchemes);
-
-    // Parse without strict checks, so that new strict checks do not
-    // fail on a pattern in an installed extension.
-    if (URLPattern::PARSE_SUCCESS != pattern.Parse(
-            *i, URLPattern::PARSE_LENIENT)) {
-      NOTREACHED();  // Corrupt prefs?  Hand editing?
-    } else {
-      if (!allow_file_access && pattern.MatchesScheme(chrome::kFileScheme)) {
-        pattern.set_valid_schemes(
-            pattern.valid_schemes() & ~URLPattern::SCHEME_FILE);
+  // Retrieve the API permissions.
+  ExtensionAPIPermissionSet apis;
+  const ListValue* api_values = NULL;
+  if (ReadExtensionPrefList(extension_id, kPrefGrantedAPIs, &api_values)) {
+    ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::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);
+        if (permission)
+          apis.insert(permission->id());
       }
-      host_extent->AddPattern(pattern);
     }
   }
 
-  return true;
+  // Retrieve the explicit host permissions.
+  URLPatternSet explicit_hosts;
+  ReadExtensionPrefURLPatternSet(
+      extension_id, kPrefGrantedExplicitHosts,
+      &explicit_hosts, Extension::kValidHostPermissionSchemes);
+
+  // Retrieve the scriptable host permissions.
+  URLPatternSet scriptable_hosts;
+  ReadExtensionPrefURLPatternSet(
+      extension_id, kPrefGrantedScriptableHosts,
+      &scriptable_hosts, UserScript::kValidUserScriptSchemes);
+
+  return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
 }
 
 void ExtensionPrefs::AddGrantedPermissions(
     const std::string& extension_id,
-    const bool full_access,
-    const std::set<std::string>& api_permissions,
-    const URLPatternSet& host_extent) {
+    const ExtensionPermissionSet* permissions) {
   CHECK(Extension::IdIsValid(extension_id));
 
-  UpdateExtensionPref(extension_id, kPrefGrantedPermissionsAll,
-                      Value::CreateBooleanValue(full_access));
+  scoped_ptr<ExtensionPermissionSet> granted_permissions(
+      GetGrantedPermissions(extension_id));
 
-  if (!api_permissions.empty()) {
-    AddToExtensionPrefStringSet(
-        extension_id, kPrefGrantedPermissionsAPI, api_permissions);
+  // The new granted permissions are the union of the already granted
+  // permissions and the newly granted permissions.
+  scoped_ptr<ExtensionPermissionSet> new_perms(
+      ExtensionPermissionSet::CreateUnion(
+          permissions, granted_permissions.get()));
+
+  // Set the API permissions.
+  ListValue* api_values = new ListValue();
+  ExtensionAPIPermissionSet apis = new_perms->apis();
+  ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+  for (ExtensionAPIPermissionSet::const_iterator i = apis.begin();
+       i != apis.end(); ++i) {
+    ExtensionAPIPermission* perm = info->GetByID(*i);
+    if (perm)
+      api_values->Append(Value::CreateStringValue(perm->name()));
+  }
+  UpdateExtensionPref(extension_id, kPrefGrantedAPIs, api_values);
+
+  // Set the explicit host permissions.
+  if (!new_perms->explicit_hosts().is_empty()) {
+    SetExtensionPrefURLPatternSet(extension_id,
+                                  kPrefGrantedExplicitHosts,
+                                  new_perms->explicit_hosts());
   }
 
-  if (!host_extent.is_empty()) {
-    std::set<std::string> host_permissions;
-    ExtentToStringSet(host_extent, &host_permissions);
-
-    AddToExtensionPrefStringSet(
-        extension_id, kPrefGrantedPermissionsHost, host_permissions);
+  // Set the scriptable host permissions.
+  if (!new_perms->scriptable_hosts().is_empty()) {
+    SetExtensionPrefURLPatternSet(extension_id,
+                                  kPrefGrantedScriptableHosts,
+                                  new_perms->scriptable_hosts());
   }
 }
 
 bool ExtensionPrefs::IsIncognitoEnabled(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefIncognitoEnabled);
 }
 
 void ExtensionPrefs::SetIsIncognitoEnabled(const std::string& extension_id,
                                            bool enabled) {
   UpdateExtensionPref(extension_id, kPrefIncognitoEnabled,
@@ skipping 672 matching lines @@
   // Create empty preferences dictionary for each extension (these dictionaries
   // are pruned when persisting the preferences to disk).
   for (ExtensionIdSet::iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     ScopedExtensionPrefUpdate update(prefs_, *ext_id);
     // This creates an empty dictionary if none is stored.
     update.Get();
   }
 
   FixMissingPrefs(extension_ids);
+  MigratePermissions(extension_ids);
+
   // Store extension controlled preference values in the
   // |extension_pref_value_map_|, which then informs the subscribers
   // (ExtensionPrefStores) about the winning values.
   for (ExtensionIdSet::iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     extension_pref_value_map_->RegisterExtension(
         *ext_id,
         GetInstallTime(*ext_id),
         GetExtensionState(*ext_id) == Extension::ENABLED);
     content_settings_store_->RegisterExtension(
@@ skipping 37 matching lines @@
                                  &content_settings)) {
       content_settings_store_->SetExtensionContentSettingsFromList(
           *ext_id, content_settings,
           kExtensionPrefsScopeIncognitoPersistent);
     }
   }
 
   extension_pref_value_map_->NotifyInitializationCompleted();
 }
 
-
 void ExtensionPrefs::SetExtensionControlledPref(
     const std::string& extension_id,
     const std::string& pref_key,
     ExtensionPrefsScope scope,
     Value* value) {
 #ifndef NDEBUG
   const PrefService::Preference* pref =
       pref_service()->FindPreference(pref_key.c_str());
   DCHECK(pref) << "Extension controlled preference key " << pref_key
                << " not registered.";
@@ skipping 96 matching lines @@
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kWebStoreLogin,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }