Rename Real* to Double* in values.* and dependent files

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 38 matching lines @@
         return Value::CreateBooleanValue(false);
       break;
     }
 
     case Value::TYPE_INTEGER: {
       int val;
       base::StringToInt(resource_string, &val);
       return Value::CreateIntegerValue(val);
     }
 
-    case Value::TYPE_REAL: {
+    case Value::TYPE_DOUBLE: {
       double val;
       base::StringToDouble(resource_string, &val);
-      return Value::CreateRealValue(val);
+      return Value::CreateDoubleValue(val);
     }
 
     case Value::TYPE_STRING: {
       return Value::CreateStringValue(resource_string);
     }
 
     default: {
       NOTREACHED() <<
           "list and dictionary types cannot have default locale values";
     }
@@ skipping 147 matching lines @@
 
 void PrefService::RegisterBooleanPref(const char* path,
                                       bool default_value) {
   RegisterPreference(path, Value::CreateBooleanValue(default_value));
 }
 
 void PrefService::RegisterIntegerPref(const char* path, int default_value) {
   RegisterPreference(path, Value::CreateIntegerValue(default_value));
 }
 
-void PrefService::RegisterRealPref(const char* path, double default_value) {
-  RegisterPreference(path, Value::CreateRealValue(default_value));
+void PrefService::RegisterDoublePref(const char* path, double default_value) {
+  RegisterPreference(path, Value::CreateDoubleValue(default_value));
 }
 
 void PrefService::RegisterStringPref(const char* path,
                                      const std::string& default_value) {
   RegisterPreference(path, Value::CreateStringValue(default_value));
 }
 
 void PrefService::RegisterFilePathPref(const char* path,
                                        const FilePath& default_value) {
   RegisterPreference(path, Value::CreateStringValue(default_value.value()));
@@ skipping 14 matching lines @@
       CreateLocaleDefaultValue(Value::TYPE_BOOLEAN, locale_default_message_id));
 }
 
 void PrefService::RegisterLocalizedIntegerPref(const char* path,
                                                int locale_default_message_id) {
   RegisterPreference(
       path,
       CreateLocaleDefaultValue(Value::TYPE_INTEGER, locale_default_message_id));
 }
 
-void PrefService::RegisterLocalizedRealPref(const char* path,
-                                            int locale_default_message_id) {
+void PrefService::RegisterLocalizedDoublePref(const char* path,
+                                              int locale_default_message_id) {
   RegisterPreference(
       path,
-      CreateLocaleDefaultValue(Value::TYPE_REAL, locale_default_message_id));
+      CreateLocaleDefaultValue(Value::TYPE_DOUBLE, locale_default_message_id));
 }
 
 void PrefService::RegisterLocalizedStringPref(const char* path,
                                               int locale_default_message_id) {
   RegisterPreference(
       path,
       CreateLocaleDefaultValue(Value::TYPE_STRING, locale_default_message_id));
 }
 
 bool PrefService::GetBoolean(const char* path) const {
@@ skipping 19 matching lines @@
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     return result;
   }
   bool rv = pref->GetValue()->GetAsInteger(&result);
   DCHECK(rv);
   return result;
 }
 
-double PrefService::GetReal(const char* path) const {
+double PrefService::GetDouble(const char* path) const {
   DCHECK(CalledOnValidThread());
 
   double result = 0.0;
 
   const Preference* pref = FindPreference(path);
   if (!pref) {
     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     return result;
   }
-  bool rv = pref->GetValue()->GetAsReal(&result);
+  bool rv = pref->GetValue()->GetAsDouble(&result);
   DCHECK(rv);
   return result;
 }
 
 std::string PrefService::GetString(const char* path) const {
   DCHECK(CalledOnValidThread());
 
   std::string result;
 
   const Preference* pref = FindPreference(path);
@@ skipping 156 matching lines @@
 }
 
 void PrefService::SetBoolean(const char* path, bool value) {
   SetUserPrefValue(path, Value::CreateBooleanValue(value));
 }
 
 void PrefService::SetInteger(const char* path, int value) {
   SetUserPrefValue(path, Value::CreateIntegerValue(value));
 }
 
-void PrefService::SetReal(const char* path, double value) {
-  SetUserPrefValue(path, Value::CreateRealValue(value));
+void PrefService::SetDouble(const char* path, double value) {
+  SetUserPrefValue(path, Value::CreateDoubleValue(value));
 }
 
 void PrefService::SetString(const char* path, const std::string& value) {
   SetUserPrefValue(path, Value::CreateStringValue(value));
 }
 
 void PrefService::SetFilePath(const char* path, const FilePath& value) {
 #if defined(OS_POSIX)
   // Value::SetString only knows about UTF8 strings, so convert the path from
   // the system native value to UTF8.
@@ skipping 166 matching lines @@
 
 bool PrefService::Preference::IsDefaultValue() const {
   return pref_service_->pref_value_store_->
       PrefValueFromDefaultStore(name_.c_str());
 }
 
 bool PrefService::Preference::IsUserModifiable() const {
   return pref_service_->pref_value_store_->
       PrefValueUserModifiable(name_.c_str());
 }