Remove base::StringValue

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 272 matching lines @@
 }
 
 bool Value::GetAsString(string16* out_value) const {
   if (out_value && is_string()) {
     *out_value = UTF8ToUTF16(*string_value_);
     return true;
   }
   return is_string();
 }
 
-bool Value::GetAsString(const StringValue** out_value) const {
+bool Value::GetAsString(const Value** out_value) const {
   if (out_value && is_string()) {
-    *out_value = static_cast<const StringValue*>(this);
+    *out_value = static_cast<const Value*>(this);
     return true;
   }
   return is_string();
 }
 
 bool Value::GetAsString(StringPiece* out_value) const {
   if (out_value && is_string()) {
     *out_value = *string_value_;
     return true;
   }
@@ skipping 46 matching lines @@
   switch (type()) {
     case Type::NONE:
       return CreateNullValue().release();
 
     case Type::BOOLEAN:
       return new Value(bool_value_);
     case Type::INTEGER:
       return new Value(int_value_);
     case Type::DOUBLE:
       return new Value(double_value_);
-    // For now, make StringValues for backward-compatibility. Convert to
-    // Value when that code is deleted.
     case Type::STRING:
-      return new StringValue(*string_value_);
+      return new Value(*string_value_);
     // For now, make BinaryValues for backward-compatibility. Convert to
     // Value when that code is deleted.
     case Type::BINARY:
-      return new BinaryValue(*binary_value_);
+      return new Value(*binary_value_);
 
     // TODO(crbug.com/646113): Clean this up when DictionaryValue and ListValue
     // are completely inlined.
     case Type::DICTIONARY: {
       DictionaryValue* result = new DictionaryValue;
 
       for (const auto& current_entry : **dict_ptr_) {
         result->SetWithoutPathExpansion(current_entry.first,
                                         current_entry.second->CreateDeepCopy());
       }
@@ skipping 296 matching lines @@
 
 void DictionaryValue::SetInteger(StringPiece path, int in_value) {
   Set(path, new Value(in_value));
 }
 
 void DictionaryValue::SetDouble(StringPiece path, double in_value) {
   Set(path, new Value(in_value));
 }
 
 void DictionaryValue::SetString(StringPiece path, StringPiece in_value) {
-  Set(path, new StringValue(in_value));
+  Set(path, new Value(in_value));
 }
 
 void DictionaryValue::SetString(StringPiece path, const string16& in_value) {
-  Set(path, new StringValue(in_value));
+  Set(path, new Value(in_value));
 }
 
 void DictionaryValue::SetWithoutPathExpansion(StringPiece key,
                                               std::unique_ptr<Value> in_value) {
   (**dict_ptr_)[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::Value>(in_value));
 }
 
 void DictionaryValue::SetIntegerWithoutPathExpansion(StringPiece path,
                                                      int in_value) {
   SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
 }
 
 void DictionaryValue::SetDoubleWithoutPathExpansion(StringPiece path,
                                                     double in_value) {
   SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
 }
 
 void DictionaryValue::SetStringWithoutPathExpansion(StringPiece path,
                                                     StringPiece in_value) {
-  SetWithoutPathExpansion(path, base::MakeUnique<base::StringValue>(in_value));
+  SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
 }
 
 void DictionaryValue::SetStringWithoutPathExpansion(StringPiece path,
                                                     const string16& in_value) {
-  SetWithoutPathExpansion(path, base::MakeUnique<base::StringValue>(in_value));
+  SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
 }
 
 bool DictionaryValue::Get(StringPiece path,
                           const Value** out_value) const {
   DCHECK(IsStringUTF8(path));
   StringPiece 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 538 matching lines @@
 
 void ListValue::AppendInteger(int in_value) {
   Append(MakeUnique<Value>(in_value));
 }
 
 void ListValue::AppendDouble(double in_value) {
   Append(MakeUnique<Value>(in_value));
 }
 
 void ListValue::AppendString(StringPiece in_value) {
-  Append(MakeUnique<StringValue>(in_value));
+  Append(MakeUnique<Value>(in_value));
 }
 
 void ListValue::AppendString(const string16& in_value) {
-  Append(MakeUnique<StringValue>(in_value));
+  Append(MakeUnique<Value>(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 55 matching lines @@
 }
 
 std::ostream& operator<<(std::ostream& out, const Value::Type& type) {
   if (static_cast<int>(type) < 0 ||
       static_cast<size_t>(type) >= arraysize(kTypeNames))
     return out << "Invalid Type (index = " << static_cast<int>(type) << ")";
   return out << Value::GetTypeName(type);
 }
 
 }  // namespace base