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

base/values.cc

 // Copyright (c) 2010 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 "base/values.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
@@ skipping 62 matching lines @@
 FundamentalValue* Value::CreateBooleanValue(bool in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
 FundamentalValue* Value::CreateIntegerValue(int in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
-FundamentalValue* Value::CreateRealValue(double in_value) {
+FundamentalValue* Value::CreateDoubleValue(double in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
 StringValue* Value::CreateStringValue(const std::string& in_value) {
   return new StringValue(in_value);
 }
 
 // static
 StringValue* Value::CreateStringValue(const string16& in_value) {
   return new StringValue(in_value);
 }
 
 // static
 BinaryValue* Value::CreateBinaryValue(char* buffer, size_t size) {
   return BinaryValue::Create(buffer, size);
 }
 
 bool Value::GetAsBoolean(bool* out_value) const {
   return false;
 }
 
 bool Value::GetAsInteger(int* out_value) const {
   return false;
 }
 
-bool Value::GetAsReal(double* out_value) const {
+bool Value::GetAsDouble(double* out_value) const {
   return false;
 }
 
 bool Value::GetAsString(std::string* out_value) const {
   return false;
 }
 
 bool Value::GetAsString(string16* out_value) const {
   return false;
 }
@@ skipping 30 matching lines @@
 
 FundamentalValue::FundamentalValue(bool in_value)
     : Value(TYPE_BOOLEAN), boolean_value_(in_value) {
 }
 
 FundamentalValue::FundamentalValue(int in_value)
     : Value(TYPE_INTEGER), integer_value_(in_value) {
 }
 
 FundamentalValue::FundamentalValue(double in_value)
-    : Value(TYPE_REAL), real_value_(in_value) {
+    : Value(TYPE_DOUBLE), double_value_(in_value) {
 }
 
 FundamentalValue::~FundamentalValue() {
 }
 
 bool FundamentalValue::GetAsBoolean(bool* out_value) const {
   if (out_value && IsType(TYPE_BOOLEAN))
     *out_value = boolean_value_;
   return (IsType(TYPE_BOOLEAN));
 }
 
 bool FundamentalValue::GetAsInteger(int* out_value) const {
   if (out_value && IsType(TYPE_INTEGER))
     *out_value = integer_value_;
   return (IsType(TYPE_INTEGER));
 }
 
-bool FundamentalValue::GetAsReal(double* out_value) const {
-  if (out_value && IsType(TYPE_REAL))
-    *out_value = real_value_;
-  return (IsType(TYPE_REAL));
+bool FundamentalValue::GetAsDouble(double* out_value) const {
+  if (out_value && IsType(TYPE_DOUBLE))
+    *out_value = double_value_;
+  return (IsType(TYPE_DOUBLE));
 }
 
 FundamentalValue* FundamentalValue::DeepCopy() const {
   switch (GetType()) {
     case TYPE_BOOLEAN:
       return CreateBooleanValue(boolean_value_);
 
     case TYPE_INTEGER:
       return CreateIntegerValue(integer_value_);
 
-    case TYPE_REAL:
-      return CreateRealValue(real_value_);
+    case TYPE_DOUBLE:
+      return CreateDoubleValue(double_value_);
 
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 bool FundamentalValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
 
   switch (GetType()) {
     case TYPE_BOOLEAN: {
       bool lhs, rhs;
       return GetAsBoolean(&lhs) && other->GetAsBoolean(&rhs) && lhs == rhs;
     }
     case TYPE_INTEGER: {
       int lhs, rhs;
       return GetAsInteger(&lhs) && other->GetAsInteger(&rhs) && lhs == rhs;
     }
-    case TYPE_REAL: {
+    case TYPE_DOUBLE: {
       double lhs, rhs;
-      return GetAsReal(&lhs) && other->GetAsReal(&rhs) && lhs == rhs;
+      return GetAsDouble(&lhs) && other->GetAsDouble(&rhs) && lhs == rhs;
     }
     default:
       NOTREACHED();
       return false;
   }
 }
 
 ///////////////////// StringValue ////////////////////
 
 StringValue::StringValue(const std::string& in_value)
@@ skipping 132 matching lines @@
 }
 
 void DictionaryValue::SetBoolean(const std::string& path, bool in_value) {
   Set(path, CreateBooleanValue(in_value));
 }
 
 void DictionaryValue::SetInteger(const std::string& path, int in_value) {
   Set(path, CreateIntegerValue(in_value));
 }
 
-void DictionaryValue::SetReal(const std::string& path, double in_value) {
-  Set(path, CreateRealValue(in_value));
+void DictionaryValue::SetDouble(const std::string& path, double in_value) {
+  Set(path, CreateDoubleValue(in_value));
 }
 
 void DictionaryValue::SetString(const std::string& path,
                                 const std::string& in_value) {
   Set(path, CreateStringValue(in_value));
 }
 
 void DictionaryValue::SetString(const std::string& path,
                                 const string16& in_value) {
   Set(path, CreateStringValue(in_value));
@@ skipping 41 matching lines @@
 
 bool DictionaryValue::GetInteger(const std::string& path,
                                  int* out_value) const {
   Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsInteger(out_value);
 }
 
-bool DictionaryValue::GetReal(const std::string& path,
-                              double* out_value) const {
+bool DictionaryValue::GetDouble(const std::string& path,
+                                double* out_value) const {
   Value* value;
   if (!Get(path, &value))
     return false;
 
-  return value->GetAsReal(out_value);
+  return value->GetAsDouble(out_value);
 }
 
 bool DictionaryValue::GetString(const std::string& path,
                                 std::string* out_value) const {
   Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
@@ skipping 76 matching lines @@
 
 bool DictionaryValue::GetIntegerWithoutPathExpansion(const std::string& key,
                                                      int* out_value) const {
   Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsInteger(out_value);
 }
 
-bool DictionaryValue::GetRealWithoutPathExpansion(const std::string& key,
-                                                  double* out_value) const {
+bool DictionaryValue::GetDoubleWithoutPathExpansion(const std::string& key,
+                                                    double* out_value) const {
   Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
-  return value->GetAsReal(out_value);
+  return value->GetAsDouble(out_value);
 }
 
 bool DictionaryValue::GetStringWithoutPathExpansion(
     const std::string& key,
     std::string* out_value) const {
   Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsString(out_value);
@@ skipping 182 matching lines @@
 }
 
 bool ListValue::GetInteger(size_t index, int* out_value) const {
   Value* value;
   if (!Get(index, &value))
     return false;
 
   return value->GetAsInteger(out_value);
 }
 
-bool ListValue::GetReal(size_t index, double* out_value) const {
+bool ListValue::GetDouble(size_t index, double* out_value) const {
   Value* value;
   if (!Get(index, &value))
     return false;
 
-  return value->GetAsReal(out_value);
+  return value->GetAsDouble(out_value);
 }
 
 bool ListValue::GetString(size_t index, std::string* out_value) const {
   Value* value;
   if (!Get(index, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
@@ skipping 124 matching lines @@
       return false;
   }
   if (lhs_it != end() || rhs_it != other_list->end())
     return false;
 
   return true;
 }
 
 ValueSerializer::~ValueSerializer() {
 }