base: Remove some unnecessary const scoped_refptr<>&.
This patch removes some unnecessary const scoped_refptr<>&. It replaces
some instances with a copy of scoped_refptr, followed by a move. Other
instances, it passes a raw non-owning pointer.
R=danakj
BUG=589044
Review URL: https://codereview.chromium.org/1800743003
Cr-Commit-Position: refs/heads/master@{#382043}
diff --git a/base/deferred_sequenced_task_runner.cc b/base/deferred_sequenced_task_runner.cc
index f805b50..7d09ef83 100644
--- a/base/deferred_sequenced_task_runner.cc
+++ b/base/deferred_sequenced_task_runner.cc
@@ -20,10 +20,8 @@
}
DeferredSequencedTaskRunner::DeferredSequencedTaskRunner(
- const scoped_refptr<SequencedTaskRunner>& target_task_runner)
- : started_(false),
- target_task_runner_(target_task_runner) {
-}
+ scoped_refptr<SequencedTaskRunner> target_task_runner)
+ : started_(false), target_task_runner_(std::move(target_task_runner)) {}
DeferredSequencedTaskRunner::~DeferredSequencedTaskRunner() {
}
diff --git a/base/deferred_sequenced_task_runner.h b/base/deferred_sequenced_task_runner.h
index 5a57e867..e5d57df 100644
--- a/base/deferred_sequenced_task_runner.h
+++ b/base/deferred_sequenced_task_runner.h
@@ -24,7 +24,7 @@
class BASE_EXPORT DeferredSequencedTaskRunner : public SequencedTaskRunner {
public:
explicit DeferredSequencedTaskRunner(
- const scoped_refptr<SequencedTaskRunner>& target_runner);
+ scoped_refptr<SequencedTaskRunner> target_runner);
// TaskRunner implementation
bool PostDelayedTask(const tracked_objects::Location& from_here,
diff --git a/base/files/important_file_writer.cc b/base/files/important_file_writer.cc
index b429305..a724dc36 100644
--- a/base/files/important_file_writer.cc
+++ b/base/files/important_file_writer.cc
@@ -126,19 +126,18 @@
ImportantFileWriter::ImportantFileWriter(
const FilePath& path,
- const scoped_refptr<SequencedTaskRunner>& task_runner)
+ scoped_refptr<SequencedTaskRunner> task_runner)
: ImportantFileWriter(
- path,
- task_runner,
- TimeDelta::FromMilliseconds(kDefaultCommitIntervalMs)) {
-}
+ path,
+ std::move(task_runner),
+ TimeDelta::FromMilliseconds(kDefaultCommitIntervalMs)) {}
ImportantFileWriter::ImportantFileWriter(
const FilePath& path,
- const scoped_refptr<SequencedTaskRunner>& task_runner,
+ scoped_refptr<SequencedTaskRunner> task_runner,
TimeDelta interval)
: path_(path),
- task_runner_(task_runner),
+ task_runner_(std::move(task_runner)),
serializer_(nullptr),
commit_interval_(interval),
weak_factory_(this) {
diff --git a/base/files/important_file_writer.h b/base/files/important_file_writer.h
index 1b2ad5c..4d18c0bd 100644
--- a/base/files/important_file_writer.h
+++ b/base/files/important_file_writer.h
@@ -63,11 +63,11 @@
// execute file I/O operations.
// All non-const methods, ctor and dtor must be called on the same thread.
ImportantFileWriter(const FilePath& path,
- const scoped_refptr<SequencedTaskRunner>& task_runner);
+ scoped_refptr<SequencedTaskRunner> task_runner);
// Same as above, but with a custom commit interval.
ImportantFileWriter(const FilePath& path,
- const scoped_refptr<SequencedTaskRunner>& task_runner,
+ scoped_refptr<SequencedTaskRunner> task_runner,
TimeDelta interval);
// You have to ensure that there are no pending writes at the moment
diff --git a/base/memory/ref_counted_delete_on_message_loop.h b/base/memory/ref_counted_delete_on_message_loop.h
index 84f80d8..de194e8 100644
--- a/base/memory/ref_counted_delete_on_message_loop.h
+++ b/base/memory/ref_counted_delete_on_message_loop.h
@@ -19,10 +19,8 @@
// Sample usage:
// class Foo : public RefCountedDeleteOnMessageLoop<Foo> {
//
-// Foo(const scoped_refptr<SingleThreadTaskRunner>& loop)
-// : RefCountedDeleteOnMessageLoop<Foo>(loop) {
-// ...
-// }
+// Foo(scoped_refptr<SingleThreadTaskRunner> loop)
+// : RefCountedDeleteOnMessageLoop<Foo>(std::move(loop)) {}
// ...
// private:
// friend class RefCountedDeleteOnMessageLoop<Foo>;
@@ -40,8 +38,8 @@
// MessageLoop on the current thread can be acquired by calling
// MessageLoop::current()->task_runner().
RefCountedDeleteOnMessageLoop(
- const scoped_refptr<SingleThreadTaskRunner>& task_runner)
- : task_runner_(task_runner) {
+ scoped_refptr<SingleThreadTaskRunner> task_runner)
+ : task_runner_(std::move(task_runner)) {
DCHECK(task_runner_);
}
diff --git a/base/test/sequenced_task_runner_test_template.cc b/base/test/sequenced_task_runner_test_template.cc
index 010f439..0022aac 100644
--- a/base/test/sequenced_task_runner_test_template.cc
+++ b/base/test/sequenced_task_runner_test_template.cc
@@ -23,7 +23,7 @@
}
void SequencedTaskTracker::PostWrappedNonNestableTask(
- const scoped_refptr<SequencedTaskRunner>& task_runner,
+ SequencedTaskRunner* task_runner,
const Closure& task) {
AutoLock event_lock(lock_);
const int post_i = next_post_i_++;
@@ -34,7 +34,7 @@
}
void SequencedTaskTracker::PostWrappedNestableTask(
- const scoped_refptr<SequencedTaskRunner>& task_runner,
+ SequencedTaskRunner* task_runner,
const Closure& task) {
AutoLock event_lock(lock_);
const int post_i = next_post_i_++;
@@ -45,7 +45,7 @@
}
void SequencedTaskTracker::PostWrappedDelayedNonNestableTask(
- const scoped_refptr<SequencedTaskRunner>& task_runner,
+ SequencedTaskRunner* task_runner,
const Closure& task,
TimeDelta delay) {
AutoLock event_lock(lock_);
@@ -57,7 +57,7 @@
}
void SequencedTaskTracker::PostNonNestableTasks(
- const scoped_refptr<SequencedTaskRunner>& task_runner,
+ SequencedTaskRunner* task_runner,
int task_count) {
for (int i = 0; i < task_count; ++i) {
PostWrappedNonNestableTask(task_runner, Closure());
diff --git a/base/test/sequenced_task_runner_test_template.h b/base/test/sequenced_task_runner_test_template.h
index d0717cd7..ac5f3c6 100644
--- a/base/test/sequenced_task_runner_test_template.h
+++ b/base/test/sequenced_task_runner_test_template.h
@@ -41,25 +41,20 @@
SequencedTaskTracker();
// Posts the non-nestable task |task|, and records its post event.
- void PostWrappedNonNestableTask(
- const scoped_refptr<SequencedTaskRunner>& task_runner,
- const Closure& task);
+ void PostWrappedNonNestableTask(SequencedTaskRunner* task_runner,
+ const Closure& task);
// Posts the nestable task |task|, and records its post event.
- void PostWrappedNestableTask(
- const scoped_refptr<SequencedTaskRunner>& task_runner,
- const Closure& task);
+ void PostWrappedNestableTask(SequencedTaskRunner* task_runner,
+ const Closure& task);
// Posts the delayed non-nestable task |task|, and records its post event.
- void PostWrappedDelayedNonNestableTask(
- const scoped_refptr<SequencedTaskRunner>& task_runner,
- const Closure& task,
- TimeDelta delay);
+ void PostWrappedDelayedNonNestableTask(SequencedTaskRunner* task_runner,
+ const Closure& task,
+ TimeDelta delay);
// Posts |task_count| non-nestable tasks.
- void PostNonNestableTasks(
- const scoped_refptr<SequencedTaskRunner>& task_runner,
- int task_count);
+ void PostNonNestableTasks(SequencedTaskRunner* task_runner, int task_count);
const std::vector<TaskEvent>& GetTaskEvents() const;
@@ -141,9 +136,11 @@
this->delegate_.GetTaskRunner();
this->task_tracker_->PostWrappedNonNestableTask(
- task_runner, Bind(&PlatformThread::Sleep, TimeDelta::FromSeconds(1)));
+ task_runner.get(),
+ Bind(&PlatformThread::Sleep, TimeDelta::FromSeconds(1)));
for (int i = 1; i < kTaskCount; ++i) {
- this->task_tracker_->PostWrappedNonNestableTask(task_runner, Closure());
+ this->task_tracker_->PostWrappedNonNestableTask(task_runner.get(),
+ Closure());
}
this->delegate_.StopTaskRunner();
@@ -163,10 +160,10 @@
this->delegate_.GetTaskRunner();
this->task_tracker_->PostWrappedNestableTask(
- task_runner,
+ task_runner.get(),
Bind(&PlatformThread::Sleep, TimeDelta::FromSeconds(1)));
for (int i = 1; i < kTaskCount; ++i) {
- this->task_tracker_->PostWrappedNestableTask(task_runner, Closure());
+ this->task_tracker_->PostWrappedNestableTask(task_runner.get(), Closure());
}
this->delegate_.StopTaskRunner();
@@ -188,8 +185,7 @@
for (int i = 0; i < kTaskCount; ++i) {
this->task_tracker_->PostWrappedDelayedNonNestableTask(
- task_runner,
- Closure(),
+ task_runner.get(), Closure(),
TimeDelta::FromMilliseconds(kDelayIncrementMs * i));
}
@@ -217,7 +213,7 @@
this->task_tracker_,
task_runner,
kChildrenPerParent);
- this->task_tracker_->PostWrappedNonNestableTask(task_runner, task);
+ this->task_tracker_->PostWrappedNonNestableTask(task_runner.get(), task);
}
this->delegate_.StopTaskRunner();
@@ -242,10 +238,10 @@
const scoped_refptr<SequencedTaskRunner> task_runner =
this->delegate_.GetTaskRunner();
- this->task_tracker_->PostWrappedDelayedNonNestableTask(
- task_runner, Closure(), kDelay);
- this->task_tracker_->PostWrappedDelayedNonNestableTask(
- task_runner, Closure(), kDelay);
+ this->task_tracker_->PostWrappedDelayedNonNestableTask(task_runner.get(),
+ Closure(), kDelay);
+ this->task_tracker_->PostWrappedDelayedNonNestableTask(task_runner.get(),
+ Closure(), kDelay);
this->task_tracker_->WaitForCompletedTasks(kTaskCount);
this->delegate_.StopTaskRunner();
@@ -264,10 +260,10 @@
this->delegate_.GetTaskRunner();
this->task_tracker_->PostWrappedNonNestableTask(
- task_runner, base::Bind(&PlatformThread::Sleep,
- TimeDelta::FromMilliseconds(50)));
+ task_runner.get(),
+ base::Bind(&PlatformThread::Sleep, TimeDelta::FromMilliseconds(50)));
this->task_tracker_->PostWrappedDelayedNonNestableTask(
- task_runner, Closure(), TimeDelta::FromMilliseconds(10));
+ task_runner.get(), Closure(), TimeDelta::FromMilliseconds(10));
this->task_tracker_->WaitForCompletedTasks(kTaskCount);
this->delegate_.StopTaskRunner();
@@ -286,11 +282,11 @@
for (int i = 0; i < kTaskCount - 1; i++) {
this->task_tracker_->PostWrappedNonNestableTask(
- task_runner, base::Bind(&PlatformThread::Sleep,
- TimeDelta::FromMilliseconds(50)));
+ task_runner.get(),
+ base::Bind(&PlatformThread::Sleep, TimeDelta::FromMilliseconds(50)));
}
this->task_tracker_->PostWrappedDelayedNonNestableTask(
- task_runner, Closure(), TimeDelta::FromMilliseconds(10));
+ task_runner.get(), Closure(), TimeDelta::FromMilliseconds(10));
this->task_tracker_->WaitForCompletedTasks(kTaskCount);
this->delegate_.StopTaskRunner();
@@ -333,8 +329,8 @@
this->delegate_.GetTaskRunner();
Time time_before_run = Time::Now();
- this->task_tracker_->PostWrappedDelayedNonNestableTask(task_runner, Closure(),
- kDelay);
+ this->task_tracker_->PostWrappedDelayedNonNestableTask(task_runner.get(),
+ Closure(), kDelay);
this->task_tracker_->WaitForCompletedTasks(kTaskCount);
this->delegate_.StopTaskRunner();
Time time_after_run = Time::Now();
diff --git a/base/test/task_runner_test_template.cc b/base/test/task_runner_test_template.cc
index efc2193..5983b8a 100644
--- a/base/test/task_runner_test_template.cc
+++ b/base/test/task_runner_test_template.cc
@@ -37,9 +37,8 @@
task_runs_cv_.Wait();
}
-void ExpectRunsTasksOnCurrentThread(
- bool expected_value,
- const scoped_refptr<TaskRunner>& task_runner) {
+void ExpectRunsTasksOnCurrentThread(bool expected_value,
+ TaskRunner* task_runner) {
EXPECT_EQ(expected_value, task_runner->RunsTasksOnCurrentThread());
}
diff --git a/base/test/task_runner_test_template.h b/base/test/task_runner_test_template.h
index cc16469..c0d3a128 100644
--- a/base/test/task_runner_test_template.h
+++ b/base/test/task_runner_test_template.h
@@ -175,9 +175,8 @@
// Calls RunsTasksOnCurrentThread() on |task_runner| and expects it to
// equal |expected_value|.
-void ExpectRunsTasksOnCurrentThread(
- bool expected_value,
- const scoped_refptr<TaskRunner>& task_runner);
+void ExpectRunsTasksOnCurrentThread(bool expected_value,
+ TaskRunner* task_runner);
} // namespace test
diff --git a/base/thread_task_runner_handle.cc b/base/thread_task_runner_handle.cc
index ee337b38..911e90c 100644
--- a/base/thread_task_runner_handle.cc
+++ b/base/thread_task_runner_handle.cc
@@ -30,8 +30,8 @@
}
ThreadTaskRunnerHandle::ThreadTaskRunnerHandle(
- const scoped_refptr<SingleThreadTaskRunner>& task_runner)
- : task_runner_(task_runner) {
+ scoped_refptr<SingleThreadTaskRunner> task_runner)
+ : task_runner_(std::move(task_runner)) {
DCHECK(task_runner_->BelongsToCurrentThread());
DCHECK(!lazy_tls_ptr.Pointer()->Get());
lazy_tls_ptr.Pointer()->Set(this);
diff --git a/base/thread_task_runner_handle.h b/base/thread_task_runner_handle.h
index 197669ed..2a6282bf 100644
--- a/base/thread_task_runner_handle.h
+++ b/base/thread_task_runner_handle.h
@@ -29,7 +29,7 @@
// Binds |task_runner| to the current thread. |task_runner| must belong
// to the current thread for this to succeed.
explicit ThreadTaskRunnerHandle(
- const scoped_refptr<SingleThreadTaskRunner>& task_runner);
+ scoped_refptr<SingleThreadTaskRunner> task_runner);
~ThreadTaskRunnerHandle();
private:
diff --git a/base/threading/sequenced_worker_pool.cc b/base/threading/sequenced_worker_pool.cc
index 081a49f3..086f54b 100644
--- a/base/threading/sequenced_worker_pool.cc
+++ b/base/threading/sequenced_worker_pool.cc
@@ -98,7 +98,7 @@
class SequencedWorkerPoolTaskRunner : public TaskRunner {
public:
SequencedWorkerPoolTaskRunner(
- const scoped_refptr<SequencedWorkerPool>& pool,
+ scoped_refptr<SequencedWorkerPool> pool,
SequencedWorkerPool::WorkerShutdown shutdown_behavior);
// TaskRunner implementation
@@ -118,11 +118,9 @@
};
SequencedWorkerPoolTaskRunner::SequencedWorkerPoolTaskRunner(
- const scoped_refptr<SequencedWorkerPool>& pool,
+ scoped_refptr<SequencedWorkerPool> pool,
SequencedWorkerPool::WorkerShutdown shutdown_behavior)
- : pool_(pool),
- shutdown_behavior_(shutdown_behavior) {
-}
+ : pool_(std::move(pool)), shutdown_behavior_(shutdown_behavior) {}
SequencedWorkerPoolTaskRunner::~SequencedWorkerPoolTaskRunner() {
}
@@ -150,7 +148,7 @@
class SequencedWorkerPoolSequencedTaskRunner : public SequencedTaskRunner {
public:
SequencedWorkerPoolSequencedTaskRunner(
- const scoped_refptr<SequencedWorkerPool>& pool,
+ scoped_refptr<SequencedWorkerPool> pool,
SequencedWorkerPool::SequenceToken token,
SequencedWorkerPool::WorkerShutdown shutdown_behavior);
@@ -178,13 +176,12 @@
};
SequencedWorkerPoolSequencedTaskRunner::SequencedWorkerPoolSequencedTaskRunner(
- const scoped_refptr<SequencedWorkerPool>& pool,
+ scoped_refptr<SequencedWorkerPool> pool,
SequencedWorkerPool::SequenceToken token,
SequencedWorkerPool::WorkerShutdown shutdown_behavior)
- : pool_(pool),
+ : pool_(std::move(pool)),
token_(token),
- shutdown_behavior_(shutdown_behavior) {
-}
+ shutdown_behavior_(shutdown_behavior) {}
SequencedWorkerPoolSequencedTaskRunner::
~SequencedWorkerPoolSequencedTaskRunner() {
@@ -230,7 +227,7 @@
public:
// Hold a (cyclic) ref to |worker_pool|, since we want to keep it
// around as long as we are running.
- Worker(const scoped_refptr<SequencedWorkerPool>& worker_pool,
+ Worker(scoped_refptr<SequencedWorkerPool> worker_pool,
int thread_number,
const std::string& thread_name_prefix);
~Worker() override;
@@ -504,11 +501,11 @@
// Worker definitions ---------------------------------------------------------
SequencedWorkerPool::Worker::Worker(
- const scoped_refptr<SequencedWorkerPool>& worker_pool,
+ scoped_refptr<SequencedWorkerPool> worker_pool,
int thread_number,
const std::string& prefix)
: SimpleThread(prefix + StringPrintf("Worker%d", thread_number)),
- worker_pool_(worker_pool),
+ worker_pool_(std::move(worker_pool)),
task_shutdown_behavior_(BLOCK_SHUTDOWN),
is_processing_task_(false) {
Start();
diff --git a/base/threading/sequenced_worker_pool_unittest.cc b/base/threading/sequenced_worker_pool_unittest.cc
index fba1808..2855b9f 100644
--- a/base/threading/sequenced_worker_pool_unittest.cc
+++ b/base/threading/sequenced_worker_pool_unittest.cc
@@ -75,9 +75,8 @@
class DestructionDeadlockChecker
: public base::RefCountedThreadSafe<DestructionDeadlockChecker> {
public:
- explicit DestructionDeadlockChecker(
- const scoped_refptr<SequencedWorkerPool>& pool)
- : pool_(pool) {}
+ explicit DestructionDeadlockChecker(scoped_refptr<SequencedWorkerPool> pool)
+ : pool_(std::move(pool)) {}
protected:
virtual ~DestructionDeadlockChecker() {
diff --git a/base/trace_event/memory_dump_manager.cc b/base/trace_event/memory_dump_manager.cc
index 4ba7fcb..56cc902 100644
--- a/base/trace_event/memory_dump_manager.cc
+++ b/base/trace_event/memory_dump_manager.cc
@@ -211,43 +211,43 @@
void MemoryDumpManager::RegisterDumpProvider(
MemoryDumpProvider* mdp,
const char* name,
- const scoped_refptr<SingleThreadTaskRunner>& task_runner,
+ scoped_refptr<SingleThreadTaskRunner> task_runner,
MemoryDumpProvider::Options options) {
options.dumps_on_single_thread_task_runner = true;
- RegisterDumpProviderInternal(mdp, name, task_runner, options);
+ RegisterDumpProviderInternal(mdp, name, std::move(task_runner), options);
}
void MemoryDumpManager::RegisterDumpProvider(
MemoryDumpProvider* mdp,
const char* name,
- const scoped_refptr<SingleThreadTaskRunner>& task_runner) {
+ scoped_refptr<SingleThreadTaskRunner> task_runner) {
// Set |dumps_on_single_thread_task_runner| to true because all providers
// without task runner are run on dump thread.
MemoryDumpProvider::Options options;
options.dumps_on_single_thread_task_runner = true;
- RegisterDumpProviderInternal(mdp, name, task_runner, options);
+ RegisterDumpProviderInternal(mdp, name, std::move(task_runner), options);
}
void MemoryDumpManager::RegisterDumpProviderWithSequencedTaskRunner(
MemoryDumpProvider* mdp,
const char* name,
- const scoped_refptr<SequencedTaskRunner>& task_runner,
+ scoped_refptr<SequencedTaskRunner> task_runner,
MemoryDumpProvider::Options options) {
DCHECK(task_runner);
options.dumps_on_single_thread_task_runner = false;
- RegisterDumpProviderInternal(mdp, name, task_runner, options);
+ RegisterDumpProviderInternal(mdp, name, std::move(task_runner), options);
}
void MemoryDumpManager::RegisterDumpProviderInternal(
MemoryDumpProvider* mdp,
const char* name,
- const scoped_refptr<SequencedTaskRunner>& task_runner,
+ scoped_refptr<SequencedTaskRunner> task_runner,
const MemoryDumpProvider::Options& options) {
if (dumper_registrations_ignored_for_testing_)
return;
scoped_refptr<MemoryDumpProviderInfo> mdpinfo =
- new MemoryDumpProviderInfo(mdp, name, task_runner, options);
+ new MemoryDumpProviderInfo(mdp, name, std::move(task_runner), options);
{
AutoLock lock(lock_);
@@ -703,11 +703,11 @@
MemoryDumpManager::MemoryDumpProviderInfo::MemoryDumpProviderInfo(
MemoryDumpProvider* dump_provider,
const char* name,
- const scoped_refptr<SequencedTaskRunner>& task_runner,
+ scoped_refptr<SequencedTaskRunner> task_runner,
const MemoryDumpProvider::Options& options)
: dump_provider(dump_provider),
name(name),
- task_runner(task_runner),
+ task_runner(std::move(task_runner)),
options(options),
consecutive_failures(0),
disabled(false) {}
@@ -729,15 +729,15 @@
MemoryDumpManager::ProcessMemoryDumpAsyncState::ProcessMemoryDumpAsyncState(
MemoryDumpRequestArgs req_args,
const MemoryDumpProviderInfo::OrderedSet& dump_providers,
- const scoped_refptr<MemoryDumpSessionState>& session_state,
+ scoped_refptr<MemoryDumpSessionState> session_state,
MemoryDumpCallback callback,
- const scoped_refptr<SingleThreadTaskRunner>& dump_thread_task_runner)
+ scoped_refptr<SingleThreadTaskRunner> dump_thread_task_runner)
: req_args(req_args),
- session_state(session_state),
+ session_state(std::move(session_state)),
callback(callback),
dump_successful(true),
callback_task_runner(MessageLoop::current()->task_runner()),
- dump_thread_task_runner(dump_thread_task_runner) {
+ dump_thread_task_runner(std::move(dump_thread_task_runner)) {
pending_dump_providers.reserve(dump_providers.size());
pending_dump_providers.assign(dump_providers.rbegin(), dump_providers.rend());
}
diff --git a/base/trace_event/memory_dump_manager.h b/base/trace_event/memory_dump_manager.h
index e9b09f8..79686c8 100644
--- a/base/trace_event/memory_dump_manager.h
+++ b/base/trace_event/memory_dump_manager.h
@@ -73,19 +73,17 @@
// the calls to |mdp| will be run on the given |task_runner|. If passed
// null |mdp| should be able to handle calls on arbitrary threads.
// - options: extra optional arguments. See memory_dump_provider.h.
- void RegisterDumpProvider(
- MemoryDumpProvider* mdp,
- const char* name,
- const scoped_refptr<SingleThreadTaskRunner>& task_runner);
- void RegisterDumpProvider(
- MemoryDumpProvider* mdp,
- const char* name,
- const scoped_refptr<SingleThreadTaskRunner>& task_runner,
- MemoryDumpProvider::Options options);
+ void RegisterDumpProvider(MemoryDumpProvider* mdp,
+ const char* name,
+ scoped_refptr<SingleThreadTaskRunner> task_runner);
+ void RegisterDumpProvider(MemoryDumpProvider* mdp,
+ const char* name,
+ scoped_refptr<SingleThreadTaskRunner> task_runner,
+ MemoryDumpProvider::Options options);
void RegisterDumpProviderWithSequencedTaskRunner(
MemoryDumpProvider* mdp,
const char* name,
- const scoped_refptr<SequencedTaskRunner>& task_runner,
+ scoped_refptr<SequencedTaskRunner> task_runner,
MemoryDumpProvider::Options options);
void UnregisterDumpProvider(MemoryDumpProvider* mdp);
@@ -174,11 +172,10 @@
using OrderedSet =
std::set<scoped_refptr<MemoryDumpProviderInfo>, Comparator>;
- MemoryDumpProviderInfo(
- MemoryDumpProvider* dump_provider,
- const char* name,
- const scoped_refptr<SequencedTaskRunner>& task_runner,
- const MemoryDumpProvider::Options& options);
+ MemoryDumpProviderInfo(MemoryDumpProvider* dump_provider,
+ const char* name,
+ scoped_refptr<SequencedTaskRunner> task_runner,
+ const MemoryDumpProvider::Options& options);
MemoryDumpProvider* const dump_provider;
@@ -217,9 +214,9 @@
ProcessMemoryDumpAsyncState(
MemoryDumpRequestArgs req_args,
const MemoryDumpProviderInfo::OrderedSet& dump_providers,
- const scoped_refptr<MemoryDumpSessionState>& session_state,
+ scoped_refptr<MemoryDumpSessionState> session_state,
MemoryDumpCallback callback,
- const scoped_refptr<SingleThreadTaskRunner>& dump_thread_task_runner);
+ scoped_refptr<SingleThreadTaskRunner> dump_thread_task_runner);
~ProcessMemoryDumpAsyncState();
// Gets or creates the memory dump container for the given target process.
@@ -299,7 +296,7 @@
void RegisterDumpProviderInternal(
MemoryDumpProvider* mdp,
const char* name,
- const scoped_refptr<SequencedTaskRunner>& task_runner,
+ scoped_refptr<SequencedTaskRunner> task_runner,
const MemoryDumpProvider::Options& options);
// Helper for the public UnregisterDumpProvider* functions.
diff --git a/base/trace_event/memory_dump_manager_unittest.cc b/base/trace_event/memory_dump_manager_unittest.cc
index 138ba69..12227ee7 100644
--- a/base/trace_event/memory_dump_manager_unittest.cc
+++ b/base/trace_event/memory_dump_manager_unittest.cc
@@ -51,42 +51,29 @@
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";
+ mdm->RegisterDumpProviderWithSequencedTaskRunner(mdp, kMDPName, task_runner,
+ options);
+ mdm->set_dumper_registrations_ignored_for_testing(true);
}
void OnTraceDataCollected(Closure quit_closure,
diff --git a/base/trace_event/process_memory_dump.cc b/base/trace_event/process_memory_dump.cc
index 74cbcc29..1642e5a3 100644
--- a/base/trace_event/process_memory_dump.cc
+++ b/base/trace_event/process_memory_dump.cc
@@ -144,10 +144,10 @@
#endif // defined(COUNT_RESIDENT_BYTES_SUPPORTED)
ProcessMemoryDump::ProcessMemoryDump(
- const scoped_refptr<MemoryDumpSessionState>& session_state)
+ scoped_refptr<MemoryDumpSessionState> session_state)
: has_process_totals_(false),
has_process_mmaps_(false),
- session_state_(session_state) {}
+ session_state_(std::move(session_state)) {}
ProcessMemoryDump::~ProcessMemoryDump() {}
diff --git a/base/trace_event/process_memory_dump.h b/base/trace_event/process_memory_dump.h
index 37c0aa1..41efc73 100644
--- a/base/trace_event/process_memory_dump.h
+++ b/base/trace_event/process_memory_dump.h
@@ -66,7 +66,7 @@
static size_t CountResidentBytes(void* start_address, size_t mapped_size);
#endif
- ProcessMemoryDump(const scoped_refptr<MemoryDumpSessionState>& session_state);
+ ProcessMemoryDump(scoped_refptr<MemoryDumpSessionState> session_state);
~ProcessMemoryDump();
// Creates a new MemoryAllocatorDump with the given name and returns the
