Inline base::BinaryValue into base::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 <cmath>
@@ skipping 60 matching lines @@
     default:
       return node.CreateDeepCopy();
   }
 }
 
 // TODO(crbug.com/646113): Remove this once all types are implemented.
 bool IsAssignmentSafe(Value::Type lhs, Value::Type rhs) {
   auto IsImplemented = [](Value::Type type) {
     return type == Value::Type::NONE || type == Value::Type::BOOLEAN ||
            type == Value::Type::INTEGER || type == Value::Type::DOUBLE ||
-           type == Value::Type::STRING;
+           type == Value::Type::STRING || type == Value::Type::BINARY;
   };
 
   return lhs == rhs || (IsImplemented(lhs) && IsImplemented(rhs));
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<Value> Value::CreateNullValue() {
   return WrapUnique(new Value(Type::NONE));
 }
 
+// static
+std::unique_ptr<BinaryValue> BinaryValue::CreateWithCopiedBuffer(
+    const char* buffer,
+    size_t size) {
+  return MakeUnique<BinaryValue>(std::vector<char>(buffer, buffer + size));
+}
+
 Value::Value(const Value& that) {
   InternalCopyConstructFrom(that);
 }
 
 Value::Value(Value&& that) {
   InternalMoveConstructFrom(std::move(that));
 }
 
 Value::Value() : type_(Type::NONE) {}
 
 Value::Value(Type type) : type_(type) {
   // Initialize with the default value.
   switch (type_) {
     case Type::NONE:
       return;
 
     case Type::BOOLEAN:
       bool_value_ = false;
       return;
     case Type::INTEGER:
       int_value_ = 0;
       return;
     case Type::DOUBLE:
       double_value_ = 0.0;
       return;
     case Type::STRING:
       string_value_.Init();
       return;
+    case Type::BINARY:
+      binary_value_.Init();
+      return;
 
     // TODO(crbug.com/646113): Implement these once the corresponding derived
     // classes are removed.
-    case Type::BINARY:
     case Type::LIST:
     case Type::DICTIONARY:
       return;
   }
 }
 
 Value::Value(bool in_bool) : type_(Type::BOOLEAN), bool_value_(in_bool) {}
 
 Value::Value(int in_int) : type_(Type::INTEGER), int_value_(in_int) {}
 
@@ skipping 23 matching lines @@
 Value::Value(const char16* in_string) : type_(Type::STRING) {
   string_value_.Init(UTF16ToUTF8(in_string));
 }
 
 Value::Value(const string16& in_string) : type_(Type::STRING) {
   string_value_.Init(UTF16ToUTF8(in_string));
 }
 
 Value::Value(StringPiece in_string) : Value(in_string.as_string()) {}
 
+Value::Value(const std::vector<char>& in_blob) : type_(Type::BINARY) {
+  binary_value_.Init(in_blob);
+}
+
+Value::Value(std::vector<char>&& in_blob) : type_(Type::BINARY) {
+  binary_value_.Init(std::move(in_blob));
+}
+
 Value& Value::operator=(const Value& that) {
   if (this != &that) {
     DCHECK(IsAssignmentSafe(type_, that.type_));
     if (type_ == that.type_) {
       InternalCopyAssignFrom(that);
     } else {
       InternalCleanup();
       InternalCopyConstructFrom(that);
     }
   }
@@ skipping 43 matching lines @@
     return int_value_;
   CHECK(false);
   return 0.0;
 }
 
 const std::string& Value::GetString() const {
   CHECK(is_string());
   return *string_value_;
 }
 
+const std::vector<char>& Value::GetBlob() const {
+  CHECK(is_blob());
+  return *binary_value_;
+}
+
+size_t Value::GetSize() const {
+  return GetBlob().size();
+}
+
+const char* Value::GetBuffer() const {
+  return GetBlob().data();
+}
+
 bool Value::GetAsBoolean(bool* out_value) const {
   if (out_value && is_bool()) {
     *out_value = bool_value_;
     return true;
   }
   return is_bool();
 }
 
 bool Value::GetAsInteger(int* out_value) const {
   if (out_value && is_int()) {
@@ skipping 41 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 {
-  return false;
+  if (out_value && is_blob()) {
+    *out_value = this;
+    return true;
+  }
+  return is_blob();
 }
 
 bool Value::GetAsList(ListValue** out_value) {
   return false;
 }
 
 bool Value::GetAsList(const ListValue** out_value) const {
   return false;
 }
 
@@ skipping 17 matching lines @@
     case Type::BOOLEAN:
       return new FundamentalValue(bool_value_);
     case Type::INTEGER:
       return new FundamentalValue(int_value_);
     case Type::DOUBLE:
       return new FundamentalValue(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_);
+    // For now, make BinaryValues for backward-compatibility. Convert to
+    // Value when that code is deleted.
+    case Type::BINARY:
+      return new BinaryValue(*binary_value_);
 
     default:
       // All other types should be handled by subclasses.
       NOTREACHED();
       return nullptr;
   }
 }
 
 std::unique_ptr<Value> Value::CreateDeepCopy() const {
   return WrapUnique(DeepCopy());
 }
 
 bool Value::Equals(const Value* other) const {
   if (other->type() != type())
     return false;
 
   switch (type()) {
     case Type::NONE:
       return true;
     case Type::BOOLEAN:
       return bool_value_ == other->bool_value_;
     case Type::INTEGER:
       return int_value_ == other->int_value_;
     case Type::DOUBLE:
       return double_value_ == other->double_value_;
     case Type::STRING:
       return *string_value_ == *(other->string_value_);
+    case Type::BINARY:
+      return *binary_value_ == *(other->binary_value_);
     default:
       // This method should only be getting called for the above types -- all
       // subclasses need to provide their own implementation;.
       NOTREACHED();
       return false;
   }
 }
 
 // static
 bool Value::Equals(const Value* a, const Value* b) {
@@ skipping 30 matching lines @@
     case Type::NONE:
     case Type::BOOLEAN:
     case Type::INTEGER:
     case Type::DOUBLE:
       InternalCopyFundamentalValue(that);
       return;
 
     case Type::STRING:
       string_value_.Init(*that.string_value_);
       return;
+    case Type::BINARY:
+      binary_value_.Init(*that.binary_value_);
+      return;
 
     // TODO(crbug.com/646113): Implement these once the corresponding derived
     // classes are removed.
-    case Type::BINARY:
     case Type::LIST:
     case Type::DICTIONARY:
       return;
   }
 }
 
 void Value::InternalMoveConstructFrom(Value&& that) {
   type_ = that.type_;
 
   switch (type_) {
     case Type::NONE:
     case Type::BOOLEAN:
     case Type::INTEGER:
     case Type::DOUBLE:
       InternalCopyFundamentalValue(that);
       return;
 
     case Type::STRING:
       string_value_.InitFromMove(std::move(that.string_value_));
       return;
+    case Type::BINARY:
+      binary_value_.InitFromMove(std::move(that.binary_value_));
+      return;
 
     // TODO(crbug.com/646113): Implement these once the corresponding derived
     // classes are removed.
-    case Type::BINARY:
     case Type::LIST:
     case Type::DICTIONARY:
       return;
   }
 }
 
 void Value::InternalCopyAssignFrom(const Value& that) {
   type_ = that.type_;
 
   switch (type_) {
     case Type::NONE:
     case Type::BOOLEAN:
     case Type::INTEGER:
     case Type::DOUBLE:
       InternalCopyFundamentalValue(that);
       return;
 
     case Type::STRING:
       *string_value_ = *that.string_value_;
       return;
+    case Type::BINARY:
+      *binary_value_ = *that.binary_value_;
+      return;
 
     // TODO(crbug.com/646113): Implement these once the corresponding derived
     // classes are removed.
-    case Type::BINARY:
     case Type::LIST:
     case Type::DICTIONARY:
       return;
   }
 }
 
 void Value::InternalMoveAssignFrom(Value&& that) {
   type_ = that.type_;
 
   switch (type_) {
     case Type::NONE:
     case Type::BOOLEAN:
     case Type::INTEGER:
     case Type::DOUBLE:
       InternalCopyFundamentalValue(that);
       return;
 
     case Type::STRING:
       *string_value_ = std::move(*that.string_value_);
       return;
+    case Type::BINARY:
+      *binary_value_ = std::move(*that.binary_value_);
+      return;
 
     // TODO(crbug.com/646113): Implement these once the corresponding derived
     // classes are removed.
-    case Type::BINARY:
     case Type::LIST:
     case Type::DICTIONARY:
       return;
   }
 }
 
 void Value::InternalCleanup() {
   switch (type_) {
     case Type::NONE:
     case Type::BOOLEAN:
     case Type::INTEGER:
     case Type::DOUBLE:
       // Nothing to do
       return;
 
     case Type::STRING:
       string_value_.Destroy();
       return;
+    case Type::BINARY:
+      binary_value_.Destroy();
+      return;
 
     // TODO(crbug.com/646113): Implement these once the corresponding derived
     // classes are removed.
-    case Type::BINARY:
     case Type::LIST:
     case Type::DICTIONARY:
       return;
   }
 }
 
