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

content/browser/tracing/background_tracing_manager_impl.cc

 // Copyright 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 "content/browser/tracing/background_tracing_manager_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
@@ skipping 83 matching lines @@
   NOTREACHED();
 }
 
 void BackgroundTracingManagerImpl::WhenIdle(
     base::Callback<void()> idle_callback) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   idle_callback_ = idle_callback;
 }
 
 bool BackgroundTracingManagerImpl::SetActiveScenario(
-    scoped_ptr<BackgroundTracingConfig> config,
+    std::unique_ptr<BackgroundTracingConfig> config,
     const BackgroundTracingManager::ReceiveCallback& receive_callback,
     DataFiltering data_filtering) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   RecordBackgroundTracingMetric(SCENARIO_ACTIVATION_REQUESTED);
 
   if (is_tracing_)
     return false;
 
   // If we don't have a high resolution timer available, traces will be
   // too inaccurate to be useful.
@@ skipping 14 matching lines @@
             *config.get(), requires_anonymized_data)) {
       return false;
     }
   } else {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&BackgroundTracingManagerImpl::ValidateStartupScenario,
                    base::Unretained(this)));
   }
 
-  scoped_ptr<const content::BackgroundTracingConfigImpl> config_impl(
+  std::unique_ptr<const content::BackgroundTracingConfigImpl> config_impl(
       static_cast<BackgroundTracingConfigImpl*>(config.release()));
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   if (config_impl) {
     // No point in tracing if there's nowhere to send it.
     if (receive_callback.is_null())
       return false;
 
     // If the scenario requires us to toggle Blink features, we want
@@ skipping 243 matching lines @@
   base::trace_event::TraceConfig trace_config(category_filter_str, record_mode);
   if (requires_anonymized_data_)
     trace_config.EnableArgumentFilter();
 
   is_tracing_ = TracingController::GetInstance()->StartTracing(
       trace_config, tracing_enabled_callback_for_testing_);
   RecordBackgroundTracingMetric(RECORDING_ENABLED);
 }
 
 void BackgroundTracingManagerImpl::OnFinalizeStarted(
-    scoped_ptr<const base::DictionaryValue> metadata,
+    std::unique_ptr<const base::DictionaryValue> metadata,
     base::RefCountedString* file_contents) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   RecordBackgroundTracingMetric(FINALIZATION_STARTED);
   UMA_HISTOGRAM_MEMORY_KB("Tracing.Background.FinalizingTraceSizeInKB",
                           file_contents->size() / 1024);
 
   if (!receive_callback_.is_null()) {
     receive_callback_.Run(
         file_contents, std::move(metadata),
@@ skipping 31 matching lines @@
     AbortScenario();
   }
 
   RecordBackgroundTracingMetric(FINALIZATION_COMPLETE);
 }
 
 void BackgroundTracingManagerImpl::AddCustomMetadata(
     TracingControllerImpl::TraceDataSink* trace_data_sink) const {
   base::DictionaryValue metadata_dict;
 
-  scoped_ptr<base::DictionaryValue> config_dict(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> config_dict(
+      new base::DictionaryValue());
   config_->IntoDict(config_dict.get());
   metadata_dict.Set("config", std::move(config_dict));
 
   trace_data_sink->AddMetadata(metadata_dict);
 }
 
 void BackgroundTracingManagerImpl::BeginFinalizing(
     StartedFinalizingCallback callback) {
   is_gathering_ = true;
   is_tracing_ = false;
@@ skipping 52 matching lines @@
     case BackgroundTracingConfigImpl::CategoryPreset::BENCHMARK_BLINK_GC:
       return "blink_gc,disabled-by-default-blink_gc";
     case BackgroundTracingConfigImpl::CategoryPreset::BLINK_STYLE:
       return "blink_style";
   }
   NOTREACHED();
   return "";
 }
 
 }  // namspace content