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

chrome/common/json_schema_validator.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 "chrome/common/json_schema_validator.h"
 
 #include <cfloat>
 #include <cmath>
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 double GetNumberValue(Value* value) {
   double result = 0;
-  if (value->GetAsReal(&result))
+  if (value->GetAsDouble(&result))
     return result;
 
   int int_result = 0;
   if (value->GetAsInteger(&int_result)) {
     return int_result;
   }
 
   CHECK(false) << "Unexpected value type: " << value->GetType();
   return 0;
 }
 
 bool GetNumberFromDictionary(DictionaryValue* value, const std::string& key,
                              double* number) {
-  if (value->GetReal(key, number))
+  if (value->GetDouble(key, number))
     return true;
 
   int int_value = 0;
   if (value->GetInteger(key, &int_value)) {
     *number = int_value;
     return true;
   }
 
   return false;
 }
@@ skipping 46 matching lines @@
 
 // static
 std::string JSONSchemaValidator::GetJSONSchemaType(Value* value) {
   switch (value->GetType()) {
     case Value::TYPE_NULL:
       return "null";
     case Value::TYPE_BOOLEAN:
       return "boolean";
     case Value::TYPE_INTEGER:
       return "integer";
-    case Value::TYPE_REAL: {
+    case Value::TYPE_DOUBLE: {
       double double_value = 0;
-      value->GetAsReal(&double_value);
+      value->GetAsDouble(&double_value);
       if (std::abs(double_value) <= std::pow(2.0, DBL_MANT_DIG) &&
           double_value == floor(double_value)) {
         return "integer";
       } else {
         return "number";
       }
     }
     case Value::TYPE_STRING:
       return "string";
     case Value::TYPE_DICTIONARY:
@@ skipping 149 matching lines @@
     CHECK(choices->Get(i, &choice));
     switch (choice->GetType()) {
       case Value::TYPE_NULL:
       case Value::TYPE_BOOLEAN:
       case Value::TYPE_STRING:
         if (instance->Equals(choice))
           return;
         break;
 
       case Value::TYPE_INTEGER:
-      case Value::TYPE_REAL:
+      case Value::TYPE_DOUBLE:
         if (instance->IsType(Value::TYPE_INTEGER) ||
-            instance->IsType(Value::TYPE_REAL)) {
+            instance->IsType(Value::TYPE_DOUBLE)) {
           if (GetNumberValue(choice) == GetNumberValue(instance))
             return;
         }
         break;
 
       default:
         CHECK(false) << "Unexpected type in enum: " << choice->GetType();
     }
   }
 
@@ skipping 210 matching lines @@
 
   if (*additional_properties_schema) {
     std::string additional_properties_type("any");
     CHECK((*additional_properties_schema)->GetString(
         "type", &additional_properties_type));
     return additional_properties_type == "any";
   } else {
     return default_allow_additional_properties_;
   }
 }