From 82b0c16d66f85881e084ae16ef366ee4e6f4cffc Mon Sep 17 00:00:00 2001 From: vmpstr Date: Fri, 18 Mar 2016 12:17:28 -0700 Subject: [PATCH] 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} --- base/deferred_sequenced_task_runner.cc | 6 +- base/deferred_sequenced_task_runner.h | 2 +- base/files/important_file_writer.cc | 13 ++-- base/files/important_file_writer.h | 4 +- .../ref_counted_delete_on_message_loop.h | 10 ++-- .../sequenced_task_runner_test_template.cc | 8 +-- .../sequenced_task_runner_test_template.h | 60 +++++++++---------- base/test/task_runner_test_template.cc | 5 +- base/test/task_runner_test_template.h | 5 +- base/thread_task_runner_handle.cc | 4 +- base/thread_task_runner_handle.h | 2 +- base/threading/sequenced_worker_pool.cc | 23 ++++--- .../sequenced_worker_pool_unittest.cc | 5 +- base/trace_event/memory_dump_manager.cc | 28 ++++----- base/trace_event/memory_dump_manager.h | 33 +++++----- .../memory_dump_manager_unittest.cc | 33 ++++------ base/trace_event/process_memory_dump.cc | 4 +- base/trace_event/process_memory_dump.h | 2 +- 18 files changed, 108 insertions(+), 139 deletions(-) diff --git a/base/deferred_sequenced_task_runner.cc b/base/deferred_sequenced_task_runner.cc index f805b50237c073..7d09ef838cf37b 100644 --- a/base/deferred_sequenced_task_runner.cc +++ b/base/deferred_sequenced_task_runner.cc @@ -20,10 +20,8 @@ DeferredSequencedTaskRunner::DeferredTask::~DeferredTask() { } DeferredSequencedTaskRunner::DeferredSequencedTaskRunner( - const scoped_refptr& target_task_runner) - : started_(false), - target_task_runner_(target_task_runner) { -} + scoped_refptr 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 5a57e86725eed9..e5d57df5a0ba4e 100644 --- a/base/deferred_sequenced_task_runner.h +++ b/base/deferred_sequenced_task_runner.h @@ -24,7 +24,7 @@ namespace base { class BASE_EXPORT DeferredSequencedTaskRunner : public SequencedTaskRunner { public: explicit DeferredSequencedTaskRunner( - const scoped_refptr& target_runner); + scoped_refptr 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 b4293053a69cf6..a724dc36ee86ce 100644 --- a/base/files/important_file_writer.cc +++ b/base/files/important_file_writer.cc @@ -126,19 +126,18 @@ bool ImportantFileWriter::WriteFileAtomically(const FilePath& path, ImportantFileWriter::ImportantFileWriter( const FilePath& path, - const scoped_refptr& task_runner) + scoped_refptr 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& task_runner, + scoped_refptr 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 1b2ad5caed07a3..4d18c0bd2e0ce9 100644 --- a/base/files/important_file_writer.h +++ b/base/files/important_file_writer.h @@ -63,11 +63,11 @@ class BASE_EXPORT ImportantFileWriter : public NonThreadSafe { // 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& task_runner); + scoped_refptr task_runner); // Same as above, but with a custom commit interval. ImportantFileWriter(const FilePath& path, - const scoped_refptr& task_runner, + scoped_refptr 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 84f80d8d8f2918..de194e84791854 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 @@ namespace base { // Sample usage: // class Foo : public RefCountedDeleteOnMessageLoop { // -// Foo(const scoped_refptr& loop) -// : RefCountedDeleteOnMessageLoop(loop) { -// ... -// } +// Foo(scoped_refptr loop) +// : RefCountedDeleteOnMessageLoop(std::move(loop)) {} // ... // private: // friend class RefCountedDeleteOnMessageLoop; @@ -40,8 +38,8 @@ class RefCountedDeleteOnMessageLoop : public subtle::RefCountedThreadSafeBase { // MessageLoop on the current thread can be acquired by calling // MessageLoop::current()->task_runner(). RefCountedDeleteOnMessageLoop( - const scoped_refptr& task_runner) - : task_runner_(task_runner) { + scoped_refptr 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 010f439d749f5d..0022aac36eed6b 100644 --- a/base/test/sequenced_task_runner_test_template.cc +++ b/base/test/sequenced_task_runner_test_template.cc @@ -23,7 +23,7 @@ SequencedTaskTracker::SequencedTaskTracker() } void SequencedTaskTracker::PostWrappedNonNestableTask( - const scoped_refptr& 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::PostWrappedNonNestableTask( } void SequencedTaskTracker::PostWrappedNestableTask( - const scoped_refptr& 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::PostWrappedNestableTask( } void SequencedTaskTracker::PostWrappedDelayedNonNestableTask( - const scoped_refptr& task_runner, + SequencedTaskRunner* task_runner, const Closure& task, TimeDelta delay) { AutoLock event_lock(lock_); @@ -57,7 +57,7 @@ void SequencedTaskTracker::PostWrappedDelayedNonNestableTask( } void SequencedTaskTracker::PostNonNestableTasks( - const scoped_refptr& 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 d0717cd746d10b..ac5f3c65653519 100644 --- a/base/test/sequenced_task_runner_test_template.h +++ b/base/test/sequenced_task_runner_test_template.h @@ -41,25 +41,20 @@ class SequencedTaskTracker : public RefCountedThreadSafe { SequencedTaskTracker(); // Posts the non-nestable task |task|, and records its post event. - void PostWrappedNonNestableTask( - const scoped_refptr& 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& 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& 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& task_runner, - int task_count); + void PostNonNestableTasks(SequencedTaskRunner* task_runner, int task_count); const std::vector& GetTaskEvents() const; @@ -141,9 +136,11 @@ TYPED_TEST_P(SequencedTaskRunnerTest, SequentialNonNestable) { 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 @@ TYPED_TEST_P(SequencedTaskRunnerTest, SequentialNestable) { 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 @@ TYPED_TEST_P(SequencedTaskRunnerTest, SequentialDelayedNonNestable) { 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 @@ TYPED_TEST_P(SequencedTaskRunnerTest, NonNestablePostFromNonNestableTask) { 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 @@ TYPED_TEST_P(SequencedTaskRunnerTest, DelayedTasksSameDelay) { const scoped_refptr 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 @@ TYPED_TEST_P(SequencedTaskRunnerTest, DelayedTaskAfterLongTask) { 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 @@ TYPED_TEST_P(SequencedTaskRunnerTest, DelayedTaskAfterManyLongTasks) { 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 @@ TYPED_TEST_P(SequencedTaskRunnerDelayedTest, DelayedTaskBasic) { 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 efc21936e10c2e..5983b8a0fd0b5d 100644 --- a/base/test/task_runner_test_template.cc +++ b/base/test/task_runner_test_template.cc @@ -37,9 +37,8 @@ void TaskTracker::WaitForCompletedTasks(int count) { task_runs_cv_.Wait(); } -void ExpectRunsTasksOnCurrentThread( - bool expected_value, - const scoped_refptr& 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 cc16469d046224..c0d3a128976bf2 100644 --- a/base/test/task_runner_test_template.h +++ b/base/test/task_runner_test_template.h @@ -175,9 +175,8 @@ namespace test { // Calls RunsTasksOnCurrentThread() on |task_runner| and expects it to // equal |expected_value|. -void ExpectRunsTasksOnCurrentThread( - bool expected_value, - const scoped_refptr& 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 ee337b382e7e6a..911e90c798c47f 100644 --- a/base/thread_task_runner_handle.cc +++ b/base/thread_task_runner_handle.cc @@ -30,8 +30,8 @@ bool ThreadTaskRunnerHandle::IsSet() { } ThreadTaskRunnerHandle::ThreadTaskRunnerHandle( - const scoped_refptr& task_runner) - : task_runner_(task_runner) { + scoped_refptr 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 197669ed88b848..2a6282bfd59403 100644 --- a/base/thread_task_runner_handle.h +++ b/base/thread_task_runner_handle.h @@ -29,7 +29,7 @@ class BASE_EXPORT ThreadTaskRunnerHandle { // Binds |task_runner| to the current thread. |task_runner| must belong // to the current thread for this to succeed. explicit ThreadTaskRunnerHandle( - const scoped_refptr& task_runner); + scoped_refptr task_runner); ~ThreadTaskRunnerHandle(); private: diff --git a/base/threading/sequenced_worker_pool.cc b/base/threading/sequenced_worker_pool.cc index 081a49f39e65d0..086f54ba805e1c 100644 --- a/base/threading/sequenced_worker_pool.cc +++ b/base/threading/sequenced_worker_pool.cc @@ -98,7 +98,7 @@ struct SequencedTaskLessThan { class SequencedWorkerPoolTaskRunner : public TaskRunner { public: SequencedWorkerPoolTaskRunner( - const scoped_refptr& pool, + scoped_refptr pool, SequencedWorkerPool::WorkerShutdown shutdown_behavior); // TaskRunner implementation @@ -118,11 +118,9 @@ class SequencedWorkerPoolTaskRunner : public TaskRunner { }; SequencedWorkerPoolTaskRunner::SequencedWorkerPoolTaskRunner( - const scoped_refptr& pool, + scoped_refptr 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 @@ bool SequencedWorkerPoolTaskRunner::RunsTasksOnCurrentThread() const { class SequencedWorkerPoolSequencedTaskRunner : public SequencedTaskRunner { public: SequencedWorkerPoolSequencedTaskRunner( - const scoped_refptr& pool, + scoped_refptr pool, SequencedWorkerPool::SequenceToken token, SequencedWorkerPool::WorkerShutdown shutdown_behavior); @@ -178,13 +176,12 @@ class SequencedWorkerPoolSequencedTaskRunner : public SequencedTaskRunner { }; SequencedWorkerPoolSequencedTaskRunner::SequencedWorkerPoolSequencedTaskRunner( - const scoped_refptr& pool, + scoped_refptr 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 @@ class SequencedWorkerPool::Worker : public SimpleThread { 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& worker_pool, + Worker(scoped_refptr worker_pool, int thread_number, const std::string& thread_name_prefix); ~Worker() override; @@ -504,11 +501,11 @@ class SequencedWorkerPool::Inner { // Worker definitions --------------------------------------------------------- SequencedWorkerPool::Worker::Worker( - const scoped_refptr& worker_pool, + scoped_refptr 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 fba18084391221..2855b9fd539336 100644 --- a/base/threading/sequenced_worker_pool_unittest.cc +++ b/base/threading/sequenced_worker_pool_unittest.cc @@ -75,9 +75,8 @@ class ThreadBlocker { class DestructionDeadlockChecker : public base::RefCountedThreadSafe { public: - explicit DestructionDeadlockChecker( - const scoped_refptr& pool) - : pool_(pool) {} + explicit DestructionDeadlockChecker(scoped_refptr 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 4ba7fcbd828a69..56cc9023a81911 100644 --- a/base/trace_event/memory_dump_manager.cc +++ b/base/trace_event/memory_dump_manager.cc @@ -211,43 +211,43 @@ void MemoryDumpManager::Initialize(MemoryDumpManagerDelegate* delegate, void MemoryDumpManager::RegisterDumpProvider( MemoryDumpProvider* mdp, const char* name, - const scoped_refptr& task_runner, + scoped_refptr 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& task_runner) { + scoped_refptr 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& task_runner, + scoped_refptr 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& task_runner, + scoped_refptr task_runner, const MemoryDumpProvider::Options& options) { if (dumper_registrations_ignored_for_testing_) return; scoped_refptr mdpinfo = - new MemoryDumpProviderInfo(mdp, name, task_runner, options); + new MemoryDumpProviderInfo(mdp, name, std::move(task_runner), options); { AutoLock lock(lock_); @@ -703,11 +703,11 @@ uint64_t MemoryDumpManager::GetTracingProcessId() const { MemoryDumpManager::MemoryDumpProviderInfo::MemoryDumpProviderInfo( MemoryDumpProvider* dump_provider, const char* name, - const scoped_refptr& task_runner, + scoped_refptr 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 @@ bool MemoryDumpManager::MemoryDumpProviderInfo::Comparator::operator()( MemoryDumpManager::ProcessMemoryDumpAsyncState::ProcessMemoryDumpAsyncState( MemoryDumpRequestArgs req_args, const MemoryDumpProviderInfo::OrderedSet& dump_providers, - const scoped_refptr& session_state, + scoped_refptr session_state, MemoryDumpCallback callback, - const scoped_refptr& dump_thread_task_runner) + scoped_refptr 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 e9b09f8f0c3b9e..79686c8fb053e5 100644 --- a/base/trace_event/memory_dump_manager.h +++ b/base/trace_event/memory_dump_manager.h @@ -73,19 +73,17 @@ class BASE_EXPORT MemoryDumpManager : public TraceLog::EnabledStateObserver { // 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& task_runner); - void RegisterDumpProvider( - MemoryDumpProvider* mdp, - const char* name, - const scoped_refptr& task_runner, - MemoryDumpProvider::Options options); + void RegisterDumpProvider(MemoryDumpProvider* mdp, + const char* name, + scoped_refptr task_runner); + void RegisterDumpProvider(MemoryDumpProvider* mdp, + const char* name, + scoped_refptr task_runner, + MemoryDumpProvider::Options options); void RegisterDumpProviderWithSequencedTaskRunner( MemoryDumpProvider* mdp, const char* name, - const scoped_refptr& task_runner, + scoped_refptr task_runner, MemoryDumpProvider::Options options); void UnregisterDumpProvider(MemoryDumpProvider* mdp); @@ -174,11 +172,10 @@ class BASE_EXPORT MemoryDumpManager : public TraceLog::EnabledStateObserver { using OrderedSet = std::set, Comparator>; - MemoryDumpProviderInfo( - MemoryDumpProvider* dump_provider, - const char* name, - const scoped_refptr& task_runner, - const MemoryDumpProvider::Options& options); + MemoryDumpProviderInfo(MemoryDumpProvider* dump_provider, + const char* name, + scoped_refptr task_runner, + const MemoryDumpProvider::Options& options); MemoryDumpProvider* const dump_provider; @@ -217,9 +214,9 @@ class BASE_EXPORT MemoryDumpManager : public TraceLog::EnabledStateObserver { ProcessMemoryDumpAsyncState( MemoryDumpRequestArgs req_args, const MemoryDumpProviderInfo::OrderedSet& dump_providers, - const scoped_refptr& session_state, + scoped_refptr session_state, MemoryDumpCallback callback, - const scoped_refptr& dump_thread_task_runner); + scoped_refptr dump_thread_task_runner); ~ProcessMemoryDumpAsyncState(); // Gets or creates the memory dump container for the given target process. @@ -299,7 +296,7 @@ class BASE_EXPORT MemoryDumpManager : public TraceLog::EnabledStateObserver { void RegisterDumpProviderInternal( MemoryDumpProvider* mdp, const char* name, - const scoped_refptr& task_runner, + scoped_refptr 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 138ba69d555386..12227ee745d0cb 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& task_runner, - const MemoryDumpProvider::Options& options, - bool dumps_on_single_thread_task_runner) { + scoped_refptr 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 single_thread_task_runner = - static_cast(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& 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& task_runner, + scoped_refptr 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 74cbcc29a0320a..1642e5a341bef3 100644 --- a/base/trace_event/process_memory_dump.cc +++ b/base/trace_event/process_memory_dump.cc @@ -144,10 +144,10 @@ size_t ProcessMemoryDump::CountResidentBytes(void* start_address, #endif // defined(COUNT_RESIDENT_BYTES_SUPPORTED) ProcessMemoryDump::ProcessMemoryDump( - const scoped_refptr& session_state) + scoped_refptr 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 37c0aa178803e9..41efc735ff0417 100644 --- a/base/trace_event/process_memory_dump.h +++ b/base/trace_event/process_memory_dump.h @@ -66,7 +66,7 @@ class BASE_EXPORT ProcessMemoryDump { static size_t CountResidentBytes(void* start_address, size_t mapped_size); #endif - ProcessMemoryDump(const scoped_refptr& session_state); + ProcessMemoryDump(scoped_refptr session_state); ~ProcessMemoryDump(); // Creates a new MemoryAllocatorDump with the given name and returns the