Convert //base to use std::unique_ptr

base/trace_event/trace_config.cc

 // Copyright (c) 2015 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_config.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_request_args.h"
 #include "base/trace_event/trace_event.h"
 
 namespace base {
 namespace trace_event {
@@ skipping 130 matching lines @@
 std::string TraceConfig::ToString() const {
   base::DictionaryValue dict;
   ToDict(dict);
 
   std::string json;
   base::JSONWriter::Write(dict, &json);
 
   return json;
 }
 
-scoped_ptr<ConvertableToTraceFormat> TraceConfig::AsConvertableToTraceFormat()
-    const {
-  return make_scoped_ptr(new ConvertableTraceConfigToTraceFormat(*this));
+std::unique_ptr<ConvertableToTraceFormat>
+TraceConfig::AsConvertableToTraceFormat() const {
+  return WrapUnique(new ConvertableTraceConfigToTraceFormat(*this));
 }
 
 std::string TraceConfig::ToCategoryFilterString() const {
   std::string filter_string;
   WriteCategoryFilterString(included_categories_, &filter_string, true);
   WriteCategoryFilterString(disabled_categories_, &filter_string, true);
   WriteCategoryFilterString(excluded_categories_, &filter_string, false);
   WriteCategoryFilterString(synthetic_delays_, &filter_string);
   return filter_string;
 }
@@ skipping 162 matching lines @@
     // category enabled. So, use the default periodic dump config.
     const base::DictionaryValue* memory_dump_config = nullptr;
     if (dict.GetDictionary(kMemoryDumpConfigParam, &memory_dump_config))
       SetMemoryDumpConfig(*memory_dump_config);
     else
       SetDefaultMemoryDumpConfig();
   }
 }
 
 void TraceConfig::InitializeFromConfigString(const std::string& config_string) {
-  scoped_ptr<Value> value(JSONReader::Read(config_string));
+  std::unique_ptr<Value> value(JSONReader::Read(config_string));
   if (!value)
     return InitializeDefault();
 
   const DictionaryValue* dict = nullptr;
   bool is_dict = value->GetAsDictionary(&dict);
 
   if (!is_dict)
     return InitializeDefault();
 
   DCHECK(dict);
@@ skipping 110 matching lines @@
     }
   }
 }
 
 void TraceConfig::AddCategoryToDict(base::DictionaryValue& dict,
                                     const char* param,
                                     const StringList& categories) const {
   if (categories.empty())
     return;
 
-  scoped_ptr<base::ListValue> list(new base::ListValue());
+  std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (StringList::const_iterator ci = categories.begin();
        ci != categories.end();
        ++ci) {
     list->AppendString(*ci);
   }
 
   dict.Set(param, std::move(list));
 }
 
 void TraceConfig::SetMemoryDumpConfig(
@@ skipping 68 matching lines @@
 
   StringList categories(included_categories_);
   categories.insert(categories.end(),
                     disabled_categories_.begin(),
                     disabled_categories_.end());
   AddCategoryToDict(dict, kIncludedCategoriesParam, categories);
   AddCategoryToDict(dict, kExcludedCategoriesParam, excluded_categories_);
   AddCategoryToDict(dict, kSyntheticDelaysParam, synthetic_delays_);
 
   if (IsCategoryEnabled(MemoryDumpManager::kTraceCategory)) {
-    scoped_ptr<base::DictionaryValue> memory_dump_config(
+    std::unique_ptr<base::DictionaryValue> memory_dump_config(
         new base::DictionaryValue());
-    scoped_ptr<base::ListValue> triggers_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> triggers_list(new base::ListValue());
     for (const MemoryDumpTriggerConfig& config : memory_dump_config_) {
-      scoped_ptr<base::DictionaryValue> trigger_dict(
+      std::unique_ptr<base::DictionaryValue> trigger_dict(
           new base::DictionaryValue());
       trigger_dict->SetInteger(kPeriodicIntervalParam,
                                static_cast<int>(config.periodic_interval_ms));
       trigger_dict->SetString(
           kModeParam, MemoryDumpLevelOfDetailToString(config.level_of_detail));
       triggers_list->Append(std::move(trigger_dict));
     }
 
     // Empty triggers will still be specified explicitly since it means that
     // the periodic dumps are not enabled.
@@ skipping 88 matching lines @@
           str.at(0) == ' ' ||
           str.at(str.length() - 1) == ' ';
 }
 
 bool TraceConfig::HasIncludedPatterns() const {
   return !included_categories_.empty();
 }
 
 }  // namespace trace_event
 }  // namespace base