Extensions: Store disable reasons in Sync

extensions/browser/extension_prefs.cc

 // Copyright 2014 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 "extensions/browser/extension_prefs.h"
 
 #include <iterator>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 521 matching lines @@
 }
 
 bool ExtensionPrefs::HasPrefForExtension(
     const std::string& extension_id) const {
   return GetExtensionPref(extension_id) != NULL;
 }
 
 bool ExtensionPrefs::ReadPrefAsURLPatternSet(const std::string& extension_id,
                                              const std::string& pref_key,
                                              URLPatternSet* result,
-                                             int valid_schemes) {
+                                             int valid_schemes) const {
   const base::ListValue* value = NULL;
   if (!ReadPrefAsList(extension_id, pref_key, &value))
     return false;
   const base::DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return false;
   int location;
   if (extension->GetInteger(kPrefLocation, &location) &&
       static_cast<Manifest::Location>(location) == Manifest::COMPONENT) {
     valid_schemes |= URLPattern::SCHEME_CHROMEUI;
@@ skipping 12 matching lines @@
 
 bool ExtensionPrefs::ReadPrefAsBooleanAndReturn(
     const std::string& extension_id,
     const std::string& pref_key) const {
   bool out_value = false;
   return ReadPrefAsBoolean(extension_id, pref_key, &out_value) && out_value;
 }
 
 PermissionSet* ExtensionPrefs::ReadPrefAsPermissionSet(
     const std::string& extension_id,
-    const std::string& pref_key) {
+    const std::string& pref_key) const {
   if (!GetExtensionPref(extension_id))
     return NULL;
 
   // Retrieve the API permissions. Please refer SetExtensionPrefPermissionSet()
   // for api_values format.
   APIPermissionSet apis;
   const base::ListValue* api_values = NULL;
   std::string api_pref = JoinPrefs(pref_key, kPrefAPIs);
   if (ReadPrefAsList(extension_id, api_pref, &api_values)) {
     APIPermissionSet::ParseFromJSON(api_values,
@@ skipping 89 matching lines @@
     const std::string& extension_id) {
   int count = 0;
   ReadPrefAsInteger(extension_id, kPrefAcknowledgePromptCount, &count);
   ++count;
   UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount,
                       new base::FundamentalValue(count));
   return count;
 }
 
 bool ExtensionPrefs::IsExternalExtensionAcknowledged(
-    const std::string& extension_id) {
+    const std::string& extension_id) const {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefExternalAcknowledged);
 }
 
 void ExtensionPrefs::AcknowledgeExternalExtension(
     const std::string& extension_id) {
   DCHECK(crx_file::id_util::IdIsValid(extension_id));
   UpdateExtensionPref(extension_id, kPrefExternalAcknowledged,
                       new base::FundamentalValue(true));
   UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL);
 }
 
 bool ExtensionPrefs::IsBlacklistedExtensionAcknowledged(
-    const std::string& extension_id) {
+    const std::string& extension_id) const {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefBlacklistAcknowledged);
 }
 
 void ExtensionPrefs::AcknowledgeBlacklistedExtension(
     const std::string& extension_id) {
   DCHECK(crx_file::id_util::IdIsValid(extension_id));
   UpdateExtensionPref(extension_id, kPrefBlacklistAcknowledged,
                       new base::FundamentalValue(true));
   UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL);
 }
 
 bool ExtensionPrefs::IsExternalInstallFirstRun(
-    const std::string& extension_id) {
+    const std::string& extension_id) const {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefExternalInstallFirstRun);
 }
 
 void ExtensionPrefs::SetExternalInstallFirstRun(
     const std::string& extension_id) {
   DCHECK(crx_file::id_util::IdIsValid(extension_id));
   UpdateExtensionPref(extension_id, kPrefExternalInstallFirstRun,
                       new base::FundamentalValue(true));
 }
 
 bool ExtensionPrefs::SetAlertSystemFirstRun() {
   if (prefs_->GetBoolean(pref_names::kAlertsInitialized)) {
     return true;
   }
   prefs_->SetBoolean(pref_names::kAlertsInitialized, true);
   return false;
 }
 
 bool ExtensionPrefs::DidExtensionEscalatePermissions(
-    const std::string& extension_id) {
+    const std::string& extension_id) const {
   return ReadPrefAsBooleanAndReturn(extension_id,
                                     kExtensionDidEscalatePermissions);
 }
 
 void ExtensionPrefs::SetDidExtensionEscalatePermissions(
     const Extension* extension, bool did_escalate) {
   UpdateExtensionPref(extension->id(), kExtensionDidEscalatePermissions,
                       new base::FundamentalValue(did_escalate));
 }
 
