Remove base::BinaryValue

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 58 matching lines @@
           static_cast<const DictionaryValue&>(node));
 
     default:
       return MakeUnique<Value>(node);
   }
 }
 
 }  // namespace
 
 // static
-std::unique_ptr<BinaryValue> BinaryValue::CreateWithCopiedBuffer(
-    const char* buffer,
-    size_t size) {
-  return MakeUnique<BinaryValue>(std::vector<char>(buffer, buffer + size));
+std::unique_ptr<Value> Value::CreateWithCopiedBuffer(const char* buffer,
+                                                     size_t size) {
+  return MakeUnique<Value>(std::vector<char>(buffer, buffer + size));
 }
 
 Value::Value(const Value& that) {
   InternalCopyConstructFrom(that);
 }
 
 Value::Value(Value&& that) noexcept {
   InternalMoveConstructFrom(std::move(that));
 }
 
@@ skipping 198 matching lines @@
 }
 
 bool Value::GetAsString(StringPiece* out_value) const {
   if (out_value && is_string()) {
     *out_value = *string_value_;
     return true;
   }
   return is_string();
 }
 
-bool Value::GetAsBinary(const BinaryValue** out_value) const {
+bool Value::GetAsBinary(const Value** out_value) const {
   if (out_value && is_blob()) {
     *out_value = this;
     return true;
   }
   return is_blob();
 }
 
 bool Value::GetAsList(ListValue** out_value) {
   if (out_value && is_list()) {
     *out_value = static_cast<ListValue*>(this);
@@ skipping 476 matching lines @@
   if (!IsStringASCII(out)) {
     NOTREACHED();
     return false;
   }
 
   out_value->assign(out);
   return true;
 }
 
 bool DictionaryValue::GetBinary(StringPiece path,
-                                const BinaryValue** out_value) const {
+                                const Value** out_value) const {
   const Value* value;
   bool result = Get(path, &value);
   if (!result || !value->IsType(Type::BINARY))
     return false;
 
   if (out_value)
     *out_value = value;
 
   return true;
 }
 
-bool DictionaryValue::GetBinary(StringPiece path, BinaryValue** out_value) {
+bool DictionaryValue::GetBinary(StringPiece path, Value** out_value) {
   return static_cast<const DictionaryValue&>(*this).GetBinary(
-      path,
-      const_cast<const BinaryValue**>(out_value));
+      path, const_cast<const Value**>(out_value));
 }
 
 bool DictionaryValue::GetDictionary(StringPiece path,
                                     const DictionaryValue** out_value) const {
   const Value* value;
   bool result = Get(path, &value);
   if (!result || !value->IsType(Type::DICTIONARY))
     return false;
 
   if (out_value)
@@ skipping 325 matching lines @@
 }
 
 bool ListValue::GetString(size_t index, string16* out_value) const {
   const Value* value;
   if (!Get(index, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
-bool ListValue::GetBinary(size_t index, const BinaryValue** out_value) const {
+bool ListValue::GetBinary(size_t index, const Value** out_value) const {
   const Value* value;
   bool result = Get(index, &value);
   if (!result || !value->IsType(Type::BINARY))
     return false;
 
   if (out_value)
     *out_value = value;
 
   return true;
 }
 
-bool ListValue::GetBinary(size_t index, BinaryValue** out_value) {
+bool ListValue::GetBinary(size_t index, Value** out_value) {
   return static_cast<const ListValue&>(*this).GetBinary(
-      index,
-      const_cast<const BinaryValue**>(out_value));
+      index, const_cast<const Value**>(out_value));
 }
 
 bool ListValue::GetDictionary(size_t index,
                               const DictionaryValue** out_value) const {
   const Value* value;
   bool result = Get(index, &value);
   if (!result || !value->IsType(Type::DICTIONARY))
     return false;
 
   if (out_value)
@@ skipping 156 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