Convert Pass()→std::move() in //content/browser

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"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/pattern.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/tracing/background_tracing_manager_impl.h"
 #include "content/browser/tracing/background_tracing_rule.h"
 #include "content/public/common/content_switches.h"
@@ skipping 84 matching lines @@
   base::DictionaryValue dict;
 
   dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
   dict.SetString("category", "BENCHMARK");
 
   scoped_ptr<base::ListValue> rules_list(new base::ListValue());
   {
     scoped_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(rules_dict.Pass());
+    rules_list->Append(std::move(rules_dict));
   }
-  dict.Set("configs", rules_list.Pass());
+  dict.Set("configs", std::move(rules_list));
 
   scoped_ptr<BackgroundTracingConfig> config(
       BackgroundTracingConfigImpl::FromDict(&dict));
 
   EXPECT_TRUE(config);
-  return config.Pass();
+  return config;
 }
 
 scoped_ptr<BackgroundTracingConfig> CreateReactiveConfig() {
   base::DictionaryValue dict;
 
   dict.SetString("mode", "REACTIVE_TRACING_MODE");
 
   scoped_ptr<base::ListValue> rules_list(new base::ListValue());
   {
     scoped_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(rules_dict.Pass());
+    rules_list->Append(std::move(rules_dict));
   }
-  dict.Set("configs", rules_list.Pass());
+  dict.Set("configs", std::move(rules_list));
 
   scoped_ptr<BackgroundTracingConfig> config(
       BackgroundTracingConfigImpl::FromDict(&dict));
 
   EXPECT_TRUE(config);
-  return config.Pass();
+  return config;
 }
 
 void SetupBackgroundTracingManager() {
   content::BackgroundTracingManager::GetInstance()
       ->InvalidateTriggerHandlesForTesting();
 }
 
 void DisableScenarioWhenIdle() {
   BackgroundTracingManager::GetInstance()->SetActiveScenario(
       NULL, BackgroundTracingManager::ReceiveCallback(),
@@ skipping 10 matching lines @@
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
             GetInstance()->RegisterTriggerType("preemptive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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));
 
     run_loop.Run();
 
@@ skipping 11 matching lines @@
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "preemptive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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));
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false));
 
@@ skipping 34 matching lines @@
   scoped_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(
-      config.Pass(), upload_config_wrapper.get_receive_callback(),
+      std::move(config), upload_config_wrapper.get_receive_callback(),
       BackgroundTracingManager::ANONYMIZE_DATA));
 
   wait_for_activated.Run();
 
   TRACE_EVENT1("benchmark", "whitelisted", "find_this", 1);
   TRACE_EVENT1("benchmark", "not_whitelisted", "this_not_found", 1);
 
   BackgroundTracingManager::GetInstance()->WhenIdle(
       base::Bind(&DisableScenarioWhenIdle));
 
@@ skipping 23 matching lines @@
   scoped_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(
-      config.Pass(), upload_config_wrapper.get_receive_callback(),
+      std::move(config), upload_config_wrapper.get_receive_callback(),
       BackgroundTracingManager::ANONYMIZE_DATA));
 
   wait_for_activated.Run();
 
   BackgroundTracingManager::GetInstance()->WhenIdle(
       base::Bind(&DisableScenarioWhenIdle));
 
   BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
       handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 
@@ skipping 23 matching lines @@
   scoped_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(
-      config.Pass(), upload_config_wrapper.get_receive_callback(),
+      std::move(config), upload_config_wrapper.get_receive_callback(),
       BackgroundTracingManager::ANONYMIZE_DATA));
 
   wait_for_activated.Run();
 
   NavigateToURL(shell(), GetTestUrl("", "about:blank"));
 
   BackgroundTracingManager::GetInstance()->WhenIdle(
       base::Bind(&DisableScenarioWhenIdle));
 
   BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
