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

content/browser/tracing/background_tracing_manager_browsertest.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 <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 21 matching lines @@
 class BackgroundTracingManagerUploadConfigWrapper {
  public:
   BackgroundTracingManagerUploadConfigWrapper(const base::Closure& callback)
       : callback_(callback), receive_count_(0) {
     receive_callback_ =
         base::Bind(&BackgroundTracingManagerUploadConfigWrapper::Upload,
                    base::Unretained(this));
   }
 
   void Upload(const scoped_refptr<base::RefCountedString>& file_contents,
-              scoped_ptr<const base::DictionaryValue> metadata,
+              std::unique_ptr<const base::DictionaryValue> metadata,
               base::Callback<void()> done_callback) {
     receive_count_ += 1;
     EXPECT_TRUE(file_contents);
 
     size_t compressed_length = file_contents->data().length();
     const size_t kOutputBufferLength = 10 * 1024 * 1024;
     std::vector<char> output_str(kOutputBufferLength);
 
     z_stream stream = {0};
     stream.avail_in = compressed_length;
@@ skipping 37 matching lines @@
 };
 
 void StartedFinalizingCallback(base::Closure callback,
                                bool expected,
                                bool value) {
   EXPECT_EQ(expected, value);
   if (!callback.is_null())
     callback.Run();
 }
 
-scoped_ptr<BackgroundTracingConfig> CreatePreemptiveConfig() {
+std::unique_ptr<BackgroundTracingConfig> CreatePreemptiveConfig() {
   base::DictionaryValue dict;
 
   dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
   dict.SetString("category", "BENCHMARK");
 
-  scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
   {
-    scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> rules_dict(
+        new base::DictionaryValue());
     rules_dict->SetString("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED");
     rules_dict->SetString("trigger_name", "preemptive_test");
     rules_list->Append(std::move(rules_dict));
   }
   dict.Set("configs", std::move(rules_list));
 
-  scoped_ptr<BackgroundTracingConfig> config(
+  std::unique_ptr<BackgroundTracingConfig> config(
       BackgroundTracingConfigImpl::FromDict(&dict));
 
   EXPECT_TRUE(config);
   return config;
 }
 
-scoped_ptr<BackgroundTracingConfig> CreateReactiveConfig() {
+std::unique_ptr<BackgroundTracingConfig> CreateReactiveConfig() {
   base::DictionaryValue dict;
 
   dict.SetString("mode", "REACTIVE_TRACING_MODE");
 
-  scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
   {
-    scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> rules_dict(
+        new base::DictionaryValue());
     rules_dict->SetString("rule", "TRACE_ON_NAVIGATION_UNTIL_TRIGGER_OR_FULL");
     rules_dict->SetString("trigger_name", "reactive_test");
     rules_dict->SetString("category", "BENCHMARK");
     rules_list->Append(std::move(rules_dict));
   }
   dict.Set("configs", std::move(rules_list));
 
-  scoped_ptr<BackgroundTracingConfig> config(
+  std::unique_ptr<BackgroundTracingConfig> config(
       BackgroundTracingConfigImpl::FromDict(&dict));
 
   EXPECT_TRUE(config);
   return config;
 }
 
 void SetupBackgroundTracingManager() {
   content::BackgroundTracingManager::GetInstance()
       ->InvalidateTriggerHandlesForTesting();
 }
 
 void DisableScenarioWhenIdle() {
   BackgroundTracingManager::GetInstance()->SetActiveScenario(
       NULL, BackgroundTracingManager::ReceiveCallback(),
       BackgroundTracingManager::NO_DATA_FILTERING);
 }
 
 // This tests that the endpoint receives the final trace data.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        ReceiveTraceFinalContentsOnTrigger) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
-    scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
             GetInstance()->RegisterTriggerType("preemptive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
@@ skipping 11 matching lines @@
 // This tests triggering more than once still only gathers once.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        CallTriggersMoreThanOnceOnlyGatherOnce) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
-    scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "preemptive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
@@ skipping 31 matching lines @@
                        NoWhitelistedArgsStripped) {
   SetupBackgroundTracingManager();
 
   base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate(
       base::Bind(&IsTraceEventArgsWhitelisted));
 
   base::RunLoop wait_for_upload;
   BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
       wait_for_upload.QuitClosure());
 
-  scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
+  std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
   content::BackgroundTracingManager::TriggerHandle handle =
       content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
           "preemptive_test");
 
   base::RunLoop wait_for_activated;
   BackgroundTracingManager::GetInstance()->SetTracingEnabledCallbackForTesting(
       wait_for_activated.QuitClosure());
   EXPECT_TRUE(BackgroundTracingManager::GetInstance()->SetActiveScenario(
       std::move(config), upload_config_wrapper.get_receive_callback(),
@@ skipping 23 matching lines @@
                        TraceMetadataInTrace) {
   SetupBackgroundTracingManager();
 
   base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate(
       base::Bind(&IsTraceEventArgsWhitelisted));
 
   base::RunLoop wait_for_upload;
   BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
       wait_for_upload.QuitClosure());
 
-  scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
+  std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
   content::BackgroundTracingManager::TriggerHandle handle =
       content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
           "preemptive_test");
 
   base::RunLoop wait_for_activated;
   BackgroundTracingManager::GetInstance()->SetTracingEnabledCallbackForTesting(
       wait_for_activated.QuitClosure());
   EXPECT_TRUE(BackgroundTracingManager::GetInstance()->SetActiveScenario(
       std::move(config), upload_config_wrapper.get_receive_callback(),
@@ skipping 23 matching lines @@
                        CrashWhenSubprocessWithoutArgumentFilter) {
   SetupBackgroundTracingManager();
 
   base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate(
       base::Bind(&IsTraceEventArgsWhitelisted));
 
   base::RunLoop wait_for_upload;
   BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
       wait_for_upload.QuitClosure());
 
-  scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
+  std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
   content::BackgroundTracingManager::TriggerHandle handle =
       content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
           "preemptive_test");
 
   base::RunLoop wait_for_activated;
   BackgroundTracingManager::GetInstance()->SetTracingEnabledCallbackForTesting(
       wait_for_activated.QuitClosure());
   EXPECT_TRUE(BackgroundTracingManager::GetInstance()->SetActiveScenario(
       std::move(config), upload_config_wrapper.get_receive_callback(),
@@ skipping 24 matching lines @@
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
-    scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED");
       rules_dict->SetString("trigger_name", "test1");
       rules_list->Append(std::move(rules_dict));
     }
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED");
       rules_dict->SetString("trigger_name", "test2");
       rules_list->Append(std::move(rules_dict));
     }
 
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
     BackgroundTracingManager::TriggerHandle handle1 =
         BackgroundTracingManager::GetInstance()->RegisterTriggerType("test1");
     BackgroundTracingManager::TriggerHandle handle2 =
         BackgroundTracingManager::GetInstance()->RegisterTriggerType("test2");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
@@ skipping 22 matching lines @@
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
-    scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED");
       rules_dict->SetString("trigger_name", "test2");
       rules_list->Append(std::move(rules_dict));
     }
 
     dict.Set("configs", std::move(rules_list));
     dict.SetString("enable_blink_features", "FasterWeb1,FasterWeb2");
     dict.SetString("disable_blink_features", "SlowerWeb1,SlowerWeb2");
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
     bool scenario_activated =
         BackgroundTracingManager::GetInstance()->SetActiveScenario(
             std::move(config), upload_config_wrapper.get_receive_callback(),
             BackgroundTracingManager::NO_DATA_FILTERING);
 
     EXPECT_TRUE(scenario_activated);
 
@@ skipping 15 matching lines @@
   SetupBackgroundTracingManager();
 
   base::RunLoop run_loop;
   BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
       run_loop.QuitClosure());
 
   base::DictionaryValue dict;
   dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
   dict.SetString("category", "BENCHMARK");
 
-  scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
   {
-    scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> rules_dict(
+        new base::DictionaryValue());
     rules_dict->SetString("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED");
     rules_dict->SetString("trigger_name", "test2");
     rules_list->Append(std::move(rules_dict));
   }
 
   dict.Set("configs", std::move(rules_list));
   dict.SetString("enable_blink_features", "FasterWeb1,FasterWeb2");
   dict.SetString("disable_blink_features", "SlowerWeb1,SlowerWeb2");
-  scoped_ptr<BackgroundTracingConfig> config(
+  std::unique_ptr<BackgroundTracingConfig> config(
       BackgroundTracingConfigImpl::FromDict(&dict));
   EXPECT_TRUE(config);
 
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kEnableBlinkFeatures, "FooFeature");
 
   bool scenario_activated =
       BackgroundTracingManager::GetInstance()->SetActiveScenario(
           std::move(config), upload_config_wrapper.get_receive_callback(),
           BackgroundTracingManager::NO_DATA_FILTERING);
 
   EXPECT_FALSE(scenario_activated);
 }
 
 // This tests that delayed histogram triggers triggers work as expected
 // with preemptive scenarios.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        CallPreemptiveTriggerWithDelay) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
-    scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString(
           "rule", "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE");
       rules_dict->SetString("histogram_name", "fake");
       rules_dict->SetInteger("histogram_value", 1);
       rules_dict->SetInteger("trigger_delay", 10);
       rules_list->Append(std::move(rules_dict));
     }
 
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
         base::Bind(&DisableScenarioWhenIdle));
 
