Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/devtools/protocol/tracing_handler.cc

 // Copyright 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 "content/browser/devtools/protocol/tracing_handler.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 30 matching lines @@
     if (isupper(c)) {
       out_str.push_back(separator);
       out_str.push_back(tolower(c));
     } else {
       out_str.push_back(c);
     }
   }
   return out_str;
 }
 
-scoped_ptr<base::Value> ConvertDictKeyStyle(const base::Value& value) {
+std::unique_ptr<base::Value> ConvertDictKeyStyle(const base::Value& value) {
   const base::DictionaryValue* dict = nullptr;
   if (value.GetAsDictionary(&dict)) {
-    scoped_ptr<base::DictionaryValue> out_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> out_dict(
+        new base::DictionaryValue());
     for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd();
          it.Advance()) {
       out_dict->Set(ConvertFromCamelCase(it.key(), '_'),
                     ConvertDictKeyStyle(it.value()));
     }
     return std::move(out_dict);
   }
 
   const base::ListValue* list = nullptr;
   if (value.GetAsList(&list)) {
-    scoped_ptr<base::ListValue> out_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> out_list(new base::ListValue());
     for (const auto& value : *list)
       out_list->Append(ConvertDictKeyStyle(*value));
     return std::move(out_list);
   }
 
   return value.CreateDeepCopy();
 }
 
 class DevToolsTraceSinkProxy : public TracingController::TraceDataSink {
  public:
@@ skipping 58 matching lines @@
     : target_(target),
       io_context_(io_context),
       frame_tree_node_id_(frame_tree_node_id),
       did_initiate_recording_(false),
       return_as_stream_(false),
       weak_factory_(this) {}
 
 TracingHandler::~TracingHandler() {
 }
 
-void TracingHandler::SetClient(scoped_ptr<Client> client) {
+void TracingHandler::SetClient(std::unique_ptr<Client> client) {
   client_.swap(client);
 }
 
 void TracingHandler::Detached() {
   if (did_initiate_recording_)
     StopTracing(scoped_refptr<TracingController::TraceDataSink>());
 }
 
 void TracingHandler::OnTraceDataCollected(const std::string& trace_fragment) {
   // Hand-craft protocol notification message so we can substitute JSON
@@ skipping 15 matching lines @@
   client_->TracingComplete(
       TracingCompleteParams::Create()->set_stream(stream_handle));
 }
 
 Response TracingHandler::Start(
     DevToolsCommandId command_id,
     const std::string* categories,
     const std::string* options,
     const double* buffer_usage_reporting_interval,
     const std::string* transfer_mode,
-    const scoped_ptr<base::DictionaryValue>& config) {
+    const std::unique_ptr<base::DictionaryValue>& config) {
   if (IsTracing())
     return Response::InternalError("Tracing is already started");
 
   if (config && (categories || options)) {
     return Response::InternalError(
         "Either trace config (preferred), or categories+options should be "
         "specified, but not both.");
   }
 
   did_initiate_recording_ = true;
@@ skipping 141 matching lines @@
 }
 
 bool TracingHandler::IsStartupTracingActive() {
   return ::tracing::TraceConfigFile::GetInstance()->IsEnabled() &&
       TracingController::GetInstance()->IsTracing();
 }
 
 // static
 base::trace_event::TraceConfig TracingHandler::GetTraceConfigFromDevToolsConfig(
     const base::DictionaryValue& devtools_config) {
-  scoped_ptr<base::Value> value = ConvertDictKeyStyle(devtools_config);
+  std::unique_ptr<base::Value> value = ConvertDictKeyStyle(devtools_config);
   DCHECK(value && value->IsType(base::Value::TYPE_DICTIONARY));
-  scoped_ptr<base::DictionaryValue> tracing_dict(
+  std::unique_ptr<base::DictionaryValue> tracing_dict(
       static_cast<base::DictionaryValue*>(value.release()));
 
   std::string mode;
   if (tracing_dict->GetString(kRecordModeParam, &mode))
     tracing_dict->SetString(kRecordModeParam, ConvertFromCamelCase(mode, '-'));
 
   return base::trace_event::TraceConfig(*tracing_dict);
 }
 
 }  // namespace tracing
 }  // namespace devtools
 }  // namespace content