diff --git a/content/browser/tracing/background_tracing_config_impl.cc b/content/browser/tracing/background_tracing_config_impl.cc
index 741e90e..25d6aa91 100644
--- a/content/browser/tracing/background_tracing_config_impl.cc
+++ b/content/browser/tracing/background_tracing_config_impl.cc
@@ -117,9 +117,10 @@
       break;
   }
 
-  scoped_ptr<base::ListValue> configs_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> configs_list(new base::ListValue());
   for (const auto& it : rules_) {
-    scoped_ptr<base::DictionaryValue> config_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> config_dict(
+        new base::DictionaryValue());
     DCHECK(it);
     it->IntoDict(config_dict.get());
     configs_list->Append(std::move(config_dict));
@@ -137,7 +138,7 @@
 
 void BackgroundTracingConfigImpl::AddPreemptiveRule(
     const base::DictionaryValue* dict) {
-  scoped_ptr<BackgroundTracingRule> rule =
+  std::unique_ptr<BackgroundTracingRule> rule =
       BackgroundTracingRule::PreemptiveRuleFromDict(dict);
   if (rule)
     rules_.push_back(std::move(rule));
@@ -146,21 +147,21 @@
 void BackgroundTracingConfigImpl::AddReactiveRule(
     const base::DictionaryValue* dict,
     BackgroundTracingConfigImpl::CategoryPreset category_preset) {
-  scoped_ptr<BackgroundTracingRule> rule =
+  std::unique_ptr<BackgroundTracingRule> rule =
       BackgroundTracingRule::ReactiveRuleFromDict(dict, category_preset);
   if (rule)
     rules_.push_back(std::move(rule));
 }
 
-scoped_ptr<BackgroundTracingConfigImpl> BackgroundTracingConfigImpl::FromDict(
-    const base::DictionaryValue* dict) {
+std::unique_ptr<BackgroundTracingConfigImpl>
+BackgroundTracingConfigImpl::FromDict(const base::DictionaryValue* dict) {
   DCHECK(dict);
 
   std::string mode;
   if (!dict->GetString(kConfigModeKey, &mode))
     return nullptr;
 
-  scoped_ptr<BackgroundTracingConfigImpl> config;
+  std::unique_ptr<BackgroundTracingConfigImpl> config;
 
   if (mode == kConfigModePreemptive) {
     config = PreemptiveFromDict(dict);
@@ -181,12 +182,12 @@
   return config;
 }
 
-scoped_ptr<BackgroundTracingConfigImpl>
+std::unique_ptr<BackgroundTracingConfigImpl>
 BackgroundTracingConfigImpl::PreemptiveFromDict(
     const base::DictionaryValue* dict) {
   DCHECK(dict);
 
-  scoped_ptr<BackgroundTracingConfigImpl> config(
+  std::unique_ptr<BackgroundTracingConfigImpl> config(
       new BackgroundTracingConfigImpl(BackgroundTracingConfigImpl::PREEMPTIVE));
 
   std::string category_preset_string;
@@ -215,12 +216,12 @@
   return config;
 }
 
-scoped_ptr<BackgroundTracingConfigImpl>
+std::unique_ptr<BackgroundTracingConfigImpl>
 BackgroundTracingConfigImpl::ReactiveFromDict(
     const base::DictionaryValue* dict) {
   DCHECK(dict);
 
-  scoped_ptr<BackgroundTracingConfigImpl> config(
+  std::unique_ptr<BackgroundTracingConfigImpl> config(
       new BackgroundTracingConfigImpl(BackgroundTracingConfigImpl::REACTIVE));
 
   const base::ListValue* configs_list = nullptr;
diff --git a/content/browser/tracing/background_tracing_config_impl.h b/content/browser/tracing/background_tracing_config_impl.h
index 0cee4b19..58c3e4d6 100644
--- a/content/browser/tracing/background_tracing_config_impl.h
+++ b/content/browser/tracing/background_tracing_config_impl.h
@@ -53,12 +53,12 @@
       const base::DictionaryValue* dict,
       BackgroundTracingConfigImpl::CategoryPreset category_preset);
 
-  static scoped_ptr<BackgroundTracingConfigImpl> PreemptiveFromDict(
+  static std::unique_ptr<BackgroundTracingConfigImpl> PreemptiveFromDict(
       const base::DictionaryValue* dict);
-  static scoped_ptr<BackgroundTracingConfigImpl> ReactiveFromDict(
+  static std::unique_ptr<BackgroundTracingConfigImpl> ReactiveFromDict(
       const base::DictionaryValue* dict);
 
-  static scoped_ptr<BackgroundTracingConfigImpl> FromDict(
+  static std::unique_ptr<BackgroundTracingConfigImpl> FromDict(
       const base::DictionaryValue* dict);
 
   static std::string CategoryPresetToString(
diff --git a/content/browser/tracing/background_tracing_config_unittest.cc b/content/browser/tracing/background_tracing_config_unittest.cc
index 901e865..73ff081 100644
--- a/content/browser/tracing/background_tracing_config_unittest.cc
+++ b/content/browser/tracing/background_tracing_config_unittest.cc
@@ -2,9 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <memory>
+
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "content/browser/tracing/background_tracing_config_impl.h"
 #include "content/browser/tracing/background_tracing_rule.h"
@@ -23,22 +24,22 @@
   TestBrowserThread ui_thread_;
 };
 
-scoped_ptr<BackgroundTracingConfigImpl> ReadFromJSONString(
+std::unique_ptr<BackgroundTracingConfigImpl> ReadFromJSONString(
     const std::string& json_text) {
-  scoped_ptr<base::Value> json_value(base::JSONReader::Read(json_text));
+  std::unique_ptr<base::Value> json_value(base::JSONReader::Read(json_text));
 
   base::DictionaryValue* dict = NULL;
   if (json_value)
     json_value->GetAsDictionary(&dict);
 
-  scoped_ptr<BackgroundTracingConfigImpl> config(
+  std::unique_ptr<BackgroundTracingConfigImpl> config(
       static_cast<BackgroundTracingConfigImpl*>(
           BackgroundTracingConfig::FromDict(dict).release()));
   return config;
 }
 
 std::string ConfigToString(const BackgroundTracingConfig* config) {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
   config->IntoDict(dict.get());
 
@@ -49,7 +50,7 @@
 }
 
 std::string RuleToString(const BackgroundTracingRule* rule) {
-  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
   rule->IntoDict(dict.get());
 
@@ -167,7 +168,7 @@
 }
 
 TEST_F(BackgroundTracingConfigTest, PreemptiveConfigFromValidString) {
-  scoped_ptr<BackgroundTracingConfigImpl> config;
+  std::unique_ptr<BackgroundTracingConfigImpl> config;
 
   config = ReadFromJSONString(
       "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": "
@@ -270,7 +271,7 @@
 }
 
 TEST_F(BackgroundTracingConfigTest, ValidPreemptiveCategoryToString) {
-  scoped_ptr<BackgroundTracingConfigImpl> config = ReadFromJSONString(
+  std::unique_ptr<BackgroundTracingConfigImpl> config = ReadFromJSONString(
       "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": "
       "\"BENCHMARK\",\"configs\": [{\"rule\": "
       "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"trigger_name\":\"foo\"}]}");
@@ -301,14 +302,14 @@
             "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\",\"trigger_name\":"
             "\"foo\"}],\"mode\":\"PREEMPTIVE_TRACING_MODE\"}");
     EXPECT_EQ(ConfigToString(config.get()), expected.c_str());
-    scoped_ptr<BackgroundTracingConfigImpl> config2 =
+    std::unique_ptr<BackgroundTracingConfigImpl> config2 =
         ReadFromJSONString(expected);
     EXPECT_EQ(config->category_preset(), config2->category_preset());
   }
 }
 
 TEST_F(BackgroundTracingConfigTest, ReactiveConfigFromValidString) {
-  scoped_ptr<BackgroundTracingConfigImpl> config;
+  std::unique_ptr<BackgroundTracingConfigImpl> config;
 
   config = ReadFromJSONString(
       "{\"mode\":\"REACTIVE_TRACING_MODE\",\"configs\": [{\"rule\": "
@@ -378,7 +379,7 @@
 }
 
 TEST_F(BackgroundTracingConfigTest, ValidPreemptiveConfigToString) {
-  scoped_ptr<BackgroundTracingConfigImpl> config(
+  std::unique_ptr<BackgroundTracingConfigImpl> config(
       new BackgroundTracingConfigImpl(BackgroundTracingConfig::PREEMPTIVE));
 
   // Default values
@@ -397,7 +398,7 @@
         new BackgroundTracingConfigImpl(BackgroundTracingConfig::PREEMPTIVE));
     config->set_category_preset(BackgroundTracingConfigImpl::BENCHMARK_DEEP);
 
-    scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     dict->SetString("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED");
     dict->SetString("trigger_name", "foo");
     config->AddPreemptiveRule(dict.get());
@@ -413,7 +414,7 @@
         new BackgroundTracingConfigImpl(BackgroundTracingConfig::PREEMPTIVE));
     config->set_category_preset(BackgroundTracingConfigImpl::BENCHMARK_DEEP);
 
-    scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     dict->SetString("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED");
     dict->SetString("trigger_name", "foo");
     dict->SetDouble("trigger_chance", 0.5);
@@ -431,7 +432,7 @@
         new BackgroundTracingConfigImpl(BackgroundTracingConfig::PREEMPTIVE));
     config->set_category_preset(BackgroundTracingConfigImpl::BENCHMARK_DEEP);
 
-    scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     dict->SetString("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED");
     dict->SetString("trigger_name", "foo1");
     config->AddPreemptiveRule(dict.get());
@@ -451,7 +452,8 @@
     config.reset(
         new BackgroundTracingConfigImpl(BackgroundTracingConfig::PREEMPTIVE));
 
-    scoped_ptr<base::DictionaryValue> second_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> second_dict(
+        new base::DictionaryValue());
     second_dict->SetString(
         "rule", "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE");
     second_dict->SetString("histogram_name", "foo");
@@ -471,7 +473,8 @@
     config.reset(
         new BackgroundTracingConfigImpl(BackgroundTracingConfig::PREEMPTIVE));
 
-    scoped_ptr<base::DictionaryValue> second_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> second_dict(
+        new base::DictionaryValue());
     second_dict->SetString(
         "rule", "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE");
     second_dict->SetString("histogram_name", "foo");
@@ -493,7 +496,7 @@
         new BackgroundTracingConfigImpl(BackgroundTracingConfig::PREEMPTIVE));
     config->set_category_preset(BackgroundTracingConfigImpl::BENCHMARK_DEEP);
 
-    scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     dict->SetString("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED");
     dict->SetString("trigger_name", "foo1");
     config->AddPreemptiveRule(dict.get());
@@ -513,13 +516,13 @@
 }
 
 TEST_F(BackgroundTracingConfigTest, InvalidPreemptiveConfigToString) {
-  scoped_ptr<BackgroundTracingConfigImpl> config;
+  std::unique_ptr<BackgroundTracingConfigImpl> config;
 
   {
     config.reset(
         new BackgroundTracingConfigImpl(BackgroundTracingConfig::PREEMPTIVE));
 
-    scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     dict->SetString("rule", "MONITOR_AND_DUMP_WHEN_BROWSER_STARTUP_COMPLETE");
     config->AddPreemptiveRule(dict.get());
 
@@ -532,7 +535,8 @@
     config.reset(
         new BackgroundTracingConfigImpl(BackgroundTracingConfig::PREEMPTIVE));
 
-    scoped_ptr<base::DictionaryValue> second_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> second_dict(
+        new base::DictionaryValue());
     second_dict->SetString(
         "rule", "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE");
     second_dict->SetString("histogram_name", "foo");
@@ -547,7 +551,8 @@
     config.reset(
         new BackgroundTracingConfigImpl(BackgroundTracingConfig::PREEMPTIVE));
 
-    scoped_ptr<base::DictionaryValue> second_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> second_dict(
+        new base::DictionaryValue());
     second_dict->SetString(
         "rule", "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE");
     second_dict->SetString("histogram_name", "foo");
@@ -561,7 +566,7 @@
 }
 
 TEST_F(BackgroundTracingConfigTest, ValidReactiveConfigToString) {
-  scoped_ptr<BackgroundTracingConfigImpl> config(
+  std::unique_ptr<BackgroundTracingConfigImpl> config(
       new BackgroundTracingConfigImpl(BackgroundTracingConfig::REACTIVE));
 
   // Default values
@@ -572,7 +577,7 @@
     config.reset(
         new BackgroundTracingConfigImpl(BackgroundTracingConfig::REACTIVE));
 
-    scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     dict->SetString("rule", "TRACE_ON_NAVIGATION_UNTIL_TRIGGER_OR_FULL");
     dict->SetString("trigger_name", "foo");
     config->AddReactiveRule(dict.get(),
@@ -588,7 +593,7 @@
     config.reset(
         new BackgroundTracingConfigImpl(BackgroundTracingConfig::REACTIVE));
 
-    scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     dict->SetString("rule", "TRACE_ON_NAVIGATION_UNTIL_TRIGGER_OR_FULL");
     dict->SetString("trigger_name", "foo1");
     config->AddReactiveRule(dict.get(),
diff --git a/content/browser/tracing/background_tracing_manager_browsertest.cc b/content/browser/tracing/background_tracing_manager_browsertest.cc
index e0001b8..1ca3fe9 100644
--- a/content/browser/tracing/background_tracing_manager_browsertest.cc
+++ b/content/browser/tracing/background_tracing_manager_browsertest.cc
@@ -39,7 +39,7 @@
   }
 
   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);
@@ -97,36 +97,38 @@
     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");
@@ -134,7 +136,7 @@
   }
   dict.Set("configs", std::move(rules_list));
 
-  scoped_ptr<BackgroundTracingConfig> config(
+  std::unique_ptr<BackgroundTracingConfig> config(
       BackgroundTracingConfigImpl::FromDict(&dict));
 
   EXPECT_TRUE(config);
@@ -162,7 +164,7 @@
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
-    scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
@@ -194,7 +196,7 @@
     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(
@@ -246,7 +248,7 @@
   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(
@@ -290,7 +292,7 @@
   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(
@@ -334,7 +336,7 @@
   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(
@@ -379,15 +381,17 @@
     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));
@@ -395,7 +399,7 @@
 
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
@@ -438,9 +442,10 @@
     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));
@@ -449,7 +454,7 @@
     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);
 
@@ -485,9 +490,10 @@
   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));
@@ -496,7 +502,7 @@
   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);
 
@@ -526,9 +532,10 @@
     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");
@@ -539,7 +546,7 @@
 
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
@@ -586,7 +593,7 @@
     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(
@@ -613,7 +620,7 @@
     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(
@@ -646,7 +653,7 @@
     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(
@@ -687,9 +694,10 @@
     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);
@@ -697,7 +705,7 @@
     }
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
 
     EXPECT_TRUE(config);
@@ -737,9 +745,10 @@
 
     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");
@@ -750,7 +759,7 @@
     }
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
 
     EXPECT_TRUE(config);
@@ -791,9 +800,10 @@
     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");
@@ -803,7 +813,7 @@
 
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
@@ -835,9 +845,10 @@
     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");
@@ -847,7 +858,7 @@
 
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
@@ -880,9 +891,10 @@
     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");
@@ -893,7 +905,7 @@
 
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
@@ -924,16 +936,17 @@
     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);
@@ -950,7 +963,7 @@
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
-    scoped_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
@@ -984,7 +997,7 @@
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
-    scoped_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
@@ -1022,9 +1035,10 @@
     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");
@@ -1032,7 +1046,8 @@
       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");
@@ -1041,7 +1056,7 @@
     }
     dict.Set("configs", std::move(rules_list));
 
-    scoped_ptr<BackgroundTracingConfig> config(
+    std::unique_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
 
     BackgroundTracingManager::TriggerHandle handle1 =
@@ -1086,7 +1101,7 @@
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
-    scoped_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
+    std::unique_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
diff --git a/content/browser/tracing/background_tracing_manager_impl.cc b/content/browser/tracing/background_tracing_manager_impl.cc
index ca39488..32fac32 100644
--- a/content/browser/tracing/background_tracing_manager_impl.cc
+++ b/content/browser/tracing/background_tracing_manager_impl.cc
@@ -101,7 +101,7 @@
 }
 
 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));
@@ -136,7 +136,7 @@
                    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();
@@ -400,7 +400,7 @@
 }
 
 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));
 
@@ -452,7 +452,8 @@
     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));
 