@@ skipping 26 matching lines @@
 // This tests that you can't trigger without a scenario set.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        CannotTriggerWithoutScenarioSet) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
-    scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "preemptive_test");
 
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle,
         base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
   }
 }
 
 // This tests that no trace is triggered with a handle that isn't specified
 // in the config.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        DoesNotTriggerWithWrongHandle) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
-    scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "does_not_exist");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
@@ skipping 12 matching lines @@
 // This tests that no trace is triggered with an invalid handle.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        DoesNotTriggerWithInvalidHandle) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
-    scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "preemptive_test");
 
     content::BackgroundTracingManager::GetInstance()
         ->InvalidateTriggerHandlesForTesting();
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
@@ skipping 20 matching lines @@
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
     base::DictionaryValue dict;
 
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
-    scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED");
       rules_dict->SetString("trigger_name", "preemptive_test");
       rules_dict->SetDouble("trigger_chance", 0.0);
       rules_list->Append(std::move(rules_dict));
     }
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
 
     EXPECT_TRUE(config);
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "preemptive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
@@ skipping 19 matching lines @@
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
     base::DictionaryValue dict;
 
     dict.SetString("mode", "REACTIVE_TRACING_MODE");
 
-    scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString("rule",
                             "TRACE_ON_NAVIGATION_UNTIL_TRIGGER_OR_FULL");
       rules_dict->SetString("trigger_name", "reactive_test1");
       rules_dict->SetString("category", "BENCHMARK");
       rules_dict->SetDouble("trigger_chance", 0.0);
 
       rules_list->Append(std::move(rules_dict));
     }
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
 
     EXPECT_TRUE(config);
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "preemptive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
@@ skipping 20 matching lines @@
 
     base::RunLoop run_loop;
 
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
-    scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString(
           "rule", "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE");
       rules_dict->SetString("histogram_name", "fake");
       rules_dict->SetInteger("histogram_value", 1);
       rules_list->Append(std::move(rules_dict));
     }
 
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     // Our reference value is "1", so a value of "2" should trigger a trace.
     LOCAL_HISTOGRAM_COUNTS("fake", 2);
 
