Update from https://crrev.com/329939

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 67 matching lines @@
  private:
   const Value* first_;
 };
 
 }  // namespace
 
 Value::~Value() {
 }
 
 // static
-Value* Value::CreateNullValue() {
-  return new Value(TYPE_NULL);
+scoped_ptr<Value> Value::CreateNullValue() {
+  return make_scoped_ptr(new Value(TYPE_NULL));
 }
 
 bool Value::GetAsBinary(const BinaryValue** out_value) const {
   return false;
 }
 
 bool Value::GetAsBoolean(bool* out_value) const {
   return false;
 }
 
@@ skipping 30 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;.
   DCHECK(IsType(TYPE_NULL));
-  return CreateNullValue();
+  return CreateNullValue().release();
+}
+
+scoped_ptr<Value> Value::CreateDeepCopy() const {
+  return make_scoped_ptr(DeepCopy());
 }
 
 bool Value::Equals(const Value* other) const {
   // This method should only be getting called for null Values--all subclasses
   // need to provide their own implementation;.
   DCHECK(IsType(TYPE_NULL));
   return other->IsType(TYPE_NULL);
 }
 
 // static
@@ skipping 671 matching lines @@
 
   for (ValueMap::const_iterator current_entry(dictionary_.begin());
        current_entry != dictionary_.end(); ++current_entry) {
     result->SetWithoutPathExpansion(current_entry->first,
                                     current_entry->second->DeepCopy());
   }
 
   return result;
 }
 
+scoped_ptr<DictionaryValue> DictionaryValue::CreateDeepCopy() const {
+  return make_scoped_ptr(DeepCopy());
+}
+
 bool DictionaryValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
 
   const DictionaryValue* other_dict =
       static_cast<const DictionaryValue*>(other);
   Iterator lhs_it(*this);
   Iterator rhs_it(*other_dict);
   while (!lhs_it.IsAtEnd() && !rhs_it.IsAtEnd()) {
     if (lhs_it.key() != rhs_it.key() ||
@@ skipping 34 matching lines @@
       Append(CreateNullValue());
     Append(in_value);
   } else {
     DCHECK(list_[index] != in_value);
     delete list_[index];
     list_[index] = in_value;
   }
   return true;
 }
 
+bool ListValue::Set(size_t index, scoped_ptr<Value> in_value) {
+  return Set(index, in_value.release());
+}
+
 bool ListValue::Get(size_t index, const Value** out_value) const {
   if (index >= list_.size())
     return false;
 
   if (out_value)
     *out_value = list_[index];
 
   return true;
 }
 
@@ skipping 129 matching lines @@
 ListValue::iterator ListValue::Erase(iterator iter,
                                      scoped_ptr<Value>* out_value) {
   if (out_value)
     out_value->reset(*iter);
   else
     delete *iter;
 
   return list_.erase(iter);
 }
 
+void ListValue::Append(scoped_ptr<Value> in_value) {
+  Append(in_value.release());
+}
+
 void ListValue::Append(Value* in_value) {
   DCHECK(in_value);
   list_.push_back(in_value);
 }
 
 void ListValue::AppendBoolean(bool in_value) {
   Append(new FundamentalValue(in_value));
 }
 
 void ListValue::AppendInteger(int in_value) {
@@ skipping 69 matching lines @@
 
 ListValue* ListValue::DeepCopy() const {
   ListValue* result = new ListValue;
 
   for (ValueVector::const_iterator i(list_.begin()); i != list_.end(); ++i)
     result->Append((*i)->DeepCopy());
 
   return result;
 }
 
+scoped_ptr<ListValue> ListValue::CreateDeepCopy() const {
+  return make_scoped_ptr(DeepCopy());
+}
+
 bool ListValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
 
   const ListValue* other_list =
       static_cast<const ListValue*>(other);
   const_iterator lhs_it, rhs_it;
   for (lhs_it = begin(), rhs_it = other_list->begin();
        lhs_it != end() && rhs_it != other_list->end();
        ++lhs_it, ++rhs_it) {
@@ skipping 14 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