@@ skipping 10 matching lines @@
     const std::string& extension_id,
     Extension::DisableReason disable_reason) const {
   return (GetDisableReasons(extension_id) & disable_reason) != 0;
 }
 
 void ExtensionPrefs::AddDisableReason(const std::string& extension_id,
                                       Extension::DisableReason disable_reason) {
   ModifyDisableReasons(extension_id, disable_reason, DISABLE_REASON_ADD);
 }
 
+void ExtensionPrefs::AddDisableReasons(const std::string& extension_id,
+                                       int disable_reasons) {
+  ModifyDisableReasons(extension_id, disable_reasons, DISABLE_REASON_ADD);
+}
+
 void ExtensionPrefs::RemoveDisableReason(
     const std::string& extension_id,
     Extension::DisableReason disable_reason) {
   ModifyDisableReasons(extension_id, disable_reason, DISABLE_REASON_REMOVE);
 }
 
 void ExtensionPrefs::ClearDisableReasons(const std::string& extension_id) {
   ModifyDisableReasons(extension_id, Extension::DISABLE_NONE,
                        DISABLE_REASON_CLEAR);
 }
@@ skipping 24 matching lines @@
     UpdateExtensionPref(extension_id,
                         kPrefDisableReasons,
                         new base::FundamentalValue(new_value));
   }
 
   FOR_EACH_OBSERVER(ExtensionPrefsObserver,
                     observer_list_,
                     OnExtensionDisableReasonsChanged(extension_id, new_value));
 }
 
