base: Remove some unnecessary const scoped_refptr<>&.

base/trace_event/memory_dump_manager_unittest.cc

Index: base/trace_event/memory_dump_manager_unittest.cc
diff --git a/base/trace_event/memory_dump_manager_unittest.cc b/base/trace_event/memory_dump_manager_unittest.cc
index 138ba69d5553863d408a9cc49d8a2f10c194de33..12227ee745d0cb061591f6bb33cee35c17608d94 100644
--- a/base/trace_event/memory_dump_manager_unittest.cc
+++ b/base/trace_event/memory_dump_manager_unittest.cc
@@ -51,42 +51,29 @@ namespace {
 
 void RegisterDumpProvider(
     MemoryDumpProvider* mdp,
-    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
-    const MemoryDumpProvider::Options& options,
-    bool dumps_on_single_thread_task_runner) {
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    const MemoryDumpProvider::Options& options) {
   MemoryDumpManager* mdm = MemoryDumpManager::GetInstance();
   mdm->set_dumper_registrations_ignored_for_testing(false);
   const char* kMDPName = "TestDumpProvider";
-  if (dumps_on_single_thread_task_runner) {
-    scoped_refptr<base::SingleThreadTaskRunner> single_thread_task_runner =
-        static_cast<base::SingleThreadTaskRunner*>(task_runner.get());
-    mdm->RegisterDumpProvider(mdp, kMDPName,
-                              std::move(single_thread_task_runner), options);
-  } else {
-    mdm->RegisterDumpProviderWithSequencedTaskRunner(mdp, kMDPName, task_runner,
-                                                     options);
-  }
+  mdm->RegisterDumpProvider(mdp, kMDPName, std::move(task_runner), options);
   mdm->set_dumper_registrations_ignored_for_testing(true);
 }
 
-void RegisterDumpProvider(
-    MemoryDumpProvider* mdp,
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    const MemoryDumpProvider::Options& options) {
-  RegisterDumpProvider(mdp, task_runner, options,
-                       true /* dumps_on_single_thread_task_runner */);
-}
-
 void RegisterDumpProvider(MemoryDumpProvider* mdp) {
   RegisterDumpProvider(mdp, nullptr, MemoryDumpProvider::Options());
 }
 
 void RegisterDumpProviderWithSequencedTaskRunner(
     MemoryDumpProvider* mdp,
-    const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
     const MemoryDumpProvider::Options& options) {
-  RegisterDumpProvider(mdp, task_runner, options,
-                       false /* dumps_on_single_thread_task_runner */);
+  MemoryDumpManager* mdm = MemoryDumpManager::GetInstance();
+  mdm->set_dumper_registrations_ignored_for_testing(false);
+  const char* kMDPName = "TestDumpProvider";

[Primiano Tucci (use gerrit), 2016/03/15 15:58:11]

Why are we re-duplicating the code here? The point of that bool dumps_on_s_t_t_r
was to avoid having two copy/pasted Register methods.

[vmpstr, 2016/03/15 18:57:38]

The part that was a bit awkward was on lines 61-62. It would take a
scoped_refptr, convert it to a raw pointer, downcast it to a derived class, and
wrap that back in a scoped_refptr. It's a bit subtle and it wouldn't work
properly if ever move to std::shared_ptr. 

Duplicating some of the code seemed not too bad. Do you think the previous
approach was better? This is test code, so I don't mind reverting these changes.

+  mdm->RegisterDumpProviderWithSequencedTaskRunner(mdp, kMDPName, task_runner,

[danakj, 2016/03/15 18:27:36]

move the task runner?

+                                                   options);
+  mdm->set_dumper_registrations_ignored_for_testing(true);
 }
 
 void OnTraceDataCollected(Closure quit_closure,