base: Remove some unnecessary const scoped_refptr<>&.

base/trace_event/memory_dump_manager_unittest.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 "base/trace_event/memory_dump_manager.h"
 
 #include <stdint.h>
 
 #include <vector>
 
@@ skipping 33 matching lines @@
 }
 
 MATCHER(IsLightDump, "") {
   return arg.level_of_detail == MemoryDumpLevelOfDetail::LIGHT;
 }
 
 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,
                           trace_event::TraceResultBuffer* buffer,
                           const scoped_refptr<RefCountedString>& json,
                           bool has_more_events) {
   buffer->AddFragment(json->data());
   if (!has_more_events)
     quit_closure.Run();
 }
@@ skipping 985 matching lines @@
   EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(_, _)).Times(2);
   for (int i = 0; i < 2; ++i) {
     RequestGlobalDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
                              MemoryDumpLevelOfDetail::DETAILED);
   }
   DisableTracing();
 }
 
 }  // namespace trace_event
 }  // namespace base