diff --git a/content/browser/tracing/background_tracing_manager_impl.h b/content/browser/tracing/background_tracing_manager_impl.h
index f1d88f2..bcb25a42 100644
--- a/content/browser/tracing/background_tracing_manager_impl.h
+++ b/content/browser/tracing/background_tracing_manager_impl.h
@@ -5,10 +5,11 @@
 #ifndef CONTENT_BROWSER_TRACING_BACKGROUND_TRACING_MANAGER_IMPL_H_
 #define CONTENT_BROWSER_TRACING_BACKGROUND_TRACING_MANAGER_IMPL_H_
 
+#include <memory>
+
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "content/browser/tracing/background_tracing_config_impl.h"
@@ -25,7 +26,7 @@
  public:
   static CONTENT_EXPORT BackgroundTracingManagerImpl* GetInstance();
 
-  bool SetActiveScenario(scoped_ptr<BackgroundTracingConfig>,
+  bool SetActiveScenario(std::unique_ptr<BackgroundTracingConfig>,
                          const ReceiveCallback&,
                          DataFiltering data_filtering) override;
   void WhenIdle(IdleCallback idle_callback) override;
@@ -55,9 +56,8 @@
 
   void StartTracing(std::string, base::trace_event::TraceRecordMode);
   void StartTracingIfConfigNeedsIt();
-  void OnFinalizeStarted(
-      scoped_ptr<const base::DictionaryValue> metadata,
-      base::RefCountedString*);
+  void OnFinalizeStarted(std::unique_ptr<const base::DictionaryValue> metadata,
+                         base::RefCountedString*);
   void OnFinalizeComplete();
   void BeginFinalizing(StartedFinalizingCallback);
   void ValidateStartupScenario();
@@ -90,10 +90,10 @@
     StartedFinalizingCallback callback_;
   };
 
