Remove base::FundamentalValue

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 <stddef.h>
 #include <stdint.h>
 
 #include <iterator>
@@ skipping 649 matching lines @@
                                   new_value.scriptable_hosts());
   }
 }
 
 int ExtensionPrefs::IncrementAcknowledgePromptCount(
     const std::string& extension_id) {
   int count = 0;
   ReadPrefAsInteger(extension_id, kPrefAcknowledgePromptCount, &count);
   ++count;
   UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount,
-                      new base::FundamentalValue(count));
+                      new base::Value(count));
   return count;
 }
 
 bool ExtensionPrefs::IsExternalExtensionAcknowledged(
     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));
+                      new base::Value(true));
   UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL);
 }
 
 bool ExtensionPrefs::IsBlacklistedExtensionAcknowledged(
     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));
+                      new base::Value(true));
   UpdateExtensionPref(extension_id, kPrefAcknowledgePromptCount, NULL);
 }
 
 bool ExtensionPrefs::IsExternalInstallFirstRun(
     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));
+                      new base::Value(true));
 }
 
 bool ExtensionPrefs::SetAlertSystemFirstRun() {
   if (prefs_->GetBoolean(pref_names::kAlertsInitialized)) {
     return true;
   }
   prefs_->SetBoolean(pref_names::kAlertsInitialized, true);
   return false;
 }
 
@@ skipping 66 matching lines @@
       new_value = Extension::DISABLE_NONE;
       break;
   }
 
   if (old_value == new_value)  // no change, return.
     return;
 
   if (new_value == Extension::DISABLE_NONE) {
     UpdateExtensionPref(extension_id, kPrefDisableReasons, NULL);
   } else {
-    UpdateExtensionPref(extension_id,
-                        kPrefDisableReasons,
-                        new base::FundamentalValue(new_value));
+    UpdateExtensionPref(extension_id, kPrefDisableReasons,
+                        new base::Value(new_value));
   }
 
   for (auto& observer : observer_list_)
     observer.OnExtensionDisableReasonsChanged(extension_id, new_value);
 }
 
 std::set<std::string> ExtensionPrefs::GetBlacklistedExtensions() const {
   std::set<std::string> ids;
 
   const base::DictionaryValue* extensions =
@@ skipping 20 matching lines @@
                                              bool is_blacklisted) {
   bool currently_blacklisted = IsExtensionBlacklisted(extension_id);
   if (is_blacklisted == currently_blacklisted)
     return;
 
   // Always make sure the "acknowledged" bit is cleared since the blacklist bit
   // is changing.
   UpdateExtensionPref(extension_id, kPrefBlacklistAcknowledged, NULL);
 
   if (is_blacklisted) {
-    UpdateExtensionPref(extension_id,
-                        kPrefBlacklist,
-                        new base::FundamentalValue(true));
+    UpdateExtensionPref(extension_id, kPrefBlacklist, new base::Value(true));
   } else {
     UpdateExtensionPref(extension_id, kPrefBlacklist, NULL);
     const base::DictionaryValue* dict = GetExtensionPref(extension_id);
     if (dict && dict->empty())
       DeleteExtensionPrefs(extension_id);
   }
 }
 
 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& id) const {
   const base::DictionaryValue* ext_prefs = GetExtensionPref(id);
@@ skipping 84 matching lines @@
 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,
-                      new base::FundamentalValue(active));
+  UpdateExtensionPref(extension_id, kActiveBit, new base::Value(active));
 }
 
 std::unique_ptr<const PermissionSet> ExtensionPrefs::GetGrantedPermissions(
     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) {
@@ skipping 29 matching lines @@
 }
 
 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);
+  base::Value* value = new base::Value(is_running);
   UpdateExtensionPref(extension_id, kPrefRunning, value);
 }
 
 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);
