Get rid of some uses of base::Create*Value

base/values.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/values.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <ostream>
@@ skipping 207 matching lines @@
   if (out_value && IsType(TYPE_DOUBLE))
     *out_value = double_value_;
   else if (out_value && IsType(TYPE_INTEGER))
     *out_value = integer_value_;
   return (IsType(TYPE_DOUBLE) || IsType(TYPE_INTEGER));
 }
 
 FundamentalValue* FundamentalValue::DeepCopy() const {
   switch (GetType()) {
     case TYPE_BOOLEAN:
-      return CreateBooleanValue(boolean_value_);
+      return new FundamentalValue(boolean_value_);
 
     case TYPE_INTEGER:
-      return CreateIntegerValue(integer_value_);
+      return new FundamentalValue(integer_value_);
 
     case TYPE_DOUBLE:
-      return CreateDoubleValue(double_value_);
+      return new FundamentalValue(double_value_);
 
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 bool FundamentalValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
@@ skipping 39 matching lines @@
   return true;
 }
 
 bool StringValue::GetAsString(string16* out_value) const {
   if (out_value)
     *out_value = UTF8ToUTF16(value_);
   return true;
 }
 
 StringValue* StringValue::DeepCopy() const {
-  return CreateStringValue(value_);
+  return new StringValue(value_);
 }
 
 bool StringValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
   std::string lhs, rhs;
   return GetAsString(&lhs) && other->GetAsString(&rhs) && lhs == rhs;
 }
 
 ///////////////////// BinaryValue ////////////////////
@@ skipping 91 matching lines @@
     }
 
     current_dictionary = child_dictionary;
     current_path.erase(0, delimiter_position + 1);
   }
 
   current_dictionary->SetWithoutPathExpansion(current_path, in_value);
 }
 
 void DictionaryValue::SetBoolean(const std::string& path, bool in_value) {
-  Set(path, CreateBooleanValue(in_value));
+  Set(path, new FundamentalValue(in_value));
 }
 
 void DictionaryValue::SetInteger(const std::string& path, int in_value) {
-  Set(path, CreateIntegerValue(in_value));
+  Set(path, new FundamentalValue(in_value));
 }
 
 void DictionaryValue::SetDouble(const std::string& path, double in_value) {
-  Set(path, CreateDoubleValue(in_value));
+  Set(path, new FundamentalValue(in_value));
 }
 
 void DictionaryValue::SetString(const std::string& path,
                                 const std::string& in_value) {
-  Set(path, CreateStringValue(in_value));
+  Set(path, new StringValue(in_value));
 }
 
 void DictionaryValue::SetString(const std::string& path,
                                 const string16& in_value) {
-  Set(path, CreateStringValue(in_value));
+  Set(path, new StringValue(in_value));
 }
 
 void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
                                               Value* in_value) {
   // If there's an existing value here, we need to delete it, because
   // we own all our children.
   std::pair<ValueMap::iterator, bool> ins_res =
       dictionary_.insert(std::make_pair(key, in_value));
   if (!ins_res.second) {
     DCHECK_NE(ins_res.first->second, in_value);  // This would be bogus
     delete ins_res.first->second;
     ins_res.first->second = in_value;
   }
 }
 
 void DictionaryValue::SetBooleanWithoutPathExpansion(
     const std::string& path, bool in_value) {
-  SetWithoutPathExpansion(path, CreateBooleanValue(in_value));
+  SetWithoutPathExpansion(path, new FundamentalValue(in_value));
 }
 
 void DictionaryValue::SetIntegerWithoutPathExpansion(
     const std::string& path, int in_value) {
-  SetWithoutPathExpansion(path, CreateIntegerValue(in_value));
+  SetWithoutPathExpansion(path, new FundamentalValue(in_value));
 }
 
 void DictionaryValue::SetDoubleWithoutPathExpansion(
     const std::string& path, double in_value) {
-  SetWithoutPathExpansion(path, CreateDoubleValue(in_value));
+  SetWithoutPathExpansion(path, new FundamentalValue(in_value));
 }
 
 void DictionaryValue::SetStringWithoutPathExpansion(
     const std::string& path, const std::string& in_value) {
-  SetWithoutPathExpansion(path, CreateStringValue(in_value));
+  SetWithoutPathExpansion(path, new StringValue(in_value));
 }
 
 void DictionaryValue::SetStringWithoutPathExpansion(
     const std::string& path, const string16& in_value) {
-  SetWithoutPathExpansion(path, CreateStringValue(in_value));
+  SetWithoutPathExpansion(path, new StringValue(in_value));
 }
 
 bool DictionaryValue::Get(const std::string& path,
                           const Value** out_value) const {
   DCHECK(IsStringUTF8(path));
   std::string current_path(path);
   const DictionaryValue* current_dictionary = this;
   for (size_t delimiter_position = current_path.find('.');
        delimiter_position != std::string::npos;
        delimiter_position = current_path.find('.')) {
@@ skipping 545 matching lines @@
 
   return list_.erase(iter);
 }
 
 void ListValue::Append(Value* in_value) {
   DCHECK(in_value);
   list_.push_back(in_value);
 }
 
 void ListValue::AppendBoolean(bool in_value) {
-  Append(CreateBooleanValue(in_value));
+  Append(new FundamentalValue(in_value));
 }
 
 void ListValue::AppendInteger(int in_value) {
-  Append(CreateIntegerValue(in_value));
+  Append(new FundamentalValue(in_value));
 }
 
 void ListValue::AppendDouble(double in_value) {
-  Append(CreateDoubleValue(in_value));
+  Append(new FundamentalValue(in_value));
 }
 
 void ListValue::AppendString(const std::string& in_value) {
-  Append(CreateStringValue(in_value));
+  Append(new StringValue(in_value));
 }
 
 void ListValue::AppendString(const string16& in_value) {
-  Append(CreateStringValue(in_value));
+  Append(new StringValue(in_value));
 }
 
 void ListValue::AppendStrings(const std::vector<std::string>& in_values) {
   for (std::vector<std::string>::const_iterator it = in_values.begin();
        it != in_values.end(); ++it) {
     AppendString(*it);
   }
 }
 
 void ListValue::AppendStrings(const std::vector<string16>& in_values) {
@@ skipping 77 matching lines @@
 
 std::ostream& operator<<(std::ostream& out, const Value& value) {
   std::string json;
   JSONWriter::WriteWithOptions(&value,
                                JSONWriter::OPTIONS_PRETTY_PRINT,
                                &json);
   return out << json;
 }
 
 }  // namespace base