Convert //base to use std::unique_ptr

base/trace_event/trace_event_argument.cc

 // Copyright (c) 2014 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/trace_event/trace_event_argument.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bits.h"
 #include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event_memory_overhead.h"
 #include "base/values.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 const char kTypeStartDict = '{';
 const char kTypeEndDict = '}';
 const char kTypeStartArray = '[';
@@ skipping 204 matching lines @@
   DEBUG_PUSH_CONTAINER(kStackTypeDict);
   pickle_.WriteBytes(&kTypeStartDict, 1);
 }
 
 void TracedValue::EndArray() {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
   DEBUG_POP_CONTAINER();
   pickle_.WriteBytes(&kTypeEndArray, 1);
 }
 
-void TracedValue::SetValue(const char* name, scoped_ptr<base::Value> value) {
+void TracedValue::SetValue(const char* name,
+                           std::unique_ptr<base::Value> value) {
   SetBaseValueWithCopiedName(name, *value);
 }
 
 void TracedValue::SetBaseValueWithCopiedName(base::StringPiece name,
                                              const base::Value& value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   switch (value.GetType()) {
     case base::Value::TYPE_NULL:
     case base::Value::TYPE_BINARY:
       NOTREACHED();
@@ skipping 92 matching lines @@
       const ListValue* list_value;
       value.GetAsList(&list_value);
       BeginArray();
       for (base::Value* base_value : *list_value)
         AppendBaseValue(*base_value);
       EndArray();
     } break;
   }
 }
 
-scoped_ptr<base::Value> TracedValue::ToBaseValue() const {
-  scoped_ptr<DictionaryValue> root(new DictionaryValue);
+std::unique_ptr<base::Value> TracedValue::ToBaseValue() const {
+  std::unique_ptr<DictionaryValue> root(new DictionaryValue);
   DictionaryValue* cur_dict = root.get();
   ListValue* cur_list = nullptr;
   std::vector<Value*> stack;
   PickleIterator it(pickle_);
   const char* type;
 
   while (it.ReadBytes(&type, 1)) {
     DCHECK((cur_dict && !cur_list) || (cur_list && !cur_dict));
     switch (*type) {
       case kTypeStartDict: {
         auto new_dict = new DictionaryValue();
         if (cur_dict) {
           cur_dict->SetWithoutPathExpansion(ReadKeyName(it),
-                                            make_scoped_ptr(new_dict));
+                                            WrapUnique(new_dict));
           stack.push_back(cur_dict);
           cur_dict = new_dict;
         } else {
-          cur_list->Append(make_scoped_ptr(new_dict));
+          cur_list->Append(WrapUnique(new_dict));
           stack.push_back(cur_list);
           cur_list = nullptr;
           cur_dict = new_dict;
         }
       } break;
 
       case kTypeEndArray:
       case kTypeEndDict: {
         if (stack.back()->GetAsDictionary(&cur_dict)) {
           cur_list = nullptr;
         } else if (stack.back()->GetAsList(&cur_list)) {
           cur_dict = nullptr;
         }
         stack.pop_back();
       } break;
 
       case kTypeStartArray: {
         auto new_list = new ListValue();
         if (cur_dict) {
           cur_dict->SetWithoutPathExpansion(ReadKeyName(it),
-                                            make_scoped_ptr(new_list));
+                                            WrapUnique(new_list));
           stack.push_back(cur_dict);
           cur_dict = nullptr;
           cur_list = new_list;
         } else {
-          cur_list->Append(make_scoped_ptr(new_list));
+          cur_list->Append(WrapUnique(new_list));
           stack.push_back(cur_list);
           cur_list = new_list;
         }
       } break;
 
       case kTypeBool: {
         bool value;
         CHECK(it.ReadBool(&value));
         if (cur_dict) {
           cur_dict->SetBooleanWithoutPathExpansion(ReadKeyName(it), value);
@@ skipping 59 matching lines @@
 
                 /* allocated size */
                 bits::Align(pickle_.GetTotalAllocatedSize(), kPickleHeapAlign),
 
                 /* resident size */
                 bits::Align(pickle_.size(), kPickleHeapAlign));
 }
 
 }  // namespace trace_event
 }  // namespace base