Use MakeUnique() in base/values.cc.

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 31 matching lines @@
   return copy.GetList().empty() ? nullptr : MakeUnique<Value>(std::move(copy));
 }
 
 std::unique_ptr<DictionaryValue> CopyDictionaryWithoutEmptyChildren(
     const DictionaryValue& dict) {
   std::unique_ptr<DictionaryValue> copy;
   for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
     std::unique_ptr<Value> child_copy = CopyWithoutEmptyChildren(it.value());
     if (child_copy) {
       if (!copy)
-        copy.reset(new DictionaryValue);
+        copy = MakeUnique<DictionaryValue>();
       copy->SetWithoutPathExpansion(it.key(), std::move(child_copy));
     }
   }
   return copy;
 }
 
 std::unique_ptr<Value> CopyWithoutEmptyChildren(const Value& node) {
   switch (node.GetType()) {
     case Value::Type::LIST:
       return CopyListWithoutEmptyChildren(static_cast<const ListValue&>(node));
@@ skipping 267 matching lines @@
 
 bool Value::GetAsDictionary(const DictionaryValue** out_value) const {
   if (out_value && is_dict()) {
     *out_value = static_cast<const DictionaryValue*>(this);
     return true;
   }
   return is_dict();
 }
 
 Value* Value::DeepCopy() const {
-  return new Value(*this);
+  return CreateDeepCopy().release();

[jdoerrie, 2017/05/08 22:44:47]

I'd rather like for this to stay the same. As the comment in values.h states
both DeepCopy methods are deprecated in favor of using copy constructors, so I
prefer the current implementation.

I don't like using raw new either, but soon we should be able to delete this
method completely. I am currently removing calls to the raw pointer versions of
DictionaryValue::Set*, where DeepCopy has been used a lot. I will try to remove
DeepCopy as a follow up to that.

[Lei Zhang, 2017/05/08 22:58:30]

Done.

 }
 
 std::unique_ptr<Value> Value::CreateDeepCopy() const {
   return MakeUnique<Value>(*this);
 }
 
 bool operator==(const Value& lhs, const Value& rhs) {
   if (lhs.type_ != rhs.type_)
     return false;
 
@@ skipping 266 matching lines @@
 
   StringPiece current_path(path);
   DictionaryValue* current_dictionary = this;
   for (size_t delimiter_position = current_path.find('.');
        delimiter_position != StringPiece::npos;
        delimiter_position = current_path.find('.')) {
     // Assume that we're indexing into a dictionary.
     StringPiece key = current_path.substr(0, delimiter_position);
     DictionaryValue* child_dictionary = nullptr;
     if (!current_dictionary->GetDictionary(key, &child_dictionary)) {
-      child_dictionary = new DictionaryValue;
+      auto new_child_dictionary = MakeUnique<DictionaryValue>();
+      child_dictionary = new_child_dictionary.get();
       current_dictionary->SetWithoutPathExpansion(
-          key, base::WrapUnique(child_dictionary));
+          key, std::move(new_child_dictionary));

[jdoerrie, 2017/05/08 22:44:47]

Consider using the recently added SetDictionaryWithoutPathExpansion here:

child_dictionary = current_dictionary->SetDictionaryWithoutPathExpansion(key,
MakeUnique<DictionaryValue>());

[Lei Zhang, 2017/05/08 22:58:30]

Done. Thanks.

     }
 
     current_dictionary = child_dictionary;
     current_path = current_path.substr(delimiter_position + 1);
   }
 
   return current_dictionary->SetWithoutPathExpansion(current_path,
                                                      std::move(in_value));
 }
 
 Value* DictionaryValue::Set(StringPiece path, Value* in_value) {
   return Set(path, WrapUnique(in_value));
 }
 
 Value* DictionaryValue::SetBoolean(StringPiece path, bool in_value) {
-  return Set(path, new Value(in_value));
+  return Set(path, MakeUnique<Value>(in_value));
 }
 
 Value* DictionaryValue::SetInteger(StringPiece path, int in_value) {
-  return Set(path, new Value(in_value));
+  return Set(path, MakeUnique<Value>(in_value));
 }
 
 Value* DictionaryValue::SetDouble(StringPiece path, double in_value) {
-  return Set(path, new Value(in_value));
+  return Set(path, MakeUnique<Value>(in_value));
 }
 
 Value* DictionaryValue::SetString(StringPiece path, StringPiece in_value) {
-  return Set(path, new Value(in_value));
+  return Set(path, MakeUnique<Value>(in_value));
 }
 
 Value* DictionaryValue::SetString(StringPiece path, const string16& in_value) {
-  return Set(path, new Value(in_value));
+  return Set(path, MakeUnique<Value>(in_value));
 }
 
 DictionaryValue* DictionaryValue::SetDictionary(
     StringPiece path,
     std::unique_ptr<DictionaryValue> in_value) {
   return static_cast<DictionaryValue*>(Set(path, std::move(in_value)));
 }
 
 ListValue* DictionaryValue::SetList(StringPiece path,
                                     std::unique_ptr<ListValue> in_value) {
   return static_cast<ListValue*>(Set(path, std::move(in_value)));
 }
 
 Value* DictionaryValue::SetWithoutPathExpansion(
     StringPiece key,
     std::unique_ptr<Value> in_value) {
   return ((*dict_)[key.as_string()] = std::move(in_value)).get();
 }
 
 Value* DictionaryValue::SetWithoutPathExpansion(StringPiece key,
                                                 Value* in_value) {
   return SetWithoutPathExpansion(key, WrapUnique(in_value));
 }
 
 Value* DictionaryValue::SetBooleanWithoutPathExpansion(StringPiece path,
                                                        bool in_value) {
-  return SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+  return SetWithoutPathExpansion(path, MakeUnique<Value>(in_value));
 }
 
 Value* DictionaryValue::SetIntegerWithoutPathExpansion(StringPiece path,
                                                        int in_value) {
-  return SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+  return SetWithoutPathExpansion(path, MakeUnique<Value>(in_value));
 }
 
 Value* DictionaryValue::SetDoubleWithoutPathExpansion(StringPiece path,
                                                       double in_value) {
-  return SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+  return SetWithoutPathExpansion(path, MakeUnique<Value>(in_value));
 }
 
 Value* DictionaryValue::SetStringWithoutPathExpansion(StringPiece path,
                                                       StringPiece in_value) {
-  return SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+  return SetWithoutPathExpansion(path, MakeUnique<Value>(in_value));
 }
 
 Value* DictionaryValue::SetStringWithoutPathExpansion(
     StringPiece path,
     const string16& in_value) {
-  return SetWithoutPathExpansion(path, base::MakeUnique<base::Value>(in_value));
+  return SetWithoutPathExpansion(path, MakeUnique<Value>(in_value));
 }
 
 DictionaryValue* DictionaryValue::SetDictionaryWithoutPathExpansion(
     StringPiece path,
     std::unique_ptr<DictionaryValue> in_value) {
   return static_cast<DictionaryValue*>(
       SetWithoutPathExpansion(path, std::move(in_value)));
 }
 
 ListValue* DictionaryValue::SetListWithoutPathExpansion(
@@ skipping 303 matching lines @@
     RemoveWithoutPathExpansion(subdict_path, NULL);
 
   return result;
 }
 
 std::unique_ptr<DictionaryValue> DictionaryValue::DeepCopyWithoutEmptyChildren()
     const {
   std::unique_ptr<DictionaryValue> copy =
       CopyDictionaryWithoutEmptyChildren(*this);
   if (!copy)
-    copy.reset(new DictionaryValue);
+    copy = MakeUnique<DictionaryValue>();
   return copy;
 }
 
 void DictionaryValue::MergeDictionary(const DictionaryValue* dictionary) {
   CHECK(dictionary->is_dict());
   for (DictionaryValue::Iterator it(*dictionary); !it.IsAtEnd(); it.Advance()) {
     const Value* merge_value = &it.value();
     // Check whether we have to merge dictionaries.
     if (merge_value->IsType(Value::Type::DICTIONARY)) {
       DictionaryValue* sub_dict;
@@ skipping 14 matching lines @@
 }
 
 DictionaryValue::Iterator::Iterator(const DictionaryValue& target)
     : target_(target), it_(target.dict_->begin()) {}
 
 DictionaryValue::Iterator::Iterator(const Iterator& other) = default;
 
 DictionaryValue::Iterator::~Iterator() {}
 
 DictionaryValue* DictionaryValue::DeepCopy() const {
-  return new DictionaryValue(*this);
+  return CreateDeepCopy().release();

[jdoerrie, 2017/05/08 22:44:47]

Same here.

[Lei Zhang, 2017/05/08 22:58:30]

Done.

 }
 
 std::unique_ptr<DictionaryValue> DictionaryValue::CreateDeepCopy() const {
   return MakeUnique<DictionaryValue>(*this);
 }
 
 ///////////////////// ListValue ////////////////////
 
 // static
 std::unique_ptr<ListValue> ListValue::From(std::unique_ptr<Value> value) {
@@ skipping 230 matching lines @@
 ListValue::const_iterator ListValue::Find(const Value& value) const {
   return std::find(list_->begin(), list_->end(), value);
 }
 
 void ListValue::Swap(ListValue* other) {
   CHECK(other->is_list());
   list_->swap(*(other->list_));
 }
 
 ListValue* ListValue::DeepCopy() const {
-  return new ListValue(*this);
+  return CreateDeepCopy().release();

[jdoerrie, 2017/05/08 22:44:48]

And here.

[Lei Zhang, 2017/05/08 22:58:30]

Done.

 }
 
 std::unique_ptr<ListValue> ListValue::CreateDeepCopy() const {
   return MakeUnique<ListValue>(*this);
 }
 
 ValueSerializer::~ValueSerializer() {
 }
 
 ValueDeserializer::~ValueDeserializer() {
 }
 
 std::ostream& operator<<(std::ostream& out, const Value& value) {
   std::string json;
   JSONWriter::WriteWithOptions(value, JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return out << json;
 }
 
 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