+  base::Value* value = new base::Value(is_active);
   UpdateExtensionPref(extension_id, kIsActive, value);
 }
 
 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);
 }
 
 void ExtensionPrefs::SetIsIncognitoEnabled(const std::string& extension_id,
                                            bool enabled) {
   UpdateExtensionPref(extension_id, kPrefIncognitoEnabled,
-                      new base::FundamentalValue(enabled));
+                      new base::Value(enabled));
   extension_pref_value_map_->SetExtensionIncognitoState(extension_id, enabled);
 }
 
 bool ExtensionPrefs::AllowFileAccess(const std::string& extension_id) const {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefAllowFileAccess);
 }
 
 void ExtensionPrefs::SetAllowFileAccess(const std::string& extension_id,
                                         bool allow) {
   UpdateExtensionPref(extension_id, kPrefAllowFileAccess,
-                      new base::FundamentalValue(allow));
+                      new base::Value(allow));
 }
 
 bool ExtensionPrefs::HasAllowFileAccessSetting(
     const std::string& extension_id) const {
   const base::DictionaryValue* ext = GetExtensionPref(extension_id);
   return ext && ext->HasKey(kPrefAllowFileAccess);
 }
 
 bool ExtensionPrefs::DoesExtensionHaveState(
     const std::string& id, Extension::State check_state) const {
@@ skipping 53 matching lines @@
 void ExtensionPrefs::OnExtensionUninstalled(const std::string& extension_id,
                                             const Manifest::Location& location,
                                             bool external_uninstall) {
   app_sorting()->ClearOrdinals(extension_id);
 
   // For external extensions, we save a preference reminding ourself not to try
   // and install the extension anymore (except when |external_uninstall| is
   // true, which signifies that the registry key was deleted or the pref file
   // no longer lists the extension).
   if (!external_uninstall && Manifest::IsExternalLocation(location)) {
-    UpdateExtensionPref(extension_id, kPrefState,
-                        new base::FundamentalValue(
-                            Extension::EXTERNAL_EXTENSION_UNINSTALLED));
+    UpdateExtensionPref(
+        extension_id, kPrefState,
+        new base::Value(Extension::EXTERNAL_EXTENSION_UNINSTALLED));
     extension_pref_value_map_->SetExtensionState(extension_id, false);
     for (auto& observer : observer_list_)
       observer.OnExtensionStateChanged(extension_id, false);
   } else {
     DeleteExtensionPrefs(extension_id);
   }
 }
 
 void ExtensionPrefs::SetExtensionEnabled(const std::string& extension_id) {
   UpdateExtensionPref(extension_id, kPrefState,
-                      new base::FundamentalValue(Extension::ENABLED));
+                      new base::Value(Extension::ENABLED));
   extension_pref_value_map_->SetExtensionState(extension_id, true);
   UpdateExtensionPref(extension_id, kPrefDisableReasons, nullptr);
   for (auto& observer : observer_list_)
     observer.OnExtensionStateChanged(extension_id, true);
 }
 
 void ExtensionPrefs::SetExtensionDisabled(const std::string& extension_id,
                                           int disable_reasons) {
   if (!IsExternalExtensionUninstalled(extension_id)) {
     UpdateExtensionPref(extension_id, kPrefState,
-                        new base::FundamentalValue(Extension::DISABLED));
+                        new base::Value(Extension::DISABLED));
     extension_pref_value_map_->SetExtensionState(extension_id, false);
   }
   UpdateExtensionPref(extension_id, kPrefDisableReasons,
-                      new base::FundamentalValue(disable_reasons));
+                      new base::Value(disable_reasons));
   for (auto& observer : observer_list_)
     observer.OnExtensionStateChanged(extension_id, false);
 }
 
 void ExtensionPrefs::SetExtensionBlacklistState(const std::string& extension_id,
                                                 BlacklistState state) {
   SetExtensionBlacklisted(extension_id, state == BLACKLISTED_MALWARE);
   UpdateExtensionPref(extension_id, kPrefBlacklistState,
-                      new base::FundamentalValue(state));
+                      new base::Value(state));
 }
 
 BlacklistState ExtensionPrefs::GetExtensionBlacklistState(
     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);
@@ skipping 264 matching lines @@
 
   return extensions_info;
 }
 
 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));
+  UpdateExtensionPref(extension_id, kPrefUserDraggedApp, new base::Value(true));
 }
 
 bool ExtensionPrefs::IsFromWebStore(
     const std::string& extension_id) const {
   const base::DictionaryValue* dictionary = GetExtensionPref(extension_id);
   bool result = false;
   if (dictionary && dictionary->GetBoolean(kPrefFromWebStore, &result))
     return result;
   return false;
 }
@@ skipping 262 matching lines @@
   prefs_->SetInteger(kCorruptedDisableCount, count + 1);
 }
 
 bool ExtensionPrefs::NeedsSync(const std::string& extension_id) const {
   return ReadPrefAsBooleanAndReturn(extension_id, kPrefNeedsSync);
 }
 
 void ExtensionPrefs::SetNeedsSync(const std::string& extension_id,
                                   bool needs_sync) {
   UpdateExtensionPref(extension_id, kPrefNeedsSync,
-                      needs_sync ? new base::FundamentalValue(true) : nullptr);
+                      needs_sync ? new base::Value(true) : nullptr);
 }
 
 ExtensionPrefs::ExtensionPrefs(
     content::BrowserContext* browser_context,
     PrefService* prefs,
     const base::FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map,
     std::unique_ptr<TimeProvider> time_provider,
     bool extensions_disabled,
     const std::vector<ExtensionPrefsObserver*>& early_observers)
@@ skipping 96 matching lines @@
   }
 }
 
 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) const {
-  extension_dict->Set(kPrefState, new base::FundamentalValue(initial_state));
-  extension_dict->Set(kPrefLocation,
-                      new base::FundamentalValue(extension->location()));
+  extension_dict->Set(kPrefState, new base::Value(initial_state));
+  extension_dict->Set(kPrefLocation, new base::Value(extension->location()));
   extension_dict->Set(kPrefCreationFlags,
-                      new base::FundamentalValue(extension->creation_flags()));
+                      new base::Value(extension->creation_flags()));
   extension_dict->Set(kPrefFromWebStore,
-                      new base::FundamentalValue(extension->from_webstore()));
+                      new base::Value(extension->from_webstore()));
   extension_dict->Set(kPrefFromBookmark,
-                      new base::FundamentalValue(extension->from_bookmark()));
-  extension_dict->Set(
-      kPrefWasInstalledByDefault,
-      new base::FundamentalValue(extension->was_installed_by_default()));
-  extension_dict->Set(
-      kPrefWasInstalledByOem,
-      new base::FundamentalValue(extension->was_installed_by_oem()));
+                      new base::Value(extension->from_bookmark()));
+  extension_dict->Set(kPrefWasInstalledByDefault,
+                      new base::Value(extension->was_installed_by_default()));
+  extension_dict->Set(kPrefWasInstalledByOem,
+                      new base::Value(extension->was_installed_by_oem()));
   extension_dict->Set(kPrefInstallTime,
                       new base::StringValue(
                           base::Int64ToString(install_time.ToInternalValue())));
   if (install_flags & kInstallFlagIsBlacklistedForMalware)
-    extension_dict->Set(kPrefBlacklist, new base::FundamentalValue(true));
+    extension_dict->Set(kPrefBlacklist, new base::Value(true));
 
   base::FilePath::StringType path = MakePathRelative(install_directory_,
                                                      extension->path());
   extension_dict->Set(kPrefPath, new base::StringValue(path));
   if (!install_parameter.empty()) {
     extension_dict->Set(kPrefInstallParam,
                         new base::StringValue(install_parameter));
   }
   // We store prefs about LOAD extensions, but don't cache their manifest
   // since it may change on disk.
   if (!Manifest::IsUnpackedLocation(extension->location())) {
     extension_dict->Set(kPrefManifest,
                         extension->manifest()->value()->DeepCopy());
   }
 
   // Only writes kPrefDoNotSync when it is not the default.
   if (install_flags & kInstallFlagDoNotSync)
-    extension_dict->Set(kPrefDoNotSync, new base::FundamentalValue(true));
+    extension_dict->Set(kPrefDoNotSync, new base::Value(true));
   else
     extension_dict->Remove(kPrefDoNotSync, NULL);
 }
 
 void ExtensionPrefs::InitExtensionControlledPrefs(
     ExtensionPrefValueMap* value_map) {
   TRACE_EVENT0("browser,startup",
                "ExtensionPrefs::InitExtensionControlledPrefs")
   SCOPED_UMA_HISTOGRAM_TIMER("Extensions.InitExtensionControlledPrefsTime");
 
@@ skipping 81 matching lines @@
   bool is_incognito_enabled = IsIncognitoEnabled(extension_id);
 
   extension_pref_value_map_->RegisterExtension(
       extension_id, install_time, is_enabled, is_incognito_enabled);
 
   for (auto& observer : observer_list_)
     observer.OnExtensionRegistered(extension_id, install_time, is_enabled);
 }
 
 }  // namespace extensions