@@ skipping 11 matching lines @@
 
     base::RunLoop run_loop;
 
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
-    scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString(
           "rule", "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE");
       rules_dict->SetString("histogram_name", "fake");
       rules_dict->SetInteger("histogram_value", 1);
       rules_list->Append(std::move(rules_dict));
     }
 
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     // This should fail to trigger a trace since the sample value < the
     // the reference value above.
     LOCAL_HISTOGRAM_COUNTS("fake", 0);
@@ skipping 12 matching lines @@
 
     base::RunLoop run_loop;
 
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
-    scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString(
           "rule", "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE");
       rules_dict->SetString("histogram_name", "fake");
       rules_dict->SetInteger("histogram_lower_value", 1);
       rules_dict->SetInteger("histogram_upper_value", 3);
       rules_list->Append(std::move(rules_dict));
     }
 
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     // This should fail to trigger a trace since the sample value > the
     // the upper reference value above.
     LOCAL_HISTOGRAM_COUNTS("fake", 0);
@@ skipping 10 matching lines @@
   {
     SetupBackgroundTracingManager();
 
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
-    scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString("rule", "INVALID_RULE");
       rules_list->Append(std::move(rules_dict));
     }
 
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     // An invalid config should always return a nullptr here.
     EXPECT_FALSE(config);
   }
 }
 
 // This tests that reactive mode records and terminates with timeout.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        ReactiveTimeoutTermination) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
-    scoped_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
             GetInstance()->RegisterTriggerType("reactive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
@@ skipping 13 matching lines @@
 // This tests that reactive mode records and terminates with a second trigger.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        ReactiveSecondTriggerTermination) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
-    scoped_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
             GetInstance()->RegisterTriggerType("reactive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
@@ skipping 17 matching lines @@
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     base::DictionaryValue dict;
     dict.SetString("mode", "REACTIVE_TRACING_MODE");
 
-    scoped_ptr<base::ListValue> rules_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> rules_list(new base::ListValue());
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString("rule",
                             "TRACE_ON_NAVIGATION_UNTIL_TRIGGER_OR_FULL");
       rules_dict->SetString("trigger_name", "reactive_test1");
       rules_dict->SetString("category", "BENCHMARK");
       rules_list->Append(std::move(rules_dict));
     }
     {
-      scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
+      std::unique_ptr<base::DictionaryValue> rules_dict(
+          new base::DictionaryValue());
       rules_dict->SetString("rule",
                             "TRACE_ON_NAVIGATION_UNTIL_TRIGGER_OR_FULL");
       rules_dict->SetString("trigger_name", "reactive_test2");
       rules_dict->SetString("category", "BENCHMARK");
       rules_list->Append(std::move(rules_dict));
     }
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
 
     BackgroundTracingManager::TriggerHandle handle1 =
         BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "reactive_test1");
     BackgroundTracingManager::TriggerHandle handle2 =
         BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "reactive_test2");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
@@ skipping 24 matching lines @@
 // This tests a third trigger in reactive more does not start another trace.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        ReactiveThirdTriggerTimeout) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
-    scoped_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
             GetInstance()->RegisterTriggerType("reactive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
         std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
         base::Bind(&DisableScenarioWhenIdle));
 
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
     // second trigger to terminate.
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
     // third trigger to trigger again, fails as it is still gathering.
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
 
 }  // namespace content