BinaryValue support for NULL buffer.

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 <algorithm>
 #include <ostream>
 
 #include "base/float_util.h"
@@ skipping 288 matching lines @@
 
 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 ////////////////////
 
-BinaryValue::~BinaryValue() {
-  DCHECK(buffer_);
-  if (buffer_)
-    delete[] buffer_;
+BinaryValue::BinaryValue()
+    : Value(TYPE_BINARY),
+      buffer_(NULL),
+      size_(0) {
 }
 
-// static
-BinaryValue* BinaryValue::Create(char* buffer, size_t size) {
-  if (!buffer)
-    return NULL;
+BinaryValue::BinaryValue(scoped_array<char> buffer, size_t size)
+    : Value(TYPE_BINARY),
+      buffer_(buffer.release()),

[brettw, 2013/01/03 22:01:23]

Can you use .Pass() here instead?

[rpaquay, 2013/01/03 23:20:02]

Done.

+      size_(size) {
+}
 
-  return new BinaryValue(buffer, size);
+BinaryValue::~BinaryValue() {
 }
 
 // static
 BinaryValue* BinaryValue::CreateWithCopiedBuffer(const char* buffer,
                                                  size_t size) {
-  if (!buffer)
-    return NULL;
-
   char* buffer_copy = new char[size];
   memcpy(buffer_copy, buffer, size);
-  return new BinaryValue(buffer_copy, size);
+  scoped_array<char> scoped_buffer_copy(buffer_copy);
+  return new BinaryValue(scoped_buffer_copy.Pass(), size);
 }
 
 BinaryValue* BinaryValue::DeepCopy() const {
-  return CreateWithCopiedBuffer(buffer_, size_);
+  return CreateWithCopiedBuffer(buffer_.get(), size_);
 }
 
 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(buffer_, other_binary->buffer_, size_);
-}
-
-BinaryValue::BinaryValue(char* buffer, size_t size)
-  : Value(TYPE_BINARY),
-    buffer_(buffer),
-    size_(size) {
-  DCHECK(buffer_);
+  return !memcmp(GetBuffer(), other_binary->GetBuffer(), size_);
 }
 
 ///////////////////// DictionaryValue ////////////////////
 
 DictionaryValue::DictionaryValue()
     : Value(TYPE_DICTIONARY) {
 }
 
 DictionaryValue::~DictionaryValue() {
   Clear();
@@ skipping 773 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