Remove FundamentalValue

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 <cmath>
@@ skipping 170 matching lines @@
 bool Value::GetAsDictionary(const DictionaryValue** out_value) const {
   return false;
 }
 
 Value* Value::DeepCopy() const {
   // This method should only be getting called for null Values--all subclasses
   // need to provide their own implementation;.
   switch (type()) {
     case TYPE_NULL:
       return CreateNullValue().release();
-
-    // For now, make FundamentalValues for backward-compatibility. Convert to
-    // Value when that code is deleted.
     case TYPE_BOOLEAN:
-      return new FundamentalValue(bool_value_);
+      return new Value(bool_value_);
     case TYPE_INTEGER:
-      return new FundamentalValue(int_value_);
+      return new Value(int_value_);
     case TYPE_DOUBLE:
-      return new FundamentalValue(double_value_);
+      return new Value(double_value_);
 
     default:
       // All other types should be handled by subclasses.
       NOTREACHED();
       return nullptr;
   }
 }
 
 std::unique_ptr<Value> Value::CreateDeepCopy() const {
   return WrapUnique(DeepCopy());
@@ skipping 29 matching lines @@
 
 Value::Value(Type type) : type_(type) {}
 
 Value::Value(const Value& that) : type_(that.type_) {}
 
 Value& Value::operator=(const Value& that) {
   type_ = that.type_;
   return *this;
 }
 
-///////////////////// FundamentalValue ////////////////////
-
-FundamentalValue::FundamentalValue(bool in_value)
-    : Value(in_value) {
-}
-
-FundamentalValue::FundamentalValue(int in_value)
-    : Value(in_value) {
-}
-
-FundamentalValue::FundamentalValue(double in_value)
-    : Value(in_value) {
-}
-
-FundamentalValue::~FundamentalValue() {
-}
-
 ///////////////////// StringValue ////////////////////
 
 StringValue::StringValue(StringPiece in_value)
     : Value(TYPE_STRING), value_(in_value.as_string()) {
   DCHECK(IsStringUTF8(in_value));
 }
 
 StringValue::StringValue(const string16& in_value)
     : Value(TYPE_STRING),
       value_(UTF16ToUTF8(in_value)) {
@@ skipping 148 matching lines @@
 
   current_dictionary->SetWithoutPathExpansion(current_path,
                                               std::move(in_value));
 }
 
 void DictionaryValue::Set(StringPiece path, Value* in_value) {
   Set(path, WrapUnique(in_value));
 }
 
 void DictionaryValue::SetBoolean(StringPiece path, bool in_value) {
-  Set(path, new FundamentalValue(in_value));
+  Set(path, new Value(in_value));
 }
 
 void DictionaryValue::SetInteger(StringPiece path, int in_value) {
-  Set(path, new FundamentalValue(in_value));
+  Set(path, new Value(in_value));
 }
 
 void DictionaryValue::SetDouble(StringPiece path, double in_value) {
-  Set(path, new FundamentalValue(in_value));
+  Set(path, new Value(in_value));
 }
 
 void DictionaryValue::SetString(StringPiece path, StringPiece in_value) {
   Set(path, new StringValue(in_value));
 }
 
 void DictionaryValue::SetString(StringPiece path, const string16& in_value) {
   Set(path, new StringValue(in_value));
 }
 
 void DictionaryValue::SetWithoutPathExpansion(StringPiece key,
                                               std::unique_ptr<Value> in_value) {
   dictionary_[key.as_string()] = std::move(in_value);
 }
 
 void DictionaryValue::SetWithoutPathExpansion(StringPiece key,
                                               Value* in_value) {
   SetWithoutPathExpansion(key, WrapUnique(in_value));
 }
 
 void DictionaryValue::SetBooleanWithoutPathExpansion(StringPiece path,
                                                      bool in_value) {
-  SetWithoutPathExpansion(path,
-                          base::MakeUnique<base::FundamentalValue>(in_value));
+  SetWithoutPathExpansion(path, new Value(in_value));
 }
 
 void DictionaryValue::SetIntegerWithoutPathExpansion(StringPiece path,
                                                      int in_value) {
-  SetWithoutPathExpansion(path,
-                          base::MakeUnique<base::FundamentalValue>(in_value));
+  SetWithoutPathExpansion(path, new Value(in_value));
 }
 
 void DictionaryValue::SetDoubleWithoutPathExpansion(StringPiece path,
                                                     double in_value) {
-  SetWithoutPathExpansion(path,
-                          base::MakeUnique<base::FundamentalValue>(in_value));
+  SetWithoutPathExpansion(path, new Value(in_value));
 }
 
 void DictionaryValue::SetStringWithoutPathExpansion(StringPiece path,
                                                     StringPiece in_value) {
   SetWithoutPathExpansion(path, base::MakeUnique<base::StringValue>(in_value));
 }
 
 void DictionaryValue::SetStringWithoutPathExpansion(StringPiece path,
                                                     const string16& in_value) {
   SetWithoutPathExpansion(path, base::MakeUnique<base::StringValue>(in_value));
@@ skipping 571 matching lines @@
 }
 
 #if !defined(OS_LINUX)
 void ListValue::Append(Value* in_value) {
   DCHECK(in_value);
   Append(WrapUnique(in_value));
 }
 #endif
 
 void ListValue::AppendBoolean(bool in_value) {
-  Append(MakeUnique<FundamentalValue>(in_value));
+  Append(MakeUnique<Value>(in_value));
 }
 
 void ListValue::AppendInteger(int in_value) {
-  Append(MakeUnique<FundamentalValue>(in_value));
+  Append(MakeUnique<Value>(in_value));
 }
 
 void ListValue::AppendDouble(double in_value) {
-  Append(MakeUnique<FundamentalValue>(in_value));
+  Append(MakeUnique<Value>(in_value));
 }
 
 void ListValue::AppendString(StringPiece in_value) {
   Append(MakeUnique<StringValue>(in_value));
 }
 
 void ListValue::AppendString(const string16& in_value) {
   Append(MakeUnique<StringValue>(in_value));
 }
 
@@ skipping 92 matching lines @@
 ValueDeserializer::~ValueDeserializer() {
 }
 
 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