Convert //base to use std::unique_ptr

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>
 #include <ostream>
 #include <utility>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/move.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 
 namespace base {
 
 namespace {
 
-scoped_ptr<Value> CopyWithoutEmptyChildren(const Value& node);
+std::unique_ptr<Value> CopyWithoutEmptyChildren(const Value& node);
 
 // Make a deep copy of |node|, but don't include empty lists or dictionaries
 // in the copy. It's possible for this function to return NULL and it
 // expects |node| to always be non-NULL.
-scoped_ptr<ListValue> CopyListWithoutEmptyChildren(const ListValue& list) {
-  scoped_ptr<ListValue> copy;
+std::unique_ptr<ListValue> CopyListWithoutEmptyChildren(const ListValue& list) {
+  std::unique_ptr<ListValue> copy;
   for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) {
-    scoped_ptr<Value> child_copy = CopyWithoutEmptyChildren(**it);
+    std::unique_ptr<Value> child_copy = CopyWithoutEmptyChildren(**it);
     if (child_copy) {
       if (!copy)
         copy.reset(new ListValue);
       copy->Append(std::move(child_copy));
     }
   }
   return copy;
 }
 
-scoped_ptr<DictionaryValue> CopyDictionaryWithoutEmptyChildren(
+std::unique_ptr<DictionaryValue> CopyDictionaryWithoutEmptyChildren(
     const DictionaryValue& dict) {
-  scoped_ptr<DictionaryValue> copy;
+  std::unique_ptr<DictionaryValue> copy;
   for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
-    scoped_ptr<Value> child_copy = CopyWithoutEmptyChildren(it.value());
+    std::unique_ptr<Value> child_copy = CopyWithoutEmptyChildren(it.value());
     if (child_copy) {
       if (!copy)
         copy.reset(new DictionaryValue);
       copy->SetWithoutPathExpansion(it.key(), std::move(child_copy));
     }
   }
   return copy;
 }
 
-scoped_ptr<Value> CopyWithoutEmptyChildren(const Value& node) {
+std::unique_ptr<Value> CopyWithoutEmptyChildren(const Value& node) {
   switch (node.GetType()) {
     case Value::TYPE_LIST:
       return CopyListWithoutEmptyChildren(static_cast<const ListValue&>(node));
 
     case Value::TYPE_DICTIONARY:
       return CopyDictionaryWithoutEmptyChildren(
           static_cast<const DictionaryValue&>(node));
 
     default:
       return node.CreateDeepCopy();
@@ skipping 15 matching lines @@
  private:
   const Value* first_;
 };
 
 }  // namespace
 
 Value::~Value() {
 }
 
 // static
-scoped_ptr<Value> Value::CreateNullValue() {
-  return make_scoped_ptr(new Value(TYPE_NULL));
+std::unique_ptr<Value> Value::CreateNullValue() {
+  return WrapUnique(new Value(TYPE_NULL));
 }
 
 bool Value::GetAsBinary(const BinaryValue** out_value) const {
   return false;
 }
 
 bool Value::GetAsBoolean(bool* out_value) const {
   return false;
 }
 
@@ skipping 33 matching lines @@
   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().release();
 }
 
-scoped_ptr<Value> Value::CreateDeepCopy() const {
-  return make_scoped_ptr(DeepCopy());
+std::unique_ptr<Value> Value::CreateDeepCopy() const {
+  return WrapUnique(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 147 matching lines @@
   return GetAsString(&lhs) && other->GetAsString(&rhs) && lhs == rhs;
 }
 
 ///////////////////// BinaryValue ////////////////////
 
 BinaryValue::BinaryValue()
     : Value(TYPE_BINARY),
       size_(0) {
 }
 
-BinaryValue::BinaryValue(scoped_ptr<char[]> buffer, size_t size)
+BinaryValue::BinaryValue(std::unique_ptr<char[]> buffer, size_t size)
     : Value(TYPE_BINARY), buffer_(std::move(buffer)), size_(size) {}
 
 BinaryValue::~BinaryValue() {
 }
 
 // static
 BinaryValue* BinaryValue::CreateWithCopiedBuffer(const char* buffer,
                                                  size_t size) {
   char* buffer_copy = new char[size];
   memcpy(buffer_copy, buffer, size);
-  scoped_ptr<char[]> scoped_buffer_copy(buffer_copy);
+  std::unique_ptr<char[]> scoped_buffer_copy(buffer_copy);
   return new BinaryValue(std::move(scoped_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_);
 }
 
 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
-scoped_ptr<DictionaryValue> DictionaryValue::From(scoped_ptr<Value> value) {
+std::unique_ptr<DictionaryValue> DictionaryValue::From(
+    std::unique_ptr<Value> value) {
   DictionaryValue* out;
   if (value && value->GetAsDictionary(&out)) {
     ignore_result(value.release());
-    return make_scoped_ptr(out);
+    return WrapUnique(out);
   }
   return nullptr;
 }
 
 DictionaryValue::DictionaryValue()
     : Value(TYPE_DICTIONARY) {
 }
 
 DictionaryValue::~DictionaryValue() {
   Clear();
@@ skipping 21 matching lines @@
 void DictionaryValue::Clear() {
   ValueMap::iterator dict_iterator = dictionary_.begin();
   while (dict_iterator != dictionary_.end()) {
     delete dict_iterator->second;
     ++dict_iterator;
   }
 
   dictionary_.clear();
 }
 
-void DictionaryValue::Set(const std::string& path, scoped_ptr<Value> in_value) {
+void DictionaryValue::Set(const std::string& path,
+                          std::unique_ptr<Value> in_value) {
   DCHECK(IsStringUTF8(path));
   DCHECK(in_value);
 
   std::string current_path(path);
   DictionaryValue* current_dictionary = this;
   for (size_t delimiter_position = current_path.find('.');
        delimiter_position != std::string::npos;
        delimiter_position = current_path.find('.')) {
     // Assume that we're indexing into a dictionary.
     std::string key(current_path, 0, delimiter_position);
     DictionaryValue* child_dictionary = NULL;
     if (!current_dictionary->GetDictionary(key, &child_dictionary)) {
       child_dictionary = new DictionaryValue;
       current_dictionary->SetWithoutPathExpansion(key, child_dictionary);
     }
 
     current_dictionary = child_dictionary;
     current_path.erase(0, delimiter_position + 1);
   }
 
   current_dictionary->SetWithoutPathExpansion(current_path,
                                               std::move(in_value));
 }
 
 void DictionaryValue::Set(const std::string& path, Value* in_value) {
-  Set(path, make_scoped_ptr(in_value));
+  Set(path, WrapUnique(in_value));
 }
 
 void DictionaryValue::SetBoolean(const std::string& path, bool in_value) {
   Set(path, new FundamentalValue(in_value));
 }
 
 void DictionaryValue::SetInteger(const std::string& path, int in_value) {
   Set(path, new FundamentalValue(in_value));
 }
 
 void DictionaryValue::SetDouble(const std::string& path, double in_value) {
   Set(path, new FundamentalValue(in_value));
 }
 
 void DictionaryValue::SetString(const std::string& path,
                                 const std::string& in_value) {
   Set(path, new StringValue(in_value));
 }
 
 void DictionaryValue::SetString(const std::string& path,
                                 const string16& in_value) {
   Set(path, new StringValue(in_value));
 }
 
 void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
-                                              scoped_ptr<Value> in_value) {
+                                              std::unique_ptr<Value> in_value) {
   Value* bare_ptr = in_value.release();
   // If there's an existing value here, we need to delete it, because
   // we own all our children.
   std::pair<ValueMap::iterator, bool> ins_res =
       dictionary_.insert(std::make_pair(key, bare_ptr));
   if (!ins_res.second) {
     DCHECK_NE(ins_res.first->second, bare_ptr);  // This would be bogus
     delete ins_res.first->second;
     ins_res.first->second = bare_ptr;
   }
 }
 
 void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
                                               Value* in_value) {
-  SetWithoutPathExpansion(key, make_scoped_ptr(in_value));
+  SetWithoutPathExpansion(key, WrapUnique(in_value));
 }
 
 void DictionaryValue::SetBooleanWithoutPathExpansion(
     const std::string& path, bool in_value) {
   SetWithoutPathExpansion(path, new FundamentalValue(in_value));
 }
 
 void DictionaryValue::SetIntegerWithoutPathExpansion(
     const std::string& path, int in_value) {
   SetWithoutPathExpansion(path, new FundamentalValue(in_value));
@@ skipping 268 matching lines @@
 
 bool DictionaryValue::GetListWithoutPathExpansion(const std::string& key,
                                                   ListValue** out_value) {
   return
       static_cast<const DictionaryValue&>(*this).GetListWithoutPathExpansion(
           key,
           const_cast<const ListValue**>(out_value));
 }
 
 bool DictionaryValue::Remove(const std::string& path,
-                             scoped_ptr<Value>* out_value) {
+                             std::unique_ptr<Value>* out_value) {
   DCHECK(IsStringUTF8(path));
   std::string current_path(path);
   DictionaryValue* current_dictionary = this;
   size_t delimiter_position = current_path.rfind('.');
   if (delimiter_position != std::string::npos) {
     if (!GetDictionary(current_path.substr(0, delimiter_position),
                        &current_dictionary))
       return false;
     current_path.erase(0, delimiter_position + 1);
   }
 
   return current_dictionary->RemoveWithoutPathExpansion(current_path,
                                                         out_value);
 }
 
-bool DictionaryValue::RemoveWithoutPathExpansion(const std::string& key,
-                                                 scoped_ptr<Value>* out_value) {
+bool DictionaryValue::RemoveWithoutPathExpansion(
+    const std::string& key,
+    std::unique_ptr<Value>* out_value) {
   DCHECK(IsStringUTF8(key));
   ValueMap::iterator entry_iterator = dictionary_.find(key);
   if (entry_iterator == dictionary_.end())
     return false;
 
   Value* entry = entry_iterator->second;
   if (out_value)
     out_value->reset(entry);
   else
     delete entry;
   dictionary_.erase(entry_iterator);
   return true;
 }
 
 bool DictionaryValue::RemovePath(const std::string& path,
-                                 scoped_ptr<Value>* out_value) {
+                                 std::unique_ptr<Value>* out_value) {
   bool result = false;
   size_t delimiter_position = path.find('.');
 
   if (delimiter_position == std::string::npos)
     return RemoveWithoutPathExpansion(path, out_value);
 
   const std::string subdict_path = path.substr(0, delimiter_position);
   DictionaryValue* subdict = NULL;
   if (!GetDictionary(subdict_path, &subdict))
     return false;
   result = subdict->RemovePath(path.substr(delimiter_position + 1),
                                out_value);
   if (result && subdict->empty())
     RemoveWithoutPathExpansion(subdict_path, NULL);
 
   return result;
 }
 
-scoped_ptr<DictionaryValue> DictionaryValue::DeepCopyWithoutEmptyChildren()
+std::unique_ptr<DictionaryValue> DictionaryValue::DeepCopyWithoutEmptyChildren()
     const {
-  scoped_ptr<DictionaryValue> copy = CopyDictionaryWithoutEmptyChildren(*this);
+  std::unique_ptr<DictionaryValue> copy =
+      CopyDictionaryWithoutEmptyChildren(*this);
   if (!copy)
     copy.reset(new DictionaryValue);
   return copy;
 }
 
 void DictionaryValue::MergeDictionary(const DictionaryValue* dictionary) {
   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)) {
@@ skipping 26 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());
+std::unique_ptr<DictionaryValue> DictionaryValue::CreateDeepCopy() const {
+  return WrapUnique(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() ||
         !lhs_it.value().Equals(&rhs_it.value())) {
       return false;
     }
     lhs_it.Advance();
     rhs_it.Advance();
   }
   if (!lhs_it.IsAtEnd() || !rhs_it.IsAtEnd())
     return false;
 
   return true;
 }
 
 ///////////////////// ListValue ////////////////////
 
 // static
-scoped_ptr<ListValue> ListValue::From(scoped_ptr<Value> value) {
+std::unique_ptr<ListValue> ListValue::From(std::unique_ptr<Value> value) {
   ListValue* out;
   if (value && value->GetAsList(&out)) {
     ignore_result(value.release());
-    return make_scoped_ptr(out);
+    return WrapUnique(out);
   }
   return nullptr;
 }
 
 ListValue::ListValue() : Value(TYPE_LIST) {
 }
 
 ListValue::~ListValue() {
   Clear();
 }
@@ skipping 14 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) {
+bool ListValue::Set(size_t index, std::unique_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];
 
@@ skipping 94 matching lines @@
 
   return true;
 }
 
 bool ListValue::GetList(size_t index, ListValue** out_value) {
   return static_cast<const ListValue&>(*this).GetList(
       index,
       const_cast<const ListValue**>(out_value));
 }
 
-bool ListValue::Remove(size_t index, scoped_ptr<Value>* out_value) {
+bool ListValue::Remove(size_t index, std::unique_ptr<Value>* out_value) {
   if (index >= list_.size())
     return false;
 
   if (out_value)
     out_value->reset(list_[index]);
   else
     delete list_[index];
 
   list_.erase(list_.begin() + index);
   return true;
 }
 
 bool ListValue::Remove(const Value& value, size_t* index) {
   for (ValueVector::iterator i(list_.begin()); i != list_.end(); ++i) {
     if ((*i)->Equals(&value)) {
       size_t previous_index = i - list_.begin();
       delete *i;
       list_.erase(i);
 
       if (index)
         *index = previous_index;
       return true;
     }
   }
   return false;
 }
 
 ListValue::iterator ListValue::Erase(iterator iter,
-                                     scoped_ptr<Value>* out_value) {
+                                     std::unique_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) {
+void ListValue::Append(std::unique_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));
@@ skipping 72 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());
+std::unique_ptr<ListValue> ListValue::CreateDeepCopy() const {
+  return WrapUnique(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();
@@ skipping 14 matching lines @@
 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;
 }
 
 }  // namespace base