-  scoped_ptr<TracingDelegate> delegate_;
-  scoped_ptr<const content::BackgroundTracingConfigImpl> config_;
+  std::unique_ptr<TracingDelegate> delegate_;
+  std::unique_ptr<const content::BackgroundTracingConfigImpl> config_;
   std::map<TriggerHandle, std::string> trigger_handles_;
-  scoped_ptr<TracingTimer> tracing_timer_;
+  std::unique_ptr<TracingTimer> tracing_timer_;
   ReceiveCallback receive_callback_;
 
   bool is_gathering_;
diff --git a/content/browser/tracing/background_tracing_rule.cc b/content/browser/tracing/background_tracing_rule.cc
index f09608a..cf11772 100644
--- a/content/browser/tracing/background_tracing_rule.cc
+++ b/content/browser/tracing/background_tracing_rule.cc
@@ -92,13 +92,13 @@
       : named_event_(named_event) {}
 
  public:
-  static scoped_ptr<BackgroundTracingRule> Create(
+  static std::unique_ptr<BackgroundTracingRule> Create(
       const base::DictionaryValue* dict) {
     std::string trigger_name;
     if (!dict->GetString(kConfigRuleTriggerNameKey, &trigger_name))
       return nullptr;
 
-    return scoped_ptr<BackgroundTracingRule>(
+    return std::unique_ptr<BackgroundTracingRule>(
         new NamedTriggerRule(trigger_name));
   }
 
@@ -132,7 +132,7 @@
         trigger_delay_(trigger_delay) {}
 
  public:
-  static scoped_ptr<BackgroundTracingRule> Create(
+  static std::unique_ptr<BackgroundTracingRule> Create(
       const base::DictionaryValue* dict) {
     std::string histogram_name;
     if (!dict->GetString(kConfigRuleHistogramNameKey, &histogram_name))
@@ -161,7 +161,7 @@
     int trigger_delay = -1;
     dict->GetInteger(kConfigRuleTriggerDelay, &trigger_delay);
 
-    return scoped_ptr<BackgroundTracingRule>(
+    return std::unique_ptr<BackgroundTracingRule>(
         new HistogramRule(histogram_name, histogram_lower_value,
                           histogram_upper_value, repeat, trigger_delay));
   }
@@ -263,14 +263,14 @@
       : named_event_(named_event), category_preset_(category_preset) {}
 
  public:
-  static scoped_ptr<BackgroundTracingRule> Create(
+  static std::unique_ptr<BackgroundTracingRule> Create(
       const base::DictionaryValue* dict,
       BackgroundTracingConfigImpl::CategoryPreset category_preset) {
     std::string trigger_name;
     if (!dict->GetString(kConfigRuleTriggerNameKey, &trigger_name))
       return nullptr;
 
-    return scoped_ptr<BackgroundTracingRule>(
+    return std::unique_ptr<BackgroundTracingRule>(
         new ReactiveTraceForNSOrTriggerOrFullRule(trigger_name,
                                                   category_preset));
   }
@@ -318,7 +318,7 @@
   }
 
  public:
-  static scoped_ptr<BackgroundTracingRule> Create(
+  static std::unique_ptr<BackgroundTracingRule> Create(
       const base::DictionaryValue* dict,
       BackgroundTracingConfigImpl::CategoryPreset category_preset) {
     int timeout_min;
@@ -332,7 +332,7 @@
     if (timeout_min > timeout_max)
       return nullptr;
 
-    return scoped_ptr<BackgroundTracingRule>(
+    return std::unique_ptr<BackgroundTracingRule>(
         new ReactiveTraceAtRandomIntervalsRule(category_preset, timeout_min,
                                                timeout_max));
   }
@@ -411,7 +411,8 @@
 
 }  // namespace
 
-scoped_ptr<BackgroundTracingRule> BackgroundTracingRule::PreemptiveRuleFromDict(
+std::unique_ptr<BackgroundTracingRule>
+BackgroundTracingRule::PreemptiveRuleFromDict(
     const base::DictionaryValue* dict) {
   DCHECK(dict);
 
@@ -419,7 +420,7 @@
   if (!dict->GetString(kConfigRuleKey, &type))
     return nullptr;
 
-  scoped_ptr<BackgroundTracingRule> tracing_rule;
+  std::unique_ptr<BackgroundTracingRule> tracing_rule;
   if (type == kPreemptiveConfigRuleMonitorNamed)
     tracing_rule = NamedTriggerRule::Create(dict);
   else if (type == kPreemptiveConfigRuleMonitorHistogram)
@@ -431,7 +432,8 @@
   return tracing_rule;
 }
 
-scoped_ptr<BackgroundTracingRule> BackgroundTracingRule::ReactiveRuleFromDict(
+std::unique_ptr<BackgroundTracingRule>
+BackgroundTracingRule::ReactiveRuleFromDict(
     const base::DictionaryValue* dict,
     BackgroundTracingConfigImpl::CategoryPreset category_preset) {
   DCHECK(dict);
@@ -440,7 +442,7 @@
   if (!dict->GetString(kConfigRuleKey, &type))
     return nullptr;
 
-  scoped_ptr<BackgroundTracingRule> tracing_rule;
+  std::unique_ptr<BackgroundTracingRule> tracing_rule;
 
   if (type == kReactiveConfigRuleTraceOnNavigationUntilTriggerOrFull) {
     tracing_rule =
diff --git a/content/browser/tracing/background_tracing_rule.h b/content/browser/tracing/background_tracing_rule.h
index 3277716b..236ef91 100644
--- a/content/browser/tracing/background_tracing_rule.h
+++ b/content/browser/tracing/background_tracing_rule.h
@@ -33,10 +33,10 @@
   // Probability that we should allow a tigger to  happen.
   double trigger_chance() const { return trigger_chance_; }
 
-  static scoped_ptr<BackgroundTracingRule> PreemptiveRuleFromDict(
+  static std::unique_ptr<BackgroundTracingRule> PreemptiveRuleFromDict(
       const base::DictionaryValue* dict);
 
-  static scoped_ptr<BackgroundTracingRule> ReactiveRuleFromDict(
+  static std::unique_ptr<BackgroundTracingRule> ReactiveRuleFromDict(
       const base::DictionaryValue* dict,
       BackgroundTracingConfigImpl::CategoryPreset category_preset);
 
diff --git a/content/browser/tracing/etw_system_event_consumer_win.cc b/content/browser/tracing/etw_system_event_consumer_win.cc
index 09d81f7..ede14ced 100644
--- a/content/browser/tracing/etw_system_event_consumer_win.cc
+++ b/content/browser/tracing/etw_system_event_consumer_win.cc
@@ -166,7 +166,7 @@
   now_in_us.QuadPart = now.ToInternalValue();
 
   // Add fields to the event.
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   value->Set("guid", new base::StringValue("ClockSync"));
   value->Set("walltime", new base::StringValue(
       base::StringPrintf("%08X%08X",
@@ -184,7 +184,7 @@
 void EtwSystemEventConsumer::AppendEventToBuffer(EVENT_TRACE* event) {
   using base::FundamentalValue;
 
-  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 
   // Add header fields to the event.
   LARGE_INTEGER ts_us;
@@ -230,7 +230,7 @@
 void EtwSystemEventConsumer::FlushOnThread(
     const StopAgentTracingCallback& callback) {
   // Add the header information to the stream.
-  scoped_ptr<base::DictionaryValue> header(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> header(new base::DictionaryValue());
   header->Set("name", new base::StringValue("ETW"));
 
   // Release and pass the events buffer.
diff --git a/content/browser/tracing/etw_system_event_consumer_win.h b/content/browser/tracing/etw_system_event_consumer_win.h
index f14a37e..35d7d4c 100644
--- a/content/browser/tracing/etw_system_event_consumer_win.h
+++ b/content/browser/tracing/etw_system_event_consumer_win.h
@@ -5,10 +5,11 @@
 #ifndef CONTENT_BROWSER_TRACING_ETW_SYSTEM_EVENT_CONSUMER_WIN_H_
 #define CONTENT_BROWSER_TRACING_ETW_SYSTEM_EVENT_CONSUMER_WIN_H_
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/threading/thread.h"
 #include "base/trace_event/tracing_agent.h"
 #include "base/values.h"
@@ -69,7 +70,7 @@
   void TraceAndConsumeOnThread();
   void FlushOnThread(const StopAgentTracingCallback& callback);
 
-  scoped_ptr<base::ListValue> events_;
+  std::unique_ptr<base::ListValue> events_;
   base::Thread thread_;
   TRACEHANDLE session_handle_;
   base::win::EtwTraceProperties properties_;
diff --git a/content/browser/tracing/memory_tracing_browsertest.cc b/content/browser/tracing/memory_tracing_browsertest.cc
index 13b0923..cec3bb82 100644
--- a/content/browser/tracing/memory_tracing_browsertest.cc
+++ b/content/browser/tracing/memory_tracing_browsertest.cc
@@ -126,7 +126,7 @@
   }
 
   base::Closure on_memory_dump_complete_closure_;
-  scoped_ptr<MockDumpProvider> mock_dump_provider_;
+  std::unique_ptr<MockDumpProvider> mock_dump_provider_;
   uint32_t callback_call_count_;
   uint64_t last_callback_dump_guid_;
   bool last_callback_success_;
diff --git a/content/browser/tracing/power_tracing_agent.h b/content/browser/tracing/power_tracing_agent.h
index 0fa97fe..ae5079e4 100644
--- a/content/browser/tracing/power_tracing_agent.h
+++ b/content/browser/tracing/power_tracing_agent.h
@@ -5,9 +5,10 @@
 #ifndef CONTENT_BROWSER_TRACING_POWER_TRACING_AGENT_H_
 #define CONTENT_BROWSER_TRACING_POWER_TRACING_AGENT_H_
 
+#include <memory>
+
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/threading/thread.h"
 #include "base/trace_event/tracing_agent.h"
 #include "content/public/browser/browser_thread.h"
@@ -68,7 +69,7 @@
 
   // All interactions with the BattOrAgent (after construction) must happen on
   // the IO thread.
-  scoped_ptr<battor::BattOrAgent, BrowserThread::DeleteOnIOThread>
+  std::unique_ptr<battor::BattOrAgent, BrowserThread::DeleteOnIOThread>
       battor_agent_;
 
   StartAgentTracingCallback start_tracing_callback_;
diff --git a/content/browser/tracing/tracing_controller_browsertest.cc b/content/browser/tracing/tracing_controller_browsertest.cc
index 8cafbd7d..29fbba1 100644
--- a/content/browser/tracing/tracing_controller_browsertest.cc
+++ b/content/browser/tracing/tracing_controller_browsertest.cc
@@ -59,7 +59,7 @@
     : public TracingController::TraceDataEndpoint {
  public:
   TracingControllerTestEndpoint(
-      base::Callback<void(scoped_ptr<const base::DictionaryValue>,
+      base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
                           base::RefCountedString*)> done_callback)
       : done_callback_(done_callback) {}
 
@@ -69,7 +69,7 @@
   }
 
   void ReceiveTraceFinalContents(
-      scoped_ptr<const base::DictionaryValue> metadata,
+      std::unique_ptr<const base::DictionaryValue> metadata,
       const std::string& contents) override {
     EXPECT_EQ(trace_, contents);
 
@@ -87,8 +87,9 @@
   ~TracingControllerTestEndpoint() override {}
 
   std::string trace_;
-  base::Callback<void(scoped_ptr<const base::DictionaryValue>,
-                      base::RefCountedString*)> done_callback_;
+  base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                      base::RefCountedString*)>
+      done_callback_;
 };
 
 class TracingControllerTest : public ContentBrowserTest {
@@ -122,7 +123,7 @@
 
   void StopTracingStringDoneCallbackTest(
       base::Closure quit_callback,
-      scoped_ptr<const base::DictionaryValue> metadata,
+      std::unique_ptr<const base::DictionaryValue> metadata,
       base::RefCountedString* data) {
     disable_recording_done_callback_count_++;
     last_metadata_.reset(metadata.release());
@@ -186,11 +187,11 @@
 
     {
       base::RunLoop run_loop;
-      base::Callback<void(scoped_ptr<const base::DictionaryValue>,
-                          base::RefCountedString*)> callback = base::Bind(
-          &TracingControllerTest::StopTracingStringDoneCallbackTest,
-          base::Unretained(this),
-          run_loop.QuitClosure());
+      base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                          base::RefCountedString*)>
+          callback = base::Bind(
+              &TracingControllerTest::StopTracingStringDoneCallbackTest,
+              base::Unretained(this), run_loop.QuitClosure());
       bool result = controller->StopTracing(
           TracingController::CreateStringSink(callback));
       ASSERT_TRUE(result);
@@ -224,11 +225,11 @@
 
     {
       base::RunLoop run_loop;
-      base::Callback<void(scoped_ptr<const base::DictionaryValue>,
-                          base::RefCountedString*)> callback = base::Bind(
-          &TracingControllerTest::StopTracingStringDoneCallbackTest,
-          base::Unretained(this),
-          run_loop.QuitClosure());
+      base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                          base::RefCountedString*)>
+          callback = base::Bind(
+              &TracingControllerTest::StopTracingStringDoneCallbackTest,
+              base::Unretained(this), run_loop.QuitClosure());
 
       scoped_refptr<TracingController::TraceDataSink> trace_data_sink =
           TracingController::CreateStringSink(callback);
@@ -264,10 +265,11 @@
 
     {
       base::RunLoop run_loop;
-      base::Callback<void(scoped_ptr<const base::DictionaryValue>,
-                          base::RefCountedString*)> callback = base::Bind(
-          &TracingControllerTest::StopTracingStringDoneCallbackTest,
-          base::Unretained(this), run_loop.QuitClosure());
+      base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                          base::RefCountedString*)>
+          callback = base::Bind(
+              &TracingControllerTest::StopTracingStringDoneCallbackTest,
+              base::Unretained(this), run_loop.QuitClosure());
       bool result = controller->StopTracing(
           TracingController::CreateCompressedStringSink(
               new TracingControllerTestEndpoint(callback)));
@@ -347,7 +349,7 @@
   int enable_recording_done_callback_count_;
   int disable_recording_done_callback_count_;
   base::FilePath last_actual_recording_file_path_;
-  scoped_ptr<const base::DictionaryValue> last_metadata_;
+  std::unique_ptr<const base::DictionaryValue> last_metadata_;
   std::string last_data_;
 };
 
diff --git a/content/browser/tracing/tracing_controller_impl.cc b/content/browser/tracing/tracing_controller_impl.cc
index 06ef7c8f..aba7a75 100644
--- a/content/browser/tracing/tracing_controller_impl.cc
+++ b/content/browser/tracing/tracing_controller_impl.cc
@@ -108,8 +108,9 @@
   return std::string();
 }
 
-scoped_ptr<base::DictionaryValue> GenerateTracingMetadataDict()  {
-  scoped_ptr<base::DictionaryValue> metadata_dict(new base::DictionaryValue());
+std::unique_ptr<base::DictionaryValue> GenerateTracingMetadataDict() {
+  std::unique_ptr<base::DictionaryValue> metadata_dict(
+      new base::DictionaryValue());
 
   metadata_dict->SetString("network-type", GetNetworkTypeString());
   metadata_dict->SetString("product-version", GetContentClient()->GetProduct());
@@ -158,7 +159,7 @@
   metadata_dict->SetString("gpu-gl-renderer", gpu_info.gl_renderer);
 #endif
 
-  scoped_ptr<TracingDelegate> delegate(
+  std::unique_ptr<TracingDelegate> delegate(
       GetContentClient()->browser()->GetTracingDelegate());
   if (delegate)
     delegate->GenerateMetadataDict(metadata_dict.get());
@@ -348,7 +349,7 @@
   if (trace_data_sink) {
     if (TraceLog::GetInstance()->GetCurrentTraceConfig()
         .IsArgumentFilterEnabled()) {
-      scoped_ptr<TracingDelegate> delegate(
+      std::unique_ptr<TracingDelegate> delegate(
           GetContentClient()->browser()->GetTracingDelegate());
       if (delegate) {
         trace_data_sink->SetMetadataFilterPredicate(
diff --git a/content/browser/tracing/tracing_controller_impl.h b/content/browser/tracing/tracing_controller_impl.h
index 7a6c17b..eb7761e 100644
--- a/content/browser/tracing/tracing_controller_impl.h
+++ b/content/browser/tracing/tracing_controller_impl.h
@@ -171,7 +171,7 @@
   int pending_start_tracing_ack_count_;
   base::OneShotTimer start_tracing_timer_;
   StartTracingDoneCallback start_tracing_done_callback_;
-  scoped_ptr<base::trace_event::TraceConfig> start_tracing_trace_config_;
+  std::unique_ptr<base::trace_event::TraceConfig> start_tracing_trace_config_;
 
   // Pending acks for StopTracing.
   int pending_stop_tracing_ack_count_;
diff --git a/content/browser/tracing/tracing_controller_impl_data_sinks.cc b/content/browser/tracing/tracing_controller_impl_data_sinks.cc
index 1ee6327..4020df1 100644
--- a/content/browser/tracing/tracing_controller_impl_data_sinks.cc
+++ b/content/browser/tracing/tracing_controller_impl_data_sinks.cc
@@ -21,14 +21,15 @@
 
 class StringTraceDataEndpoint : public TracingController::TraceDataEndpoint {
  public:
-  typedef base::Callback<void(scoped_ptr<const base::DictionaryValue>,
-                              base::RefCountedString*)> CompletionCallback;
+  typedef base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                              base::RefCountedString*)>
+      CompletionCallback;
 
   explicit StringTraceDataEndpoint(CompletionCallback callback)
       : completion_callback_(callback) {}
 
   void ReceiveTraceFinalContents(
-      scoped_ptr<const base::DictionaryValue> metadata,
+      std::unique_ptr<const base::DictionaryValue> metadata,
       const std::string& contents) override {
     std::string tmp = contents;
     scoped_refptr<base::RefCountedString> str =
@@ -66,9 +67,8 @@
                    chunk_ptr));
   }
 
-  void ReceiveTraceFinalContents(
-      scoped_ptr<const base::DictionaryValue> ,
-      const std::string& contents) override {
+  void ReceiveTraceFinalContents(std::unique_ptr<const base::DictionaryValue>,
+                                 const std::string& contents) override {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&FileTraceDataEndpoint::CloseOnFileThread, this));
@@ -288,7 +288,7 @@
   }
 
   scoped_refptr<TracingController::TraceDataEndpoint> endpoint_;
-  scoped_ptr<z_stream> stream_;
+  std::unique_ptr<z_stream> stream_;
   bool already_tried_open_;
   std::string compressed_trace_data_;
 
@@ -324,12 +324,13 @@
   metadata_filter_predicate_ = metadata_filter_predicate;
 }
 
-scoped_ptr<const base::DictionaryValue>
-    TracingController::TraceDataSink::GetMetadataCopy() const {
+std::unique_ptr<const base::DictionaryValue>
+TracingController::TraceDataSink::GetMetadataCopy() const {
   if (metadata_filter_predicate_.is_null())
-    return scoped_ptr<const base::DictionaryValue>(metadata_.DeepCopy());
+    return std::unique_ptr<const base::DictionaryValue>(metadata_.DeepCopy());
 
-  scoped_ptr<base::DictionaryValue> metadata_copy(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> metadata_copy(
+      new base::DictionaryValue);
   for (base::DictionaryValue::Iterator it(metadata_); !it.IsAtEnd();
        it.Advance()) {
     if (metadata_filter_predicate_.Run(it.key()))
@@ -342,7 +343,7 @@
 
 scoped_refptr<TracingController::TraceDataSink>
 TracingController::CreateStringSink(
-    const base::Callback<void(scoped_ptr<const base::DictionaryValue>,
+    const base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
                               base::RefCountedString*)>& callback) {
   return new StringTraceDataSink(new StringTraceDataEndpoint(callback));
 }
@@ -361,9 +362,9 @@
 }
 
 scoped_refptr<TracingController::TraceDataEndpoint>
-TracingController::CreateCallbackEndpoint(const base::Callback<
-    void(scoped_ptr<const base::DictionaryValue>,
-         base::RefCountedString*)>& callback) {
+TracingController::CreateCallbackEndpoint(
+    const base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
+                              base::RefCountedString*)>& callback) {
   return new StringTraceDataEndpoint(callback);
 }
 
diff --git a/content/browser/tracing/tracing_ui.cc b/content/browser/tracing/tracing_ui.cc
index 074a771..04452c4 100644
--- a/content/browser/tracing/tracing_ui.cc
+++ b/content/browser/tracing/tracing_ui.cc
@@ -6,6 +6,7 @@
 
 #include <stddef.h>
 
+#include <memory>
 #include <set>
 #include <string>
 #include <vector>
@@ -17,7 +18,6 @@
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ -62,7 +62,7 @@
     return false;
   }
 
-  scoped_ptr<base::Value> optionsRaw = base::JSONReader::Read(data);
+  std::unique_ptr<base::Value> optionsRaw = base::JSONReader::Read(data);
   if (!optionsRaw) {
     LOG(ERROR) << "Options were not valid JSON";
     return false;
@@ -147,7 +147,7 @@
 
 void TracingCallbackWrapperBase64(
     const WebUIDataSource::GotDataCallback& callback,
-    scoped_ptr<const base::DictionaryValue> metadata,
+    std::unique_ptr<const base::DictionaryValue> metadata,
     base::RefCountedString* data) {
   base::RefCountedString* data_base64 = new base::RefCountedString();
   base::Base64Encode(data->data(), &data_base64->data());
diff --git a/content/browser/tracing/tracing_ui.h b/content/browser/tracing/tracing_ui.h
index 4e65de1..fdbe0c19 100644
--- a/content/browser/tracing/tracing_ui.h
+++ b/content/browser/tracing/tracing_ui.h
@@ -33,8 +33,8 @@
   void DoUpload(const base::ListValue* args);
   void DoUploadBase64Encoded(const base::ListValue* args);
 
-  scoped_ptr<TracingDelegate> delegate_;
-  scoped_ptr<TraceUploader> trace_uploader_;
+  std::unique_ptr<TracingDelegate> delegate_;
+  std::unique_ptr<TraceUploader> trace_uploader_;
   base::WeakPtrFactory<TracingUI> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TracingUI);