base: Do not use Value::Create* functions.

base/json/json_parser.cc

 // Copyright (c) 2012 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/json/json_parser.h"
 
 #include "base/float_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
@@ skipping 130 matching lines @@
   // Overridden from base::Value:
   virtual bool GetAsString(std::string* out_value) const OVERRIDE {
     string_piece_.CopyToString(out_value);
     return true;
   }
   virtual bool GetAsString(string16* out_value) const OVERRIDE {
     *out_value = UTF8ToUTF16(string_piece_);
     return true;
   }
   virtual Value* DeepCopy() const OVERRIDE {
-    return Value::CreateStringValue(string_piece_.as_string());
+    return new StringValue(string_piece_.as_string());
   }
   virtual bool Equals(const Value* other) const OVERRIDE {
     std::string other_string;
     return other->IsType(TYPE_STRING) && other->GetAsString(&other_string) &&
         StringPiece(other_string) == string_piece_;
   }
 
  private:
   // The location in the original input stream.
   base::StringPiece string_piece_;
@@ skipping 696 matching lines @@
       return NULL;
   }
 
   pos_ = exit_pos;
   index_ = exit_index;
 
   StringPiece num_string(num_start, end_index - start_index);
 
   int num_int;
   if (StringToInt(num_string, &num_int))
-    return Value::CreateIntegerValue(num_int);
+    return new FundamentalValue(num_int);
 
   double num_double;
   if (base::StringToDouble(num_string.as_string(), &num_double) &&
       IsFinite(num_double)) {
-    return Value::CreateDoubleValue(num_double);
+    return new FundamentalValue(num_double);
   }
 
   return NULL;
 }
 
 bool JSONParser::ReadInt(bool allow_leading_zeros) {
   char first = *pos_;
   int len = 0;
 
   char c = first;
@@ skipping 15 matching lines @@
   switch (*pos_) {
     case 't': {
       const char* kTrueLiteral = "true";
       const int kTrueLen = static_cast<int>(strlen(kTrueLiteral));
       if (!CanConsume(kTrueLen - 1) ||
           !StringsAreEqual(pos_, kTrueLiteral, kTrueLen)) {
         ReportError(JSONReader::JSON_SYNTAX_ERROR, 1);
         return NULL;
       }
       NextNChars(kTrueLen - 1);
-      return Value::CreateBooleanValue(true);
+      return new FundamentalValue(true);
     }
     case 'f': {
       const char* kFalseLiteral = "false";
       const int kFalseLen = static_cast<int>(strlen(kFalseLiteral));
       if (!CanConsume(kFalseLen - 1) ||
           !StringsAreEqual(pos_, kFalseLiteral, kFalseLen)) {
         ReportError(JSONReader::JSON_SYNTAX_ERROR, 1);
         return NULL;
       }
       NextNChars(kFalseLen - 1);
-      return Value::CreateBooleanValue(false);
+      return new FundamentalValue(false);
     }
     case 'n': {
       const char* kNullLiteral = "null";
       const int kNullLen = static_cast<int>(strlen(kNullLiteral));
       if (!CanConsume(kNullLen - 1) ||
           !StringsAreEqual(pos_, kNullLiteral, kNullLen)) {
         ReportError(JSONReader::JSON_SYNTAX_ERROR, 1);
         return NULL;
       }
       NextNChars(kNullLen - 1);
@@ skipping 22 matching lines @@
                                            const std::string& description) {
   if (line || column) {
     return StringPrintf("Line: %i, column: %i, %s",
         line, column, description.c_str());
   }
   return description;
 }
 
 }  // namespace internal
 }  // namespace base