-std::set<std::string> ExtensionPrefs::GetBlacklistedExtensions() {
+std::set<std::string> ExtensionPrefs::GetBlacklistedExtensions() const {
   std::set<std::string> ids;
 
   const base::DictionaryValue* extensions =
       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)) {
@@ skipping 97 matching lines @@
 base::Time ExtensionPrefs::BlacklistLastPingDay() const {
   return ReadTime(prefs_->GetDictionary(kExtensionsBlacklistUpdate),
                   kLastPingDay);
 }
 
 void ExtensionPrefs::SetBlacklistLastPingDay(const base::Time& time) {
   DictionaryPrefUpdate update(prefs_, kExtensionsBlacklistUpdate);
   SaveTime(update.Get(), kLastPingDay, time);
 }
 
-base::Time ExtensionPrefs::LastActivePingDay(const std::string& extension_id) {
+base::Time ExtensionPrefs::LastActivePingDay(
+    const std::string& extension_id) const {
   DCHECK(crx_file::id_util::IdIsValid(extension_id));
   return ReadTime(GetExtensionPref(extension_id), kLastActivePingDay);
 }
 
 void ExtensionPrefs::SetLastActivePingDay(const std::string& extension_id,
                                           const base::Time& time) {
   DCHECK(crx_file::id_util::IdIsValid(extension_id));
   ScopedExtensionPrefUpdate update(prefs_, extension_id);
   SaveTime(update.Get(), kLastActivePingDay, time);
 }
 
-bool ExtensionPrefs::GetActiveBit(const std::string& extension_id) {
+bool ExtensionPrefs::GetActiveBit(const std::string& extension_id) const {
   const base::DictionaryValue* dictionary = GetExtensionPref(extension_id);
   bool result = false;
   if (dictionary && dictionary->GetBoolean(kActiveBit, &result))
     return result;
   return false;
 }
 
 void ExtensionPrefs::SetActiveBit(const std::string& extension_id,
                                   bool active) {
   UpdateExtensionPref(extension_id, kActiveBit,
@@ skipping 72 matching lines @@
 
       UpdateExtensionPref(*ext_id, kPrefDisableReasons,
                           new base::FundamentalValue(new_value));
       // Remove the old disable reason.
       UpdateExtensionPref(*ext_id, kDeprecatedPrefDisableReason, NULL);
     }
   }
 }
 
 PermissionSet* ExtensionPrefs::GetGrantedPermissions(
-    const std::string& extension_id) {
+    const std::string& extension_id) const {
   CHECK(crx_file::id_util::IdIsValid(extension_id));
   return ReadPrefAsPermissionSet(extension_id, kPrefGrantedPermissions);
 }
 
 void ExtensionPrefs::AddGrantedPermissions(
     const std::string& extension_id,
     const PermissionSet* permissions) {
   CHECK(crx_file::id_util::IdIsValid(extension_id));
 
   scoped_refptr<PermissionSet> granted_permissions(
@@ skipping 21 matching lines @@
   // permissions and the newly ungranted permissions.
   scoped_refptr<PermissionSet> new_perms(
       PermissionSet::CreateDifference(
           granted_permissions.get(), permissions));
 
   SetExtensionPrefPermissionSet(
       extension_id, kPrefGrantedPermissions, new_perms.get());
 }
 
 PermissionSet* ExtensionPrefs::GetActivePermissions(
-    const std::string& extension_id) {
+    const std::string& extension_id) const {
   CHECK(crx_file::id_util::IdIsValid(extension_id));
   return ReadPrefAsPermissionSet(extension_id, kPrefActivePermissions);
 }
 
 void ExtensionPrefs::SetActivePermissions(
     const std::string& extension_id,
     const PermissionSet* permissions) {
   SetExtensionPrefPermissionSet(
       extension_id, kPrefActivePermissions, permissions);
 }
 
 void ExtensionPrefs::SetExtensionRunning(const std::string& extension_id,
     bool is_running) {
   base::Value* value = new base::FundamentalValue(is_running);
   UpdateExtensionPref(extension_id, kPrefRunning, value);
 }
 
-bool ExtensionPrefs::IsExtensionRunning(const std::string& extension_id) {
+bool ExtensionPrefs::IsExtensionRunning(const std::string& extension_id) const {
   const base::DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return false;
   bool running = false;
   extension->GetBoolean(kPrefRunning, &running);
   return running;
 }
 
 void ExtensionPrefs::SetIsActive(const std::string& extension_id,
                                  bool is_active) {
   base::Value* value = new base::FundamentalValue(is_active);
   UpdateExtensionPref(extension_id, kIsActive, value);
 }
 
-bool ExtensionPrefs::IsActive(const std::string& extension_id) {
+bool ExtensionPrefs::IsActive(const std::string& extension_id) const {
   const base::DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return false;
   bool is_active = false;
   extension->GetBoolean(kIsActive, &is_active);
   return is_active;
 }
 
 bool ExtensionPrefs::IsIncognitoEnabled(const std::string& extension_id) const {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefIncognitoEnabled);
@@ skipping 40 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);
 }
 
-ExtensionIdList ExtensionPrefs::GetToolbarOrder() {
+ExtensionIdList ExtensionPrefs::GetToolbarOrder() const {
   ExtensionIdList id_list_out;
   GetUserExtensionPrefIntoContainer(pref_names::kToolbar, &id_list_out);
   return id_list_out;
 }
 
 void ExtensionPrefs::SetToolbarOrder(const ExtensionIdList& extension_ids) {
   SetExtensionPrefFromContainer(pref_names::kToolbar, extension_ids);
 }
 
 void ExtensionPrefs::OnExtensionInstalled(
@@ skipping 55 matching lines @@
 }
 
 void ExtensionPrefs::SetExtensionBlacklistState(const std::string& extension_id,
                                                 BlacklistState state) {
   SetExtensionBlacklisted(extension_id, state == BLACKLISTED_MALWARE);
   UpdateExtensionPref(extension_id, kPrefBlacklistState,
                       new base::FundamentalValue(state));
 }
 
 BlacklistState ExtensionPrefs::GetExtensionBlacklistState(
-    const std::string& extension_id) {
+    const std::string& extension_id) const {
   if (IsExtensionBlacklisted(extension_id))
     return BLACKLISTED_MALWARE;
   const base::DictionaryValue* ext_prefs = GetExtensionPref(extension_id);
   int int_value = 0;
   if (ext_prefs && ext_prefs->GetInteger(kPrefBlacklistState, &int_value))
     return static_cast<BlacklistState>(int_value);
 
   return NOT_BLACKLISTED;
 }
 
-std::string ExtensionPrefs::GetVersionString(const std::string& extension_id) {
+std::string ExtensionPrefs::GetVersionString(
+    const std::string& extension_id) const {
   const base::DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return std::string();
 
   std::string version;
   extension->GetString(kPrefVersion, &version);
 
   return version;
 }
 
@@ skipping 276 matching lines @@
   if (ReadPrefAsInteger(extension_id, kPrefCreationFlags, &creation_flags)) {
     if (creation_flags & Extension::IS_EPHEMERAL) {
       creation_flags &= ~static_cast<int>(Extension::IS_EPHEMERAL);
       UpdateExtensionPref(extension_id,
                           kPrefCreationFlags,
                           new base::FundamentalValue(creation_flags));
     }
   }
 }
 
-bool ExtensionPrefs::WasAppDraggedByUser(const std::string& extension_id) {
+bool ExtensionPrefs::WasAppDraggedByUser(
+    const std::string& extension_id) const {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefUserDraggedApp);
 }
 
 void ExtensionPrefs::SetAppDraggedByUser(const std::string& extension_id) {
   UpdateExtensionPref(extension_id, kPrefUserDraggedApp,
                       new base::FundamentalValue(true));
 }
 
 bool ExtensionPrefs::IsFromWebStore(
     const std::string& extension_id) const {
@@ skipping 117 matching lines @@
        i.Advance()) {
     base::DictionaryValue* extension_dict = NULL;
     if (!update_dict->GetDictionary(i.key(), &extension_dict))
       continue;
 
     if (extension_dict->HasKey(kPrefLastLaunchTime))
       extension_dict->Remove(kPrefLastLaunchTime, NULL);
   }
 }
 
-void ExtensionPrefs::GetExtensions(ExtensionIdList* out) {
+void ExtensionPrefs::GetExtensions(ExtensionIdList* out) const {
   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);
   }
 }
 
@@ skipping 78 matching lines @@
   FixMissingPrefs(extension_ids);
   MigratePermissions(extension_ids);
   MigrateDisableReasons(extension_ids);
   app_sorting_->Initialize(extension_ids);
 
   InitExtensionControlledPrefs(extension_pref_value_map_);
 
   extension_pref_value_map_->NotifyInitializationCompleted();
 }
 
-bool ExtensionPrefs::HasIncognitoPrefValue(const std::string& pref_key) {
+bool ExtensionPrefs::HasIncognitoPrefValue(const std::string& pref_key) const {
   bool has_incognito_pref_value = false;
   extension_pref_value_map_->GetEffectivePrefValue(pref_key,
                                                    true,
                                                    &has_incognito_pref_value);
   return has_incognito_pref_value;
 }
 
 const base::DictionaryValue* ExtensionPrefs::GetGeometryCache(
     const std::string& extension_id) const {
   const base::DictionaryValue* extension_prefs = GetExtensionPref(extension_id);
   if (!extension_prefs)
     return NULL;
 
   const base::DictionaryValue* ext = NULL;
   if (!extension_prefs->GetDictionary(kPrefGeometryCache, &ext))
     return NULL;
 
   return ext;
 }
 
 void ExtensionPrefs::SetGeometryCache(
     const std::string& extension_id,
     scoped_ptr<base::DictionaryValue> cache) {
   UpdateExtensionPref(extension_id, kPrefGeometryCache, cache.release());
 }
 
-const base::DictionaryValue* ExtensionPrefs::GetInstallSignature() {
+const base::DictionaryValue* ExtensionPrefs::GetInstallSignature() const {
   return prefs_->GetDictionary(kInstallSignature);
 }
 
 void ExtensionPrefs::SetInstallSignature(
     const base::DictionaryValue* signature) {
   if (signature) {
     prefs_->Set(kInstallSignature, *signature);
     DVLOG(1) << "SetInstallSignature - saving";
   } else {
     DVLOG(1) << "SetInstallSignature - clearing";
@@ skipping 12 matching lines @@
   return install_parameter;
 }
 
 void ExtensionPrefs::SetInstallParam(const std::string& extension_id,
                                      const std::string& install_parameter) {
   UpdateExtensionPref(extension_id,
                       kPrefInstallParam,
                       new base::StringValue(install_parameter));
 }
 
-int ExtensionPrefs::GetCorruptedDisableCount() {
+int ExtensionPrefs::GetCorruptedDisableCount() const {
   return prefs_->GetInteger(kCorruptedDisableCount);
 }
 
 void ExtensionPrefs::IncrementCorruptedDisableCount() {
   int count = prefs_->GetInteger(kCorruptedDisableCount);
   prefs_->SetInteger(kCorruptedDisableCount, count + 1);
 }
 
 ExtensionPrefs::ExtensionPrefs(
     PrefService* prefs,
@@ skipping 24 matching lines @@
     AddObserver(*iter);
   }
 
   InitPrefStore();
 }
 
 void ExtensionPrefs::SetNeedsStorageGarbageCollection(bool value) {
   prefs_->SetBoolean(pref_names::kStorageGarbageCollect, value);
 }
 
-bool ExtensionPrefs::NeedsStorageGarbageCollection() {
+bool ExtensionPrefs::NeedsStorageGarbageCollection() const {
   return prefs_->GetBoolean(pref_names::kStorageGarbageCollect);
 }
 
 // static
 void ExtensionPrefs::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(pref_names::kExtensions);
   registry->RegisterListPref(pref_names::kToolbar,
                              user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
   registry->RegisterIntegerPref(pref_names::kToolbarSize, -1);
@@ skipping 16 matching lines @@
   registry->RegisterIntegerPref(kCorruptedDisableCount, 0);
 
 #if !defined(OS_MACOSX)
   registry->RegisterBooleanPref(pref_names::kAppFullscreenAllowed, true);
 #endif
 }
 
 template <class ExtensionIdContainer>
 bool ExtensionPrefs::GetUserExtensionPrefIntoContainer(
     const char* pref,
-    ExtensionIdContainer* id_container_out) {
+    ExtensionIdContainer* id_container_out) const {
   DCHECK(id_container_out->empty());
 
   const base::Value* user_pref_value = prefs_->GetUserPrefValue(pref);
   const base::ListValue* user_pref_as_list;
   if (!user_pref_value || !user_pref_value->GetAsList(&user_pref_as_list))
     return false;
 
   std::insert_iterator<ExtensionIdContainer> insert_iterator(
       *id_container_out, id_container_out->end());
   std::string extension_id;
@@ skipping 20 matching lines @@
     list_of_values->Append(new base::StringValue(*iter));
   }
 }
 
 void ExtensionPrefs::PopulateExtensionInfoPrefs(
     const Extension* extension,
     const base::Time install_time,
     Extension::State initial_state,
     int install_flags,
     const std::string& install_parameter,
-    base::DictionaryValue* extension_dict) {
+    base::DictionaryValue* extension_dict) const {
   extension_dict->Set(kPrefState, new base::FundamentalValue(initial_state));
   extension_dict->Set(kPrefLocation,
                       new base::FundamentalValue(extension->location()));
   extension_dict->Set(kPrefCreationFlags,
                       new base::FundamentalValue(extension->creation_flags()));
   extension_dict->Set(kPrefFromWebStore,
                       new base::FundamentalValue(extension->from_webstore()));
   extension_dict->Set(kPrefFromBookmark,
                       new base::FundamentalValue(extension->from_bookmark()));
   extension_dict->Set(
@@ skipping 129 matching lines @@
   extension_pref_value_map_->RegisterExtension(
       extension_id, install_time, is_enabled, is_incognito_enabled);
 
   FOR_EACH_OBSERVER(
       ExtensionPrefsObserver,
       observer_list_,
       OnExtensionRegistered(extension_id, install_time, is_enabled));
 }
 
 }  // namespace extensions