-///////////////////// BinaryValue ////////////////////
-
-BinaryValue::BinaryValue() : Value(Type::BINARY), size_(0) {}
-
-BinaryValue::BinaryValue(std::unique_ptr<char[]> buffer, size_t size)
-    : Value(Type::BINARY), buffer_(std::move(buffer)), size_(size) {}
-
-BinaryValue::~BinaryValue() {
-}
-
-// static
-std::unique_ptr<BinaryValue> BinaryValue::CreateWithCopiedBuffer(
-    const char* buffer,
-    size_t size) {
-  std::unique_ptr<char[]> buffer_copy(new char[size]);
-  memcpy(buffer_copy.get(), buffer, size);
-  return MakeUnique<BinaryValue>(std::move(buffer_copy), size);
-}
-
-bool BinaryValue::GetAsBinary(const BinaryValue** out_value) const {
-  if (out_value)
-    *out_value = this;
-  return true;
-}
-
-BinaryValue* BinaryValue::DeepCopy() const {
-  return CreateWithCopiedBuffer(buffer_.get(), size_).release();
-}
-
-bool BinaryValue::Equals(const Value* other) const {
-  if (other->GetType() != GetType())
-    return false;
-  const BinaryValue* other_binary = static_cast<const BinaryValue*>(other);
-  if (other_binary->size_ != size_)
-    return false;
-  return !memcmp(GetBuffer(), other_binary->GetBuffer(), size_);
-}
-
 ///////////////////// DictionaryValue ////////////////////
 
 // static
 std::unique_ptr<DictionaryValue> DictionaryValue::From(
     std::unique_ptr<Value> value) {
   DictionaryValue* out;
   if (value && value->GetAsDictionary(&out)) {
     ignore_result(value.release());
     return WrapUnique(out);
   }
@@ skipping 201 matching lines @@
 }
 
 bool DictionaryValue::GetBinary(StringPiece path,
                                 const BinaryValue** out_value) const {
   const Value* value;
   bool result = Get(path, &value);
   if (!result || !value->IsType(Type::BINARY))
     return false;
 
   if (out_value)
-    *out_value = static_cast<const BinaryValue*>(value);
+    *out_value = value;
 
   return true;
 }
 
 bool DictionaryValue::GetBinary(StringPiece path, BinaryValue** out_value) {
   return static_cast<const DictionaryValue&>(*this).GetBinary(
       path,
       const_cast<const BinaryValue**>(out_value));
 }
 
@@ skipping 373 matching lines @@
   return value->GetAsString(out_value);
 }
 
 bool ListValue::GetBinary(size_t index, const BinaryValue** out_value) const {
   const Value* value;
   bool result = Get(index, &value);
   if (!result || !value->IsType(Type::BINARY))
     return false;
 
   if (out_value)
-    *out_value = static_cast<const BinaryValue*>(value);
+    *out_value = value;
 
   return true;
 }
 
 bool ListValue::GetBinary(size_t index, BinaryValue** out_value) {
   return static_cast<const ListValue&>(*this).GetBinary(
       index,
       const_cast<const BinaryValue**>(out_value));
 }
 
@@ skipping 200 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