@@ skipping 19 matching lines @@
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
     scoped_ptr<base::ListValue> rules_list(new base::ListValue());
     {
       scoped_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(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
     {
       scoped_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(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
 
-    dict.Set("configs", rules_list.Pass());
+    dict.Set("configs", std::move(rules_list));
 
     scoped_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(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
         base::Bind(&DisableScenarioWhenIdle));
 
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle2,
         base::Bind(&StartedFinalizingCallback, base::Closure(), false));
@@ skipping 17 matching lines @@
 
     base::DictionaryValue dict;
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
     scoped_ptr<base::ListValue> rules_list(new base::ListValue());
     {
       scoped_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(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
 
-    dict.Set("configs", rules_list.Pass());
+    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(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
     bool scenario_activated =
         BackgroundTracingManager::GetInstance()->SetActiveScenario(
-            config.Pass(), upload_config_wrapper.get_receive_callback(),
+            std::move(config), upload_config_wrapper.get_receive_callback(),
             BackgroundTracingManager::NO_DATA_FILTERING);
 
     EXPECT_TRUE(scenario_activated);
 
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     EXPECT_TRUE(command_line);
 
     EXPECT_EQ(command_line->GetSwitchValueASCII(switches::kEnableBlinkFeatures),
               "FasterWeb1,FasterWeb2");
     EXPECT_EQ(
@@ skipping 14 matching lines @@
 
   base::DictionaryValue dict;
   dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
   dict.SetString("category", "BENCHMARK");
 
   scoped_ptr<base::ListValue> rules_list(new base::ListValue());
   {
     scoped_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(rules_dict.Pass());
+    rules_list->Append(std::move(rules_dict));
   }
 
-  dict.Set("configs", rules_list.Pass());
+  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(
       BackgroundTracingConfigImpl::FromDict(&dict));
   EXPECT_TRUE(config);
 
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kEnableBlinkFeatures, "FooFeature");
 
   bool scenario_activated =
       BackgroundTracingManager::GetInstance()->SetActiveScenario(
-          config.Pass(), upload_config_wrapper.get_receive_callback(),
+          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());
     {
       scoped_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(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
 
-    dict.Set("configs", rules_list.Pass());
+    dict.Set("configs", std::move(rules_list));
 
     scoped_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
         base::Bind(&DisableScenarioWhenIdle));
 
     base::RunLoop rule_triggered_runloop;
     BackgroundTracingManagerImpl::GetInstance()
         ->SetRuleTriggeredCallbackForTesting(
             rule_triggered_runloop.QuitClosure());
 
@@ skipping 55 matching lines @@
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
     scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "does_not_exist");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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, run_loop.QuitClosure(), false));
 
     run_loop.Run();
@@ skipping 15 matching lines @@
     scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "preemptive_test");
 
     content::BackgroundTracingManager::GetInstance()
         ->InvalidateTriggerHandlesForTesting();
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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, run_loop.QuitClosure(), false));
 
     run_loop.Run();
@@ skipping 16 matching lines @@
 
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
     scoped_ptr<base::ListValue> rules_list(new base::ListValue());
     {
       scoped_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(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
-    dict.Set("configs", rules_list.Pass());
+    dict.Set("configs", std::move(rules_list));
 
     scoped_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
 
     EXPECT_TRUE(config);
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "preemptive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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, run_loop.QuitClosure(), false));
 
     run_loop.Run();
@@ skipping 18 matching lines @@
 
     scoped_ptr<base::ListValue> rules_list(new base::ListValue());
     {
       scoped_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(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
-    dict.Set("configs", rules_list.Pass());
+    dict.Set("configs", std::move(rules_list));
 
     scoped_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
 
     EXPECT_TRUE(config);
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "preemptive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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, run_loop.QuitClosure(), false));
 
     run_loop.Run();
@@ skipping 17 matching lines @@
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
     scoped_ptr<base::ListValue> rules_list(new base::ListValue());
     {
       scoped_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(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
 
-    dict.Set("configs", rules_list.Pass());
+    dict.Set("configs", std::move(rules_list));
 
     scoped_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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);
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
@@ skipping 13 matching lines @@
     dict.SetString("mode", "PREEMPTIVE_TRACING_MODE");
     dict.SetString("category", "BENCHMARK");
 
     scoped_ptr<base::ListValue> rules_list(new base::ListValue());
     {
       scoped_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(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
 
-    dict.Set("configs", rules_list.Pass());
+    dict.Set("configs", std::move(rules_list));
 
     scoped_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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);
 
     run_loop.RunUntilIdle();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
   }
@@ skipping 15 matching lines @@
     dict.SetString("category", "BENCHMARK");
 
     scoped_ptr<base::ListValue> rules_list(new base::ListValue());
     {
       scoped_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(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
 
-    dict.Set("configs", rules_list.Pass());
+    dict.Set("configs", std::move(rules_list));
 
     scoped_ptr<BackgroundTracingConfig> config(
         BackgroundTracingConfigImpl::FromDict(&dict));
     EXPECT_TRUE(config);
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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);
 
     run_loop.RunUntilIdle();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
   }
 }
 
 // This tests that invalid preemptive mode configs will fail.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        SetActiveScenarioFailsWithInvalidPreemptiveConfig) {
   {
     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());
     {
       scoped_ptr<base::DictionaryValue> rules_dict(new base::DictionaryValue());
       rules_dict->SetString("rule", "INVALID_RULE");
-      rules_list->Append(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
 
-    dict.Set("configs", rules_list.Pass());
+    dict.Set("configs", std::move(rules_list));
 
     scoped_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();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
             GetInstance()->RegisterTriggerType("reactive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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));
 
     BackgroundTracingManager::GetInstance()->FireTimerForTesting();
 
@@ skipping 13 matching lines @@
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     scoped_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
             GetInstance()->RegisterTriggerType("reactive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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));
@@ skipping 17 matching lines @@
     base::DictionaryValue dict;
     dict.SetString("mode", "REACTIVE_TRACING_MODE");
 
     scoped_ptr<base::ListValue> rules_list(new base::ListValue());
     {
       scoped_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(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
     {
       scoped_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(rules_dict.Pass());
+      rules_list->Append(std::move(rules_dict));
     }
-    dict.Set("configs", rules_list.Pass());
+    dict.Set("configs", std::move(rules_list));
 
     scoped_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(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        std::move(config), upload_config_wrapper.get_receive_callback(),
         BackgroundTracingManager::NO_DATA_FILTERING);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
         base::Bind(&DisableScenarioWhenIdle));
 
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 
     // This is expected to fail since we triggered with handle1.
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
@@ skipping 20 matching lines @@
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     scoped_ptr<BackgroundTracingConfig> config = CreateReactiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::
             GetInstance()->RegisterTriggerType("reactive_test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        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