Remove base::StringValue

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 1343 matching lines @@
                                       &serialized_ordinal)) {
     suggested_page_ordinal = syncer::StringOrdinal(serialized_ordinal);
     needs_sort_ordinal = true;
     pending_install_dict->Remove(kPrefSuggestedPageOrdinal, NULL);
   }
   pending_install_dict->Remove(kDelayedInstallReason, NULL);
 
   const base::Time install_time = time_provider_->GetCurrentTime();
   pending_install_dict->Set(
       kPrefInstallTime,
-      new base::StringValue(
-          base::Int64ToString(install_time.ToInternalValue())));
+      new base::Value(base::Int64ToString(install_time.ToInternalValue())));
 
   // Commit the delayed install data.
   for (base::DictionaryValue::Iterator it(*pending_install_dict); !it.IsAtEnd();
        it.Advance()) {
     extension_dict->Set(it.key(), it.value().DeepCopy());
   }
   FinishExtensionInfoPrefs(extension_id, install_time, needs_sort_ordinal,
                            suggested_page_ordinal, extension_dict);
   return true;
 }
@@ skipping 311 matching lines @@
   if (!extension)  // Expected during unit testing.
     return std::string();
   std::string install_parameter;
   if (!extension->GetString(kPrefInstallParam, &install_parameter))
     return std::string();
   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));
+  UpdateExtensionPref(extension_id, kPrefInstallParam,
+                      new base::Value(install_parameter));
 }
 
 int ExtensionPrefs::GetCorruptedDisableCount() const {
   return prefs_->GetInteger(kCorruptedDisableCount);
 }
 
 void ExtensionPrefs::IncrementCorruptedDisableCount() {
   int count = prefs_->GetInteger(kCorruptedDisableCount);
   prefs_->SetInteger(kCorruptedDisableCount, count + 1);
 }
@@ skipping 127 matching lines @@
   extension_dict->Set(kPrefCreationFlags,
                       new base::Value(extension->creation_flags()));
   extension_dict->Set(kPrefFromWebStore,
                       new base::Value(extension->from_webstore()));
   extension_dict->Set(kPrefFromBookmark,
                       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())));
+  extension_dict->Set(
+      kPrefInstallTime,
+      new base::Value(base::Int64ToString(install_time.ToInternalValue())));
   if (install_flags & kInstallFlagIsBlacklistedForMalware)
     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));
+  extension_dict->Set(kPrefPath, new base::Value(path));
   if (!install_parameter.empty()) {
-    extension_dict->Set(kPrefInstallParam,
-                        new base::StringValue(install_parameter));
+    extension_dict->Set(kPrefInstallParam, new base::Value(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)
@@ skipping 92 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