more changes

chrome/browser/prefs/pref_service.cc

 // Copyright (c) 2011 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/prefs/pref_service.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 28 matching lines @@
 
 // A helper function for RegisterLocalized*Pref that creates a Value* based on
 // the string value in the locale dll.  Because we control the values in a
 // locale dll, this should always return a Value of the appropriate type.
 Value* CreateLocaleDefaultValue(base::Value::Type type, int message_id) {
   std::string resource_string = l10n_util::GetStringUTF8(message_id);
   DCHECK(!resource_string.empty());
   switch (type) {
     case Value::TYPE_BOOLEAN: {
       if ("true" == resource_string)
-        return Value::CreateBooleanValue(true);
+        return base::TrueValue();
       if ("false" == resource_string)
-        return Value::CreateBooleanValue(false);
+        return base::FalseValue();
       break;
     }
 
     case Value::TYPE_INTEGER: {
       int val;
       base::StringToInt(resource_string, &val);
-      return Value::CreateIntegerValue(val);
+      return base::NumberValue::New(val);
     }
 
     case Value::TYPE_DOUBLE: {
       double val;
       base::StringToDouble(resource_string, &val);
-      return Value::CreateDoubleValue(val);
+      return base::NumberValue::New(val);
     }
 
     case Value::TYPE_STRING: {
-      return Value::CreateStringValue(resource_string);
+      return base::StringValue::New(resource_string);
     }
 
     default: {
       NOTREACHED() <<
           "list and dictionary types cannot have default locale values";
     }
   }
   NOTREACHED();
-  return Value::CreateNullValue();
+  return base::NullValue();
 }
 
 // Forwards a notification after a PostMessage so that we can wait for the
 // MessageLoop to run.
 void NotifyReadError(int message_id) {
   ShowProfileErrorDialog(message_id);
 }
 
 // Shows notifications which correspond to PersistentPrefStore's reading errors.
 class ReadErrorHandler : public PersistentPrefStore::ReadErrorDelegate {
@@ skipping 187 matching lines @@
 }  // namespace
 
 
 // Local State prefs.
 void PrefService::RegisterBooleanPref(const char* path,
                                       bool default_value) {
   // If this fails, the pref service in use is a profile pref service, so the
   // sync status must be provided (see profile pref registration calls below).
   DCHECK(IsLocalStatePrefService(this));
   RegisterPreference(path,
-                     Value::CreateBooleanValue(default_value),
+                     base::BooleanValue::New(default_value),
                      UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterIntegerPref(const char* path, int default_value) {
   // If this fails, the pref service in use is a profile pref service, so the
   // sync status must be provided (see profile pref registration calls below).
   DCHECK(IsLocalStatePrefService(this));
   RegisterPreference(path,
-                     Value::CreateIntegerValue(default_value),
+                     base::NumberValue::New(default_value),
                      UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterDoublePref(const char* path, double default_value) {
   // If this fails, the pref service in use is a profile pref service, so the
   // sync status must be provided (see profile pref registration calls below).
   DCHECK(IsLocalStatePrefService(this));
   RegisterPreference(path,
-                     Value::CreateDoubleValue(default_value),
+                     base::NumberValue::New(default_value),
                      UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterStringPref(const char* path,
                                      const std::string& default_value) {
   // If this fails, the pref service in use is a profile pref service, so the
   // sync status must be provided (see profile pref registration calls below).
   DCHECK(IsLocalStatePrefService(this));
   RegisterPreference(path,
-                     Value::CreateStringValue(default_value),
+                     base::StringValue::New(default_value),
                      UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterFilePathPref(const char* path,
                                        const FilePath& default_value) {
   // If this fails, the pref service in use is a profile pref service, so the
   // sync status must be provided (see profile pref registration calls below).
   DCHECK(IsLocalStatePrefService(this));
   RegisterPreference(path,
-                     Value::CreateStringValue(default_value.value()),
+                     base::StringValue::New(default_value.value()),
                      UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterListPref(const char* path) {
   // If this fails, the pref service in use is a profile pref service, so the
   // sync status must be provided (see profile pref registration calls below).
   DCHECK(IsLocalStatePrefService(this));
   RegisterPreference(path,
                      new ListValue(),
                      UNSYNCABLE_PREF);
@@ skipping 70 matching lines @@
       CreateLocaleDefaultValue(Value::TYPE_STRING, locale_default_message_id),
       UNSYNCABLE_PREF);
 }
 
 void PrefService::RegisterInt64Pref(const char* path, int64 default_value) {
   // If this fails, the pref service in use is a profile pref service, so the
   // sync status must be provided (see profile pref registration calls below).
   DCHECK(IsLocalStatePrefService(this));
   RegisterPreference(
       path,
-      Value::CreateStringValue(base::Int64ToString(default_value)),
+      base::StringValue::New(base::Int64ToString(default_value)),
       UNSYNCABLE_PREF);
 }
 
 // Profile prefs (must use the sync_status variable).
 void PrefService::RegisterBooleanPref(const char* path,
                                       bool default_value,
                                       PrefSyncStatus sync_status) {
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(path,
-                     Value::CreateBooleanValue(default_value),
+                     base::BooleanValue::New(default_value),
                      sync_status);
 }
 
 void PrefService::RegisterIntegerPref(const char* path,
                                       int default_value,
                                       PrefSyncStatus sync_status) {
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(path,
-                     Value::CreateIntegerValue(default_value),
+                     base::NumberValue::New(default_value),
                      sync_status);
 }
 
 void PrefService::RegisterDoublePref(const char* path,
                                      double default_value,
                                      PrefSyncStatus sync_status) {
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(path,
-                     Value::CreateDoubleValue(default_value),
+                     base::NumberValue::New(default_value),
                      sync_status);
 }
 
 void PrefService::RegisterStringPref(const char* path,
                                      const std::string& default_value,
                                      PrefSyncStatus sync_status) {
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(path,
-                     Value::CreateStringValue(default_value),
+                     base::StringValue::New(default_value),
                      sync_status);
 }
 
 void PrefService::RegisterFilePathPref(const char* path,
                                        const FilePath& default_value,
                                        PrefSyncStatus sync_status) {
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(path,
-                     Value::CreateStringValue(default_value.value()),
+                     base::StringValue::New(default_value.value()),
                      sync_status);
 }
 
 void PrefService::RegisterListPref(const char* path,
                                    PrefSyncStatus sync_status) {
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(path, new ListValue(), sync_status);
 }
 
 void PrefService::RegisterListPref(const char* path,
@@ skipping 55 matching lines @@
       CreateLocaleDefaultValue(Value::TYPE_STRING, locale_default_message_id),
       sync_status);
 }
 
 void PrefService::RegisterInt64Pref(const char* path,
                                     int64 default_value,
                                     PrefSyncStatus sync_status) {
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(
       path,
-      Value::CreateStringValue(base::Int64ToString(default_value)),
+      base::StringValue::New(base::Int64ToString(default_value)),
       sync_status);
 }
 
 bool PrefService::GetBoolean(const char* path) const {
   DCHECK(CalledOnValidThread());
 
   bool result = false;
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
@@ skipping 184 matching lines @@
     return;
   }
   user_pref_store_->RemoveValue(path);
 }
 
 void PrefService::Set(const char* path, const Value& value) {
   SetUserPrefValue(path, value.DeepCopy());
 }
 
 void PrefService::SetBoolean(const char* path, bool value) {
-  SetUserPrefValue(path, Value::CreateBooleanValue(value));
+  SetUserPrefValue(path, base::BooleanValue::New(value));
 }
 
 void PrefService::SetInteger(const char* path, int value) {
-  SetUserPrefValue(path, Value::CreateIntegerValue(value));
+  SetUserPrefValue(path, base::NumberValue::New(value));
 }
 
 void PrefService::SetDouble(const char* path, double value) {
-  SetUserPrefValue(path, Value::CreateDoubleValue(value));
+  SetUserPrefValue(path, base::NumberValue::New(value));
 }
 
 void PrefService::SetString(const char* path, const std::string& value) {
-  SetUserPrefValue(path, Value::CreateStringValue(value));
+  SetUserPrefValue(path, base::StringValue::New(value));
 }
 
 void PrefService::SetFilePath(const char* path, const FilePath& value) {
   SetUserPrefValue(path, base::CreateFilePathValue(value));
 }
 
 void PrefService::SetInt64(const char* path, int64 value) {
-  SetUserPrefValue(path, Value::CreateStringValue(base::Int64ToString(value)));
+  SetUserPrefValue(path, base::StringValue::New(base::Int64ToString(value)));
 }
 
 int64 PrefService::GetInt64(const char* path) const {
   DCHECK(CalledOnValidThread());
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     return 0;
   }
@@ skipping 122 matching lines @@
   return pref_value_store()->PrefValueFromDefaultStore(name_.c_str());
 }
 
 bool PrefService::Preference::IsUserModifiable() const {
   return pref_value_store()->PrefValueUserModifiable(name_.c_str());
 }
 
 bool PrefService::Preference::IsExtensionModifiable() const {
   return pref_value_store()->PrefValueExtensionModifiable(name_.c_str());
 }