Renamed ExtensionIdSet to ExtensionIds

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"
@@ skipping 728 matching lines @@
                         Value::CreateIntegerValue(new_value));
   }
 }
 
 void ExtensionPrefs::ClearDisableReasons(const std::string& extension_id) {
   UpdateExtensionPref(extension_id, kPrefDisableReasons, NULL);
 }
 
 void ExtensionPrefs::UpdateBlacklist(
     const std::set<std::string>& blacklist_set) {
-  ExtensionIdSet remove_pref_ids;
+  ExtensionIds remove_pref_ids;
   std::set<std::string> used_id_set;
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
 
   if (extensions) {
     for (DictionaryValue::key_iterator extension_id = extensions->begin_keys();
          extension_id != extensions->end_keys(); ++extension_id) {
       const DictionaryValue* ext;
       if (!extensions->GetDictionaryWithoutPathExpansion(*extension_id, &ext)) {
         NOTREACHED() << "Invalid pref for extension " << *extension_id;
         continue;
@@ skipping 108 matching lines @@
     return result;
   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) {
+void ExtensionPrefs::MigratePermissions(const ExtensionIds& extension_ids) {
   PermissionsInfo* info = PermissionsInfo::GetInstance();
-  for (ExtensionIdSet::const_iterator ext_id =
+  for (ExtensionIds::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;
 
@@ skipping 32 matching lines @@
       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());
     }
   }
 }
 
 void ExtensionPrefs::MigrateDisableReasons(
-    const ExtensionIdSet& extension_ids) {
-  for (ExtensionIdSet::const_iterator ext_id =
+    const ExtensionIds& extension_ids) {
+  for (ExtensionIds::const_iterator ext_id =
        extension_ids.begin(); ext_id != extension_ids.end(); ++ext_id) {
     int value = -1;
     if (ReadExtensionPrefInteger(*ext_id, kDeprecatedPrefDisableReason,
                                  &value)) {
       int new_value = Extension::DISABLE_NONE;
       switch (value) {
         case Extension::DEPRECATED_DISABLE_USER_ACTION:
           new_value = Extension::DISABLE_USER_ACTION;
           break;
         case Extension::DEPRECATED_DISABLE_PERMISSIONS_INCREASE:
@@ skipping 420 matching lines @@
 bool ExtensionPrefs::IsExternalExtensionUninstalled(
     const std::string& id) const {
   return DoesExtensionHaveState(id, Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 }
 
 bool ExtensionPrefs::IsExtensionDisabled(
     const std::string& id) const {
   return DoesExtensionHaveState(id, Extension::DISABLED);
 }
 
-ExtensionPrefs::ExtensionIdSet ExtensionPrefs::GetToolbarOrder() {
+ExtensionPrefs::ExtensionIds ExtensionPrefs::GetToolbarOrder() {
   return GetExtensionPrefAsVector(GetToolbarOrderKeyName());
 }
 
-void ExtensionPrefs::SetToolbarOrder(const ExtensionIdSet& extension_ids) {
+void ExtensionPrefs::SetToolbarOrder(const ExtensionIds& extension_ids) {
   SetExtensionPrefFromVector(GetToolbarOrderKeyName(), extension_ids);
 }
 
-ExtensionPrefs::ExtensionIdSet ExtensionPrefs::GetActionBoxOrder() {
+ExtensionPrefs::ExtensionIds ExtensionPrefs::GetActionBoxOrder() {
   return GetExtensionPrefAsVector(kExtensionActionBox);
 }
 
-void ExtensionPrefs::SetActionBoxOrder(const ExtensionIdSet& extension_ids) {
+void ExtensionPrefs::SetActionBoxOrder(const ExtensionIds& extension_ids) {
   SetExtensionPrefFromVector(kExtensionActionBox, extension_ids);
 }
 
 void ExtensionPrefs::OnExtensionInstalled(
     const Extension* extension,
     Extension::State initial_state,
     bool from_webstore,
     const StringOrdinal& page_ordinal) {
   const std::string& id = extension->id();
   CHECK(Extension::IdIsValid(id));
@@ skipping 447 matching lines @@
   }
   std::string install_time_str;
   if (!extension->GetString(kPrefInstallTime, &install_time_str))
     return base::Time();
   int64 install_time_i64 = 0;
   if (!base::StringToInt64(install_time_str, &install_time_i64))
     return base::Time();
   return base::Time::FromInternalValue(install_time_i64);
 }
 
-void ExtensionPrefs::GetExtensions(ExtensionIdSet* out) {
+void ExtensionPrefs::GetExtensions(ExtensionIds* out) {
   CHECK(out);
 
   scoped_ptr<ExtensionsInfo> extensions_info(GetInstalledExtensionsInfo());
 
   for (size_t i = 0; i < extensions_info->size(); ++i) {
     ExtensionInfo* info = extensions_info->at(i).get();
     out->push_back(info->extension_id);
   }
 }
 
 // static
-ExtensionPrefs::ExtensionIdSet ExtensionPrefs::GetExtensionsFrom(
+ExtensionPrefs::ExtensionIds ExtensionPrefs::GetExtensionsFrom(
     const base::DictionaryValue* extension_prefs) {
-  ExtensionIdSet result;
+  ExtensionIds result;
   for (base::DictionaryValue::key_iterator it = extension_prefs->begin_keys();
        it != extension_prefs->end_keys(); ++it) {
     const DictionaryValue* ext;
     if (!extension_prefs->GetDictionaryWithoutPathExpansion(*it, &ext)) {
       NOTREACHED() << "Invalid pref for extension " << *it;
       continue;
     }
     if (!IsBlacklistBitSet(ext))
       result.push_back(*it);
   }
   return result;
 }
 
-void ExtensionPrefs::FixMissingPrefs(const ExtensionIdSet& extension_ids) {
+void ExtensionPrefs::FixMissingPrefs(const ExtensionIds& extension_ids) {
   // Fix old entries that did not get an installation time entry when they
   // were installed or don't have a preferences field.
-  for (ExtensionIdSet::const_iterator ext_id = extension_ids.begin();
+  for (ExtensionIds::const_iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     if (GetInstallTime(*ext_id) == base::Time()) {
       LOG(INFO) << "Could not parse installation time of extension "
                 << *ext_id << ". It was probably installed before setting "
                 << kPrefInstallTime << " was introduced. Updating "
                 << kPrefInstallTime << " to the current time.";
       const base::Time install_time = GetCurrentTime();
       UpdateExtensionPref(*ext_id, kPrefInstallTime, Value::CreateStringValue(
           base::Int64ToString(install_time.ToInternalValue())));
     }
@@ skipping 20 matching lines @@
 }
 
 void ExtensionPrefs::InitPrefStore(bool extensions_disabled) {
   if (extensions_disabled) {
     extension_pref_value_map_->NotifyInitializationCompleted();
     return;
   }
 
   // When this is called, the PrefService is initialized and provides access
   // to the user preferences stored in a JSON file.
-  ExtensionIdSet extension_ids;
+  ExtensionIds extension_ids;
   GetExtensions(&extension_ids);
   // 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();
+  for (ExtensionIds::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);
   MigrateDisableReasons(extension_ids);
   extension_sorting_->Initialize(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();
+  for (ExtensionIds::iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     extension_pref_value_map_->RegisterExtension(
         *ext_id,
         GetInstallTime(*ext_id),
         !IsExtensionDisabled(*ext_id));
     content_settings_store_->RegisterExtension(
         *ext_id,
         GetInstallTime(*ext_id),
         !IsExtensionDisabled(*ext_id));
 
@@ skipping 101 matching lines @@
 
 bool ExtensionPrefs::HasIncognitoPrefValue(const std::string& pref_key) {
   bool has_incognito_pref_value = false;
   extension_pref_value_map_->GetEffectivePrefValue(pref_key,
                                                    true,
                                                    &has_incognito_pref_value);
   return has_incognito_pref_value;
 }
 
 void ExtensionPrefs::ClearIncognitoSessionOnlyContentSettings() {
-  ExtensionIdSet extension_ids;
+  ExtensionIds extension_ids;
   GetExtensions(&extension_ids);
-  for (ExtensionIdSet::iterator ext_id = extension_ids.begin();
+  for (ExtensionIds::iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     content_settings_store_->ClearContentSettingsForExtension(
         *ext_id,
         kExtensionPrefsScopeIncognitoSessionOnly);
   }
 }
 
 URLPatternSet ExtensionPrefs::GetAllowedInstallSites() {
   URLPatternSet result;
   const ListValue* list = prefs_->GetList(prefs::kExtensionAllowedInstallSites);
@@ skipping 41 matching lines @@
   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);
 }
 
-ExtensionPrefs::ExtensionIdSet ExtensionPrefs::GetExtensionPrefAsVector(
+ExtensionPrefs::ExtensionIds ExtensionPrefs::GetExtensionPrefAsVector(
     const char* pref) {
-  ExtensionIdSet extension_ids;
+  ExtensionIds extension_ids;
   const ListValue* list_of_values = prefs_->GetList(pref);
   if (!list_of_values)
     return extension_ids;
 
   std::string extension_id;
   for (size_t i = 0; i < list_of_values->GetSize(); ++i) {
     if (list_of_values->GetString(i, &extension_id))
       extension_ids.push_back(extension_id);
   }
   return extension_ids;
 }
 
 void ExtensionPrefs::SetExtensionPrefFromVector(const char* pref,
-                                                const ExtensionIdSet& strings) {
+                                                const ExtensionIds& strings) {
   ListPrefUpdate update(prefs_, pref);
   ListValue* list_of_values = update.Get();
   list_of_values->Clear();
-  for (ExtensionIdSet::const_iterator iter = strings.begin();
+  for (ExtensionIds::const_iterator iter = strings.begin();
        iter != strings.end(); ++iter)
     list_of_values->Append(new StringValue(*iter));
 }
 
 }  // namespace extensions