extensions: Relocate pref name constants.

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 <iterator>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/value_conversions.h"
 #include "chrome/browser/extensions/api/content_settings/content_settings_store.h"
 #include "chrome/browser/extensions/api/preference/preference_api.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
 #include "chrome/browser/extensions/extension_prefs_factory.h"
-#include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "extensions/browser/admin_policy.h"
 #include "extensions/browser/app_sorting.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_info.h"
 #include "extensions/common/url_pattern.h"
@@ skipping 145 matching lines @@
 const char kPrefLastLaunchTime[] = "last_launch_time";
 
 // A list of installed ids and a signature.
 const char kInstallSignature[] = "extensions.install_signature";
 
 // Provider of write access to a dictionary storing extension prefs.
 class ScopedExtensionPrefUpdate : public DictionaryPrefUpdate {
  public:
   ScopedExtensionPrefUpdate(PrefService* service,
                             const std::string& extension_id) :
-    DictionaryPrefUpdate(service, prefs::kExtensionsPref),
+    DictionaryPrefUpdate(service, pref_names::kExtensions),
     extension_id_(extension_id) {}
 
   virtual ~ScopedExtensionPrefUpdate() {
   }
 
   // DictionaryPrefUpdate overrides:
   virtual base::DictionaryValue* Get() OVERRIDE {
     base::DictionaryValue* dict = DictionaryPrefUpdate::Get();
     base::DictionaryValue* extension = NULL;
     if (!dict->GetDictionary(extension_id_, &extension)) {
@@ skipping 39 matching lines @@
 }
 
 //
 // ScopedUpdate
 //
 template <typename T, base::Value::Type type_enum_value>
 ExtensionPrefs::ScopedUpdate<T, type_enum_value>::ScopedUpdate(
     ExtensionPrefs* prefs,
     const std::string& extension_id,
     const std::string& key)
-    : update_(prefs->pref_service(), prefs::kExtensionsPref),
+    : update_(prefs->pref_service(), pref_names::kExtensions),
       extension_id_(extension_id),
       key_(key) {
   DCHECK(Extension::IdIsValid(extension_id_));
 }
 
 template <typename T, base::Value::Type type_enum_value>
 ExtensionPrefs::ScopedUpdate<T, type_enum_value>::~ScopedUpdate() {
 }
 
 template <typename T, base::Value::Type type_enum_value>
@@ skipping 87 matching lines @@
   base::FilePath::StringType retval = child.value().substr(
       parent.value().length());
   if (base::FilePath::IsSeparator(retval[0]))
     return retval.substr(1);
   else
     return retval;
 }
 
 void ExtensionPrefs::MakePathsRelative() {
   const base::DictionaryValue* dict =
-      prefs_->GetDictionary(prefs::kExtensionsPref);
+      prefs_->GetDictionary(pref_names::kExtensions);
   if (!dict || dict->empty())
     return;
 
   // Collect all extensions ids with absolute paths in |absolute_keys|.
   std::set<std::string> absolute_keys;
   for (base::DictionaryValue::Iterator i(*dict); !i.IsAtEnd(); i.Advance()) {
     const base::DictionaryValue* extension_dict = NULL;
     if (!i.value().GetAsDictionary(&extension_dict))
       continue;
     int location_value;
     if (extension_dict->GetInteger(kPrefLocation, &location_value) &&
         Manifest::IsUnpackedLocation(
             static_cast<Manifest::Location>(location_value))) {
       // Unpacked extensions can have absolute paths.
       continue;
     }
     base::FilePath::StringType path_string;
     if (!extension_dict->GetString(kPrefPath, &path_string))
       continue;
     base::FilePath path(path_string);
     if (path.IsAbsolute())
       absolute_keys.insert(i.key());
   }
   if (absolute_keys.empty())
     return;
 
   // Fix these paths.
-  DictionaryPrefUpdate update(prefs_, prefs::kExtensionsPref);
+  DictionaryPrefUpdate update(prefs_, pref_names::kExtensions);
   base::DictionaryValue* update_dict = update.Get();
   for (std::set<std::string>::iterator i = absolute_keys.begin();
        i != absolute_keys.end(); ++i) {
     base::DictionaryValue* extension_dict = NULL;
     if (!update_dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict)) {
       NOTREACHED() << "Control should never reach here for extension " << *i;
       continue;
     }
     base::FilePath::StringType path_string;
     extension_dict->GetString(kPrefPath, &path_string);
     base::FilePath path(path_string);
     extension_dict->SetString(kPrefPath,
         MakePathRelative(install_directory_, path));
   }
 }
 
 const base::DictionaryValue* ExtensionPrefs::GetExtensionPref(
     const std::string& extension_id) const {
   const base::DictionaryValue* extensions =
-      prefs_->GetDictionary(prefs::kExtensionsPref);
+      prefs_->GetDictionary(pref_names::kExtensions);
   const base::DictionaryValue* extension_dict = NULL;
   if (!extensions ||
       !extensions->GetDictionary(extension_id, &extension_dict)) {
     return NULL;
   }
   return extension_dict;
 }
 
 void ExtensionPrefs::UpdateExtensionPref(const std::string& extension_id,
                                          const std::string& key,
                                          base::Value* data_value) {
   if (!Extension::IdIsValid(extension_id)) {
     NOTREACHED() << "Invalid extension_id " << extension_id;
     return;
   }
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
   if (data_value)
     update->Set(key, data_value);
   else
     update->Remove(key, NULL);
 }
 
 void ExtensionPrefs::DeleteExtensionPrefs(const std::string& extension_id) {
   extension_pref_value_map_->UnregisterExtension(extension_id);
   content_settings_store_->UnregisterExtension(extension_id);
-  DictionaryPrefUpdate update(prefs_, prefs::kExtensionsPref);
+  DictionaryPrefUpdate update(prefs_, pref_names::kExtensions);
   base::DictionaryValue* dict = update.Get();
   dict->Remove(extension_id, NULL);
 }
 
 bool ExtensionPrefs::ReadPrefAsBoolean(const std::string& extension_id,
                                        const std::string& pref_key,
                                        bool* out_value) const {
   const base::DictionaryValue* ext = GetExtensionPref(extension_id);
   if (!ext || !ext->GetBoolean(pref_key, out_value))
     return false;
@@ skipping 234 matching lines @@
 }
 
 void ExtensionPrefs::SetWipeoutAcknowledged(
     const std::string& extension_id,
     bool value) {
   UpdateExtensionPref(extension_id, kPrefWipeoutAcknowledged,
                       value ? base::Value::CreateBooleanValue(value) : NULL);
 }
 
 bool ExtensionPrefs::SetAlertSystemFirstRun() {
-  if (prefs_->GetBoolean(prefs::kExtensionAlertsInitializedPref)) {
+  if (prefs_->GetBoolean(pref_names::kAlertsInitialized)) {
     return true;
   }
-  prefs_->SetBoolean(prefs::kExtensionAlertsInitializedPref, true);
+  prefs_->SetBoolean(pref_names::kAlertsInitialized, true);
   return false;
 }
 
 bool ExtensionPrefs::ExtensionsBlacklistedByDefault() const {
   return admin_policy::BlacklistedByDefault(
-      prefs_->GetList(prefs::kExtensionInstallDenyList));
+      prefs_->GetList(pref_names::kInstallDenyList));
 }
 
 bool ExtensionPrefs::DidExtensionEscalatePermissions(
     const std::string& extension_id) {
   return ReadPrefAsBooleanAndReturn(extension_id,
                                     kExtensionDidEscalatePermissions);
 }
 
 void ExtensionPrefs::SetDidExtensionEscalatePermissions(
     const Extension* extension, bool did_escalate) {
@@ skipping 32 matching lines @@
 }
 
 void ExtensionPrefs::ClearDisableReasons(const std::string& extension_id) {
   UpdateExtensionPref(extension_id, kPrefDisableReasons, NULL);
 }
 
 std::set<std::string> ExtensionPrefs::GetBlacklistedExtensions() {
   std::set<std::string> ids;
 
   const base::DictionaryValue* extensions =
-      prefs_->GetDictionary(prefs::kExtensionsPref);
+      prefs_->GetDictionary(pref_names::kExtensions);
   if (!extensions)
     return ids;
 
   for (base::DictionaryValue::Iterator it(*extensions);
        !it.IsAtEnd(); it.Advance()) {
     if (!it.value().IsType(base::Value::TYPE_DICTIONARY)) {
       NOTREACHED() << "Invalid pref for extension " << it.key();
       continue;
     }
     if (IsBlacklistBitSet(
@@ skipping 325 matching lines @@
   return DoesExtensionHaveState(id, Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 }
 
 bool ExtensionPrefs::IsExtensionDisabled(
     const std::string& id) const {
   return DoesExtensionHaveState(id, Extension::DISABLED);
 }
 
 ExtensionIdList ExtensionPrefs::GetToolbarOrder() {
   ExtensionIdList id_list_out;
-  GetUserExtensionPrefIntoContainer(prefs::kExtensionToolbar, &id_list_out);
+  GetUserExtensionPrefIntoContainer(pref_names::kToolbar, &id_list_out);
   return id_list_out;
 }
 
 void ExtensionPrefs::SetToolbarOrder(const ExtensionIdList& extension_ids) {
-  SetExtensionPrefFromContainer(prefs::kExtensionToolbar, extension_ids);
+  SetExtensionPrefFromContainer(pref_names::kToolbar, extension_ids);
 }
 
 bool ExtensionPrefs::GetKnownDisabled(ExtensionIdSet* id_set_out) {
-  return GetUserExtensionPrefIntoContainer(prefs::kExtensionKnownDisabled,
+  return GetUserExtensionPrefIntoContainer(pref_names::kKnownDisabled,
                                            id_set_out);
 }
 
 void ExtensionPrefs::SetKnownDisabled(const ExtensionIdSet& extension_ids) {
-  SetExtensionPrefFromContainer(prefs::kExtensionKnownDisabled, extension_ids);
+  SetExtensionPrefFromContainer(pref_names::kKnownDisabled, extension_ids);
 }
 
 void ExtensionPrefs::OnExtensionInstalled(
     const Extension* extension,
     Extension::State initial_state,
     bool blacklisted_for_malware,
     const syncer::StringOrdinal& page_ordinal) {
   ScopedExtensionPrefUpdate update(prefs_, extension->id());
   base::DictionaryValue* extension_dict = update.Get();
   const base::Time install_time = time_provider_->GetCurrentTime();
@@ skipping 110 matching lines @@
   }
 
   return scoped_ptr<ExtensionInfo>(new ExtensionInfo(
       manifest, extension_id, base::FilePath(path), location));
 }
 
 scoped_ptr<ExtensionInfo> ExtensionPrefs::GetInstalledExtensionInfo(
     const std::string& extension_id) const {
   const base::DictionaryValue* ext = NULL;
   const base::DictionaryValue* extensions =
-      prefs_->GetDictionary(prefs::kExtensionsPref);
+      prefs_->GetDictionary(pref_names::kExtensions);
   if (!extensions ||
       !extensions->GetDictionaryWithoutPathExpansion(extension_id, &ext))
     return scoped_ptr<ExtensionInfo>();
   int state_value;
   if (!ext->GetInteger(kPrefState, &state_value) ||
       state_value == Extension::ENABLED_COMPONENT) {
     // Old preferences files may not have kPrefState for component extensions.
     return scoped_ptr<ExtensionInfo>();
   }
 
   if (state_value == Extension::EXTERNAL_EXTENSION_UNINSTALLED) {
     LOG(WARNING) << "External extension with id " << extension_id
                  << " has been uninstalled by the user";
     return scoped_ptr<ExtensionInfo>();
   }
 
   return GetInstalledInfoHelper(extension_id, ext);
 }
 
 scoped_ptr<ExtensionPrefs::ExtensionsInfo>
 ExtensionPrefs::GetInstalledExtensionsInfo() const {
   scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
 
   const base::DictionaryValue* extensions =
-      prefs_->GetDictionary(prefs::kExtensionsPref);
+      prefs_->GetDictionary(pref_names::kExtensions);
   for (base::DictionaryValue::Iterator extension_id(*extensions);
        !extension_id.IsAtEnd(); extension_id.Advance()) {
     if (!Extension::IdIsValid(extension_id.key()))
       continue;
 
     scoped_ptr<ExtensionInfo> info =
         GetInstalledExtensionInfo(extension_id.key());
     if (info)
       extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
   }
 
   return extensions_info.Pass();
 }
 
 scoped_ptr<ExtensionPrefs::ExtensionsInfo>
 ExtensionPrefs::GetUninstalledExtensionsInfo() const {
   scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
 
   const base::DictionaryValue* extensions =
-      prefs_->GetDictionary(prefs::kExtensionsPref);
+      prefs_->GetDictionary(pref_names::kExtensions);
   for (base::DictionaryValue::Iterator extension_id(*extensions);
        !extension_id.IsAtEnd(); extension_id.Advance()) {
     const base::DictionaryValue* ext = NULL;
     if (!Extension::IdIsValid(extension_id.key()) ||
         !IsExternalExtensionUninstalled(extension_id.key()) ||
         !extension_id.value().GetAsDictionary(&ext))
       continue;
 
     scoped_ptr<ExtensionInfo> info =
         GetInstalledInfoHelper(extension_id.key(), ext);
@@ skipping 109 matching lines @@
     return DELAY_REASON_NONE;
 
   return static_cast<DelayReason>(delay_reason);
 }
 
 scoped_ptr<ExtensionPrefs::ExtensionsInfo> ExtensionPrefs::
     GetAllDelayedInstallInfo() const {
   scoped_ptr<ExtensionsInfo> extensions_info(new ExtensionsInfo);
 
   const base::DictionaryValue* extensions =
-      prefs_->GetDictionary(prefs::kExtensionsPref);
+      prefs_->GetDictionary(pref_names::kExtensions);
   for (base::DictionaryValue::Iterator extension_id(*extensions);
        !extension_id.IsAtEnd(); extension_id.Advance()) {
     if (!Extension::IdIsValid(extension_id.key()))
       continue;
 
     scoped_ptr<ExtensionInfo> info = GetDelayedInstallInfo(extension_id.key());
     if (info)
       extensions_info->push_back(linked_ptr<ExtensionInfo>(info.release()));
   }
 
@@ skipping 111 matching lines @@
   }
 }
 
 // static
 ExtensionIdList ExtensionPrefs::GetExtensionsFrom(
     const PrefService* pref_service) {
   ExtensionIdList result;
 
   const base::DictionaryValue* extension_prefs = NULL;
   const base::Value* extension_prefs_value =
-      pref_service->GetUserPrefValue(prefs::kExtensionsPref);
+      pref_service->GetUserPrefValue(pref_names::kExtensions);
   if (!extension_prefs_value ||
       !extension_prefs_value->GetAsDictionary(&extension_prefs)) {
     return result;  // Empty set
   }
 
   for (base::DictionaryValue::Iterator it(*extension_prefs); !it.IsAtEnd();
        it.Advance()) {
     const base::DictionaryValue* ext = NULL;
     if (!it.value().GetAsDictionary(&ext)) {
       NOTREACHED() << "Invalid pref for extension " << it.key();
@@ skipping 57 matching lines @@
   bool has_incognito_pref_value = false;
   extension_pref_value_map_->GetEffectivePrefValue(pref_key,
                                                    true,
                                                    &has_incognito_pref_value);
   return has_incognito_pref_value;
 }
 
 URLPatternSet ExtensionPrefs::GetAllowedInstallSites() {
   URLPatternSet result;
   const base::ListValue* list =
-      prefs_->GetList(prefs::kExtensionAllowedInstallSites);
+      prefs_->GetList(pref_names::kAllowedInstallSites);
   CHECK(list);
 
   for (size_t i = 0; i < list->GetSize(); ++i) {
     std::string entry_string;
     URLPattern entry(URLPattern::SCHEME_ALL);
     if (!list->GetString(i, &entry_string) ||
         entry.Parse(entry_string) != URLPattern::PARSE_SUCCESS) {
       LOG(ERROR) << "Invalid value for preference: "
-                 << prefs::kExtensionAllowedInstallSites
-                 << "." << i;
+                 << pref_names::kAllowedInstallSites << "." << i;
       continue;
     }
     result.AddPattern(entry);
   }
 
   return result;
 }
 
 const base::DictionaryValue* ExtensionPrefs::GetGeometryCache(
     const std::string& extension_id) const {
@@ skipping 43 matching lines @@
       app_sorting_(app_sorting.Pass()),
       content_settings_store_(new ContentSettingsStore()),
       time_provider_(time_provider.Pass()),
       extensions_disabled_(extensions_disabled) {
   app_sorting_->SetExtensionScopedPrefs(this),
   MakePathsRelative();
   InitPrefStore();
 }
 
 void ExtensionPrefs::SetNeedsStorageGarbageCollection(bool value) {
-  prefs_->SetBoolean(prefs::kExtensionStorageGarbageCollect, value);
+  prefs_->SetBoolean(pref_names::kStorageGarbageCollect, value);
 }
 
 bool ExtensionPrefs::NeedsStorageGarbageCollection() {
-  return prefs_->GetBoolean(prefs::kExtensionStorageGarbageCollect);
+  return prefs_->GetBoolean(pref_names::kStorageGarbageCollect);
 }
 
 // static
 void ExtensionPrefs::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(
-      prefs::kExtensionsPref,
+      pref_names::kExtensions,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterListPref(prefs::kExtensionToolbar,
+  registry->RegisterListPref(pref_names::kToolbar,
                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterIntegerPref(
-      prefs::kExtensionToolbarSize,
+      pref_names::kToolbarSize,
       -1,  // default value
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterDictionaryPref(
       kExtensionsBlacklistUpdate,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterListPref(prefs::kExtensionInstallAllowList,
+  registry->RegisterListPref(pref_names::kInstallAllowList,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterListPref(prefs::kExtensionInstallDenyList,
+  registry->RegisterListPref(pref_names::kInstallDenyList,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterDictionaryPref(
-      prefs::kExtensionInstallForceList,
+      pref_names::kInstallForceList,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterListPref(prefs::kExtensionAllowedTypes,
+  registry->RegisterListPref(pref_names::kAllowedTypes,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterStringPref(
-      prefs::kExtensionBlacklistUpdateVersion,
-      "0",  // default value
-      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterBooleanPref(
-      prefs::kExtensionStorageGarbageCollect,
+      pref_names::kStorageGarbageCollect,
       false,  // default value
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterInt64Pref(
-      prefs::kLastExtensionsUpdateCheck,
+      pref_names::kLastUpdateCheck,
       0,  // default value
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterInt64Pref(
-      prefs::kNextExtensionsUpdateCheck,
+      pref_names::kNextUpdateCheck,
       0,  // default value
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterListPref(prefs::kExtensionAllowedInstallSites,
+  registry->RegisterListPref(pref_names::kAllowedInstallSites,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterStringPref(
-      prefs::kExtensionsLastChromeVersion,
+      pref_names::kLastChromeVersion,
       std::string(),  // default value
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterListPref(prefs::kExtensionKnownDisabled,
+  registry->RegisterListPref(pref_names::kKnownDisabled,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 #if defined(TOOLKIT_VIEWS)
   registry->RegisterIntegerPref(
-      prefs::kBrowserActionContainerWidth,
+      pref_names::kBrowserActionContainerWidth,
       0,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 #endif
   registry->RegisterDictionaryPref(
       kInstallSignature,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 
-  registry->RegisterListPref(prefs::kNativeMessagingBlacklist,
+  registry->RegisterListPref(pref_names::kNativeMessagingBlacklist,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
-  registry->RegisterListPref(prefs::kNativeMessagingWhitelist,
+  registry->RegisterListPref(pref_names::kNativeMessagingWhitelist,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 template <class ExtensionIdContainer>
 bool ExtensionPrefs::GetUserExtensionPrefIntoContainer(
     const char* pref,
     ExtensionIdContainer* id_container_out) {
   DCHECK(id_container_out->empty());
 
   const base::Value* user_pref_value = prefs_->GetUserPrefValue(pref);
@@ skipping 118 matching lines @@
     is_enabled = initial_state == Extension::ENABLED;
   }
 
   extension_pref_value_map_->RegisterExtension(extension_id, install_time,
                                                is_enabled);
   content_settings_store_->RegisterExtension(extension_id, install_time,
                                              is_enabled);
 }
 
 }  // namespace extensions