Migrate base::TaskRunner from Closure to OnceClosure
After this CL, TaskRunner::PostTask and its family can take OnceClosure
in addition to Closure.
Most of the changes are mechanical replacement of Closure with OnceClosure
on TaskRunner family. Others are:
- Limit CriticalClosure from Closure to OnceClosure as no caller call
the resulting callback more than once
- Add several PostTaskAndReplyWithResult overloads for old Callback
version, for compatibility. (in base/task_scheduler/post_task.h)
- Update SequencedWorkerPool implementation for OnceClosure.
- Update task handling code in app_state.mm for OnceClosure, which is
needed to bring OnceClosure into a ObjC block.
BUG=704027
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_trusty_blink_rel
Review-Url: https://codereview.chromium.org/2637843002
Cr-Commit-Position: refs/heads/master@{#462023}
diff --git a/base/critical_closure.h b/base/critical_closure.h
index 35ce2b5c..94c618d 100644
--- a/base/critical_closure.h
+++ b/base/critical_closure.h
@@ -29,13 +29,13 @@
// |ios::ScopedCriticalAction|.
class CriticalClosure {
public:
- explicit CriticalClosure(Closure closure);
+ explicit CriticalClosure(OnceClosure closure);
~CriticalClosure();
void Run();
private:
ios::ScopedCriticalAction critical_action_;
- Closure closure_;
+ OnceClosure closure_;
DISALLOW_COPY_AND_ASSIGN(CriticalClosure);
};
@@ -57,13 +57,14 @@
// background running time, |MakeCriticalClosure| should be applied on them
// before posting.
#if defined(OS_IOS)
-inline Closure MakeCriticalClosure(Closure closure) {
+inline OnceClosure MakeCriticalClosure(OnceClosure closure) {
DCHECK(internal::IsMultiTaskingSupported());
- return base::Bind(&internal::CriticalClosure::Run,
- Owned(new internal::CriticalClosure(std::move(closure))));
+ return base::BindOnce(
+ &internal::CriticalClosure::Run,
+ Owned(new internal::CriticalClosure(std::move(closure))));
}
#else // defined(OS_IOS)
-inline Closure MakeCriticalClosure(Closure closure) {
+inline OnceClosure MakeCriticalClosure(OnceClosure closure) {
// No-op for platforms where the application does not need to acquire
// background time for closures to finish when it goes into the background.
return closure;
diff --git a/base/critical_closure_internal_ios.mm b/base/critical_closure_internal_ios.mm
index 4088a47..e35eca0 100644
--- a/base/critical_closure_internal_ios.mm
+++ b/base/critical_closure_internal_ios.mm
@@ -13,13 +13,13 @@
return [[UIDevice currentDevice] isMultitaskingSupported];
}
-CriticalClosure::CriticalClosure(Closure closure)
+CriticalClosure::CriticalClosure(OnceClosure closure)
: closure_(std::move(closure)) {}
CriticalClosure::~CriticalClosure() {}
void CriticalClosure::Run() {
- closure_.Run();
+ std::move(closure_).Run();
}
} // namespace internal
diff --git a/base/deferred_sequenced_task_runner.cc b/base/deferred_sequenced_task_runner.cc
index 926d895f..15367f0 100644
--- a/base/deferred_sequenced_task_runner.cc
+++ b/base/deferred_sequenced_task_runner.cc
@@ -34,7 +34,7 @@
bool DeferredSequencedTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
AutoLock lock(lock_);
if (started_) {
@@ -54,7 +54,7 @@
bool DeferredSequencedTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
AutoLock lock(lock_);
if (started_) {
@@ -69,7 +69,7 @@
void DeferredSequencedTaskRunner::QueueDeferredTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay,
bool is_non_nestable) {
DCHECK(task);
diff --git a/base/deferred_sequenced_task_runner.h b/base/deferred_sequenced_task_runner.h
index 94651dd..85f196f3 100644
--- a/base/deferred_sequenced_task_runner.h
+++ b/base/deferred_sequenced_task_runner.h
@@ -28,13 +28,13 @@
// TaskRunner implementation
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
// SequencedTaskRunner implementation
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
// Start the execution - posts all queued tasks to the target executor. The
@@ -51,7 +51,7 @@
DeferredTask& operator=(DeferredTask&& other);
tracked_objects::Location posted_from;
- Closure task;
+ OnceClosure task;
// The delay this task was initially posted with.
TimeDelta delay;
bool is_non_nestable;
@@ -61,7 +61,7 @@
// Creates a |Task| object and adds it to |deferred_tasks_queue_|.
void QueueDeferredTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay,
bool is_non_nestable);
diff --git a/base/message_loop/incoming_task_queue.cc b/base/message_loop/incoming_task_queue.cc
index f8387138..316b5ec 100644
--- a/base/message_loop/incoming_task_queue.cc
+++ b/base/message_loop/incoming_task_queue.cc
@@ -60,7 +60,7 @@
bool IncomingTaskQueue::AddToIncomingQueue(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay,
bool nestable) {
DCHECK(task);
diff --git a/base/message_loop/incoming_task_queue.h b/base/message_loop/incoming_task_queue.h
index a912dc2..17bea07 100644
--- a/base/message_loop/incoming_task_queue.h
+++ b/base/message_loop/incoming_task_queue.h
@@ -36,7 +36,7 @@
// returns false. In all cases, the ownership of |task| is transferred to the
// called method.
bool AddToIncomingQueue(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay,
bool nestable);
diff --git a/base/message_loop/message_loop_task_runner.cc b/base/message_loop/message_loop_task_runner.cc
index ddfdeb2..aece087b 100644
--- a/base/message_loop/message_loop_task_runner.cc
+++ b/base/message_loop/message_loop_task_runner.cc
@@ -26,7 +26,7 @@
bool MessageLoopTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
base::TimeDelta delay) {
DCHECK(!task.is_null()) << from_here.ToString();
return incoming_queue_->AddToIncomingQueue(from_here, std::move(task), delay,
@@ -35,7 +35,7 @@
bool MessageLoopTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
base::TimeDelta delay) {
DCHECK(!task.is_null()) << from_here.ToString();
return incoming_queue_->AddToIncomingQueue(from_here, std::move(task), delay,
diff --git a/base/message_loop/message_loop_task_runner.h b/base/message_loop/message_loop_task_runner.h
index 11ee8a6..99a96a7 100644
--- a/base/message_loop/message_loop_task_runner.h
+++ b/base/message_loop/message_loop_task_runner.h
@@ -32,10 +32,10 @@
// SingleThreadTaskRunner implementation
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
diff --git a/base/post_task_and_reply_with_result_internal.h b/base/post_task_and_reply_with_result_internal.h
index 14561293..6f50de8 100644
--- a/base/post_task_and_reply_with_result_internal.h
+++ b/base/post_task_and_reply_with_result_internal.h
@@ -16,16 +16,15 @@
// Adapts a function that produces a result via a return value to
// one that returns via an output parameter.
template <typename ReturnType>
-void ReturnAsParamAdapter(const Callback<ReturnType(void)>& func,
- ReturnType* result) {
- *result = func.Run();
+void ReturnAsParamAdapter(OnceCallback<ReturnType()> func, ReturnType* result) {
+ *result = std::move(func).Run();
}
// Adapts a T* result to a callblack that expects a T.
template <typename TaskReturnType, typename ReplyArgType>
-void ReplyAdapter(const Callback<void(ReplyArgType)>& callback,
+void ReplyAdapter(OnceCallback<void(ReplyArgType)> callback,
TaskReturnType* result) {
- callback.Run(std::move(*result));
+ std::move(callback).Run(std::move(*result));
}
} // namespace internal
diff --git a/base/sequenced_task_runner.cc b/base/sequenced_task_runner.cc
index fa19ae5..4c367cb 100644
--- a/base/sequenced_task_runner.cc
+++ b/base/sequenced_task_runner.cc
@@ -12,7 +12,7 @@
bool SequencedTaskRunner::PostNonNestableTask(
const tracked_objects::Location& from_here,
- Closure task) {
+ OnceClosure task) {
return PostNonNestableDelayedTask(from_here, std::move(task),
base::TimeDelta());
}
diff --git a/base/sequenced_task_runner.h b/base/sequenced_task_runner.h
index b92bd997..b291539 100644
--- a/base/sequenced_task_runner.h
+++ b/base/sequenced_task_runner.h
@@ -110,11 +110,11 @@
// below.
bool PostNonNestableTask(const tracked_objects::Location& from_here,
- Closure task);
+ OnceClosure task);
virtual bool PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
base::TimeDelta delay) = 0;
// Submits a non-nestable task to delete the given object. Returns
diff --git a/base/task_runner.cc b/base/task_runner.cc
index 8502510..c3e0574 100644
--- a/base/task_runner.cc
+++ b/base/task_runner.cc
@@ -23,7 +23,7 @@
private:
bool PostTask(const tracked_objects::Location& from_here,
- Closure task) override;
+ OnceClosure task) override;
// Non-owning.
TaskRunner* destination_;
@@ -36,20 +36,20 @@
bool PostTaskAndReplyTaskRunner::PostTask(
const tracked_objects::Location& from_here,
- Closure task) {
+ OnceClosure task) {
return destination_->PostTask(from_here, std::move(task));
}
} // namespace
bool TaskRunner::PostTask(const tracked_objects::Location& from_here,
- Closure task) {
+ OnceClosure task) {
return PostDelayedTask(from_here, std::move(task), base::TimeDelta());
}
bool TaskRunner::PostTaskAndReply(const tracked_objects::Location& from_here,
- Closure task,
- Closure reply) {
+ OnceClosure task,
+ OnceClosure reply) {
return PostTaskAndReplyTaskRunner(this).PostTaskAndReply(
from_here, std::move(task), std::move(reply));
}
diff --git a/base/task_runner.h b/base/task_runner.h
index d6a3871..0421d56 100644
--- a/base/task_runner.h
+++ b/base/task_runner.h
@@ -61,7 +61,7 @@
// will not be run.
//
// Equivalent to PostDelayedTask(from_here, task, 0).
- bool PostTask(const tracked_objects::Location& from_here, Closure task);
+ bool PostTask(const tracked_objects::Location& from_here, OnceClosure task);
// Like PostTask, but tries to run the posted task only after
// |delay_ms| has passed.
@@ -69,7 +69,7 @@
// It is valid for an implementation to ignore |delay_ms|; that is,
// to have PostDelayedTask behave the same as PostTask.
virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
base::TimeDelta delay) = 0;
// Returns true if the current thread is a thread on which a task
@@ -122,8 +122,8 @@
// and the reply will cancel itself safely because it is bound to a
// WeakPtr<>.
bool PostTaskAndReply(const tracked_objects::Location& from_here,
- Closure task,
- Closure reply);
+ OnceClosure task,
+ OnceClosure reply);
protected:
friend struct TaskRunnerTraits;
diff --git a/base/task_scheduler/post_task.cc b/base/task_scheduler/post_task.cc
index 0781e85..6f9adae2 100644
--- a/base/task_scheduler/post_task.cc
+++ b/base/task_scheduler/post_task.cc
@@ -21,7 +21,7 @@
private:
bool PostTask(const tracked_objects::Location& from_here,
- Closure task) override {
+ OnceClosure task) override {
PostTaskWithTraits(from_here, traits_, std::move(task));
return true;
}
@@ -32,43 +32,43 @@
} // namespace
-void PostTask(const tracked_objects::Location& from_here, Closure task) {
+void PostTask(const tracked_objects::Location& from_here, OnceClosure task) {
PostDelayedTask(from_here, std::move(task), TimeDelta());
}
void PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
PostDelayedTaskWithTraits(from_here, TaskTraits(), std::move(task), delay);
}
void PostTaskAndReply(const tracked_objects::Location& from_here,
- Closure task,
- Closure reply) {
+ OnceClosure task,
+ OnceClosure reply) {
PostTaskWithTraitsAndReply(from_here, TaskTraits(), std::move(task),
std::move(reply));
}
void PostTaskWithTraits(const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Closure task) {
+ OnceClosure task) {
PostDelayedTaskWithTraits(from_here, traits, std::move(task), TimeDelta());
}
void PostDelayedTaskWithTraits(const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
DCHECK(TaskScheduler::GetInstance())
<< "Ref. Prerequisite section of post_task.h";
TaskScheduler::GetInstance()->PostDelayedTaskWithTraits(
- from_here, traits, std::move(task), delay);
+ from_here, traits, std::move(task), std::move(delay));
}
void PostTaskWithTraitsAndReply(const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Closure task,
- Closure reply) {
+ OnceClosure task,
+ OnceClosure reply) {
PostTaskAndReplyTaskRunner(traits).PostTaskAndReply(
from_here, std::move(task), std::move(reply));
}
diff --git a/base/task_scheduler/post_task.h b/base/task_scheduler/post_task.h
index efdee58f..69eda89 100644
--- a/base/task_scheduler/post_task.h
+++ b/base/task_scheduler/post_task.h
@@ -71,7 +71,7 @@
// Posts |task| to the TaskScheduler. Calling this is equivalent to calling
// PostTaskWithTraits with plain TaskTraits.
BASE_EXPORT void PostTask(const tracked_objects::Location& from_here,
- Closure task);
+ OnceClosure task);
// Posts |task| to the TaskScheduler. |task| will not run before |delay|
// expires. Calling this is equivalent to calling PostDelayedTaskWithTraits with
@@ -80,7 +80,7 @@
// Use PostDelayedTaskWithTraits to specify a BACKGROUND priority if the task
// doesn't have to run as soon as |delay| expires.
BASE_EXPORT void PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay);
// Posts |task| to the TaskScheduler and posts |reply| on the caller's execution
@@ -89,8 +89,8 @@
// PostTaskWithTraitsAndReply with plain TaskTraits. Can only be called when
// SequencedTaskRunnerHandle::IsSet().
BASE_EXPORT void PostTaskAndReply(const tracked_objects::Location& from_here,
- Closure task,
- Closure reply);
+ OnceClosure task,
+ OnceClosure reply);
// Posts |task| to the TaskScheduler and posts |reply| with the return value of
// |task| as argument on the caller's execution context (i.e. same sequence or
@@ -99,16 +99,30 @@
// TaskTraits. Can only be called when SequencedTaskRunnerHandle::IsSet().
template <typename TaskReturnType, typename ReplyArgType>
void PostTaskAndReplyWithResult(const tracked_objects::Location& from_here,
- Callback<TaskReturnType(void)> task,
- Callback<void(ReplyArgType)> reply) {
+ OnceCallback<TaskReturnType()> task,
+ OnceCallback<void(ReplyArgType)> reply) {
PostTaskWithTraitsAndReplyWithResult(from_here, TaskTraits(), std::move(task),
std::move(reply));
}
+// Callback version of PostTaskAndReplyWithResult above.
+// Though RepeatingCallback is convertible to OnceCallback, we need this since
+// we can not use template deduction and object conversion at once on the
+// overload resolution.
+// TODO(tzik): Update all callers of the Callback version to use OnceCallback.
+template <typename TaskReturnType, typename ReplyArgType>
+void PostTaskAndReplyWithResult(const tracked_objects::Location& from_here,
+ Callback<TaskReturnType()> task,
+ Callback<void(ReplyArgType)> reply) {
+ PostTaskAndReplyWithResult(
+ from_here, OnceCallback<TaskReturnType()>(std::move(task)),
+ OnceCallback<void(ReplyArgType)>(std::move(reply)));
+}
+
// Posts |task| with specific |traits| to the TaskScheduler.
BASE_EXPORT void PostTaskWithTraits(const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Closure task);
+ OnceClosure task);
// Posts |task| with specific |traits| to the TaskScheduler. |task| will not run
// before |delay| expires.
@@ -118,7 +132,7 @@
BASE_EXPORT void PostDelayedTaskWithTraits(
const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Closure task,
+ OnceClosure task,
TimeDelta delay);
// Posts |task| with specific |traits| to the TaskScheduler and posts |reply| on
@@ -128,8 +142,8 @@
BASE_EXPORT void PostTaskWithTraitsAndReply(
const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Closure task,
- Closure reply);
+ OnceClosure task,
+ OnceClosure reply);
// Posts |task| with specific |traits| to the TaskScheduler and posts |reply|
// with the return value of |task| as argument on the caller's execution context
@@ -139,14 +153,31 @@
void PostTaskWithTraitsAndReplyWithResult(
const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Callback<TaskReturnType()> task,
- Callback<void(ReplyArgType)> reply) {
+ OnceCallback<TaskReturnType()> task,
+ OnceCallback<void(ReplyArgType)> reply) {
TaskReturnType* result = new TaskReturnType();
return PostTaskWithTraitsAndReply(
- from_here, traits, Bind(&internal::ReturnAsParamAdapter<TaskReturnType>,
- std::move(task), result),
- Bind(&internal::ReplyAdapter<TaskReturnType, ReplyArgType>,
- std::move(reply), Owned(result)));
+ from_here, traits,
+ BindOnce(&internal::ReturnAsParamAdapter<TaskReturnType>, std::move(task),
+ result),
+ BindOnce(&internal::ReplyAdapter<TaskReturnType, ReplyArgType>,
+ std::move(reply), Owned(result)));
+}
+
+// Callback version of PostTaskWithTraitsAndReplyWithResult above.
+// Though RepeatingCallback is convertible to OnceCallback, we need this since
+// we can not use template deduction and object conversion at once on the
+// overload resolution.
+// TODO(tzik): Update all callers of the Callback version to use OnceCallback.
+template <typename TaskReturnType, typename ReplyArgType>
+void PostTaskWithTraitsAndReplyWithResult(
+ const tracked_objects::Location& from_here,
+ const TaskTraits& traits,
+ Callback<TaskReturnType()> task,
+ Callback<void(ReplyArgType)> reply) {
+ PostTaskWithTraitsAndReplyWithResult(
+ from_here, traits, OnceCallback<TaskReturnType()>(std::move(task)),
+ OnceCallback<void(ReplyArgType)>(std::move(reply)));
}
// Returns a TaskRunner whose PostTask invocations result in scheduling tasks
diff --git a/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc b/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc
index 059e459..d4c26d6 100644
--- a/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc
+++ b/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc
@@ -253,7 +253,7 @@
// SingleThreadTaskRunner:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure closure,
+ OnceClosure closure,
TimeDelta delay) override {
auto task = MakeUnique<Task>(from_here, std::move(closure), traits_, delay);
task->single_thread_task_runner_ref = this;
@@ -272,7 +272,7 @@
}
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- Closure closure,
+ OnceClosure closure,
TimeDelta delay) override {
// Tasks are never nested within the task scheduler.
return PostDelayedTask(from_here, std::move(closure), delay);
diff --git a/base/task_scheduler/scheduler_worker_pool_impl.cc b/base/task_scheduler/scheduler_worker_pool_impl.cc
index 5fb1194..cc08101 100644
--- a/base/task_scheduler/scheduler_worker_pool_impl.cc
+++ b/base/task_scheduler/scheduler_worker_pool_impl.cc
@@ -58,7 +58,7 @@
// TaskRunner:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure closure,
+ OnceClosure closure,
TimeDelta delay) override {
// Post the task as part of a one-off single-task Sequence.
return worker_pool_->PostTaskWithSequence(
@@ -93,7 +93,7 @@
// SequencedTaskRunner:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure closure,
+ OnceClosure closure,
TimeDelta delay) override {
std::unique_ptr<Task> task(
new Task(from_here, std::move(closure), traits_, delay));
@@ -104,7 +104,7 @@
}
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- Closure closure,
+ OnceClosure closure,
base::TimeDelta delay) override {
// Tasks are never nested within the task scheduler.
return PostDelayedTask(from_here, std::move(closure), delay);
diff --git a/base/task_scheduler/task.cc b/base/task_scheduler/task.cc
index 44aaa60..fc513e3 100644
--- a/base/task_scheduler/task.cc
+++ b/base/task_scheduler/task.cc
@@ -12,7 +12,7 @@
namespace internal {
Task::Task(const tracked_objects::Location& posted_from,
- Closure task,
+ OnceClosure task,
const TaskTraits& traits,
TimeDelta delay)
: PendingTask(
diff --git a/base/task_scheduler/task.h b/base/task_scheduler/task.h
index 1f3b775a2..43095f2a 100644
--- a/base/task_scheduler/task.h
+++ b/base/task_scheduler/task.h
@@ -28,7 +28,7 @@
// behavior in |traits| is BLOCK_SHUTDOWN, the shutdown behavior is
// automatically adjusted to SKIP_ON_SHUTDOWN.
Task(const tracked_objects::Location& posted_from,
- Closure task,
+ OnceClosure task,
const TaskTraits& traits,
TimeDelta delay);
~Task();
diff --git a/base/task_scheduler/task_scheduler.h b/base/task_scheduler/task_scheduler.h
index 57272bc..d19841f 100644
--- a/base/task_scheduler/task_scheduler.h
+++ b/base/task_scheduler/task_scheduler.h
@@ -70,7 +70,7 @@
virtual void PostDelayedTaskWithTraits(
const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Closure task,
+ OnceClosure task,
TimeDelta delay) = 0;
// Returns a TaskRunner whose PostTask invocations result in scheduling tasks
diff --git a/base/task_scheduler/task_scheduler_impl.cc b/base/task_scheduler/task_scheduler_impl.cc
index f323310..3c98fdf 100644
--- a/base/task_scheduler/task_scheduler_impl.cc
+++ b/base/task_scheduler/task_scheduler_impl.cc
@@ -122,7 +122,7 @@
void TaskSchedulerImpl::PostDelayedTaskWithTraits(
const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
// Post |task| as part of a one-off single-task Sequence.
GetWorkerPoolForTraits(traits)->PostTaskWithSequence(
diff --git a/base/task_scheduler/task_scheduler_impl.h b/base/task_scheduler/task_scheduler_impl.h
index 4a048c94..1e31888 100644
--- a/base/task_scheduler/task_scheduler_impl.h
+++ b/base/task_scheduler/task_scheduler_impl.h
@@ -62,7 +62,7 @@
// TaskScheduler:
void PostDelayedTaskWithTraits(const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
const TaskTraits& traits) override;
diff --git a/base/test/null_task_runner.cc b/base/test/null_task_runner.cc
index 66bdf6f..476af63 100644
--- a/base/test/null_task_runner.cc
+++ b/base/test/null_task_runner.cc
@@ -11,14 +11,14 @@
NullTaskRunner::~NullTaskRunner() {}
bool NullTaskRunner::PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
base::TimeDelta delay) {
return false;
}
bool NullTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
base::TimeDelta delay) {
return false;
}
diff --git a/base/test/null_task_runner.h b/base/test/null_task_runner.h
index a47e7b2..3dd9d7e5 100644
--- a/base/test/null_task_runner.h
+++ b/base/test/null_task_runner.h
@@ -20,10 +20,10 @@
NullTaskRunner();
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
// Always returns true to avoid triggering DCHECKs.
bool RunsTasksOnCurrentThread() const override;
diff --git a/base/test/scoped_task_scheduler.cc b/base/test/scoped_task_scheduler.cc
index dbf4936..4020e0e 100644
--- a/base/test/scoped_task_scheduler.cc
+++ b/base/test/scoped_task_scheduler.cc
@@ -49,7 +49,7 @@
// TaskScheduler:
void PostDelayedTaskWithTraits(const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
const TaskTraits& traits) override;
@@ -134,10 +134,10 @@
// SingleThreadTaskRunner:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure closure,
+ OnceClosure closure,
TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- Closure closure,
+ OnceClosure closure,
TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
@@ -167,7 +167,7 @@
void TestTaskScheduler::PostDelayedTaskWithTraits(
const tracked_objects::Location& from_here,
const TaskTraits& traits,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
CreateTaskRunnerWithTraits(traits)->PostDelayedTask(from_here,
std::move(task), delay);
@@ -280,7 +280,7 @@
bool TestTaskSchedulerTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- Closure closure,
+ OnceClosure closure,
TimeDelta delay) {
auto task =
MakeUnique<internal::Task>(from_here, std::move(closure), traits_, delay);
@@ -293,7 +293,7 @@
bool TestTaskSchedulerTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- Closure closure,
+ OnceClosure closure,
TimeDelta delay) {
// Tasks are never nested within the task scheduler.
return PostDelayedTask(from_here, std::move(closure), delay);
diff --git a/base/test/test_mock_time_task_runner.cc b/base/test/test_mock_time_task_runner.cc
index a431189..a236acf 100644
--- a/base/test/test_mock_time_task_runner.cc
+++ b/base/test/test_mock_time_task_runner.cc
@@ -81,7 +81,7 @@
: public base::TestPendingTask {
TestOrderedPendingTask();
TestOrderedPendingTask(const tracked_objects::Location& location,
- Closure task,
+ OnceClosure task,
TimeTicks post_time,
TimeDelta delay,
size_t ordinal,
@@ -106,7 +106,7 @@
TestMockTimeTaskRunner::TestOrderedPendingTask::TestOrderedPendingTask(
const tracked_objects::Location& location,
- Closure task,
+ OnceClosure task,
TimeTicks post_time,
TimeDelta delay,
size_t ordinal,
@@ -240,7 +240,7 @@
bool TestMockTimeTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
AutoLock scoped_lock(tasks_lock_);
tasks_.push(TestOrderedPendingTask(from_here, std::move(task), now_ticks_,
@@ -251,7 +251,7 @@
bool TestMockTimeTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
return PostDelayedTask(from_here, std::move(task), delay);
}
diff --git a/base/test/test_mock_time_task_runner.h b/base/test/test_mock_time_task_runner.h
index 5c61a36..2f892f5 100644
--- a/base/test/test_mock_time_task_runner.h
+++ b/base/test/test_mock_time_task_runner.h
@@ -141,10 +141,10 @@
// SingleThreadTaskRunner:
bool RunsTasksOnCurrentThread() const override;
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
protected:
diff --git a/base/test/test_pending_task.cc b/base/test/test_pending_task.cc
index 63bdfff..3f71a998 100644
--- a/base/test/test_pending_task.cc
+++ b/base/test/test_pending_task.cc
@@ -12,7 +12,7 @@
TestPendingTask::TestPendingTask() : nestability(NESTABLE) {}
TestPendingTask::TestPendingTask(const tracked_objects::Location& location,
- Closure task,
+ OnceClosure task,
TimeTicks post_time,
TimeDelta delay,
TestNestability nestability)
diff --git a/base/test/test_pending_task.h b/base/test/test_pending_task.h
index 4497ba18c..52ca592f 100644
--- a/base/test/test_pending_task.h
+++ b/base/test/test_pending_task.h
@@ -23,7 +23,7 @@
TestPendingTask();
TestPendingTask(TestPendingTask&& other);
TestPendingTask(const tracked_objects::Location& location,
- Closure task,
+ OnceClosure task,
TimeTicks post_time,
TimeDelta delay,
TestNestability nestability);
diff --git a/base/test/test_simple_task_runner.cc b/base/test/test_simple_task_runner.cc
index df03340..4280a0d 100644
--- a/base/test/test_simple_task_runner.cc
+++ b/base/test/test_simple_task_runner.cc
@@ -18,7 +18,7 @@
bool TestSimpleTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
AutoLock auto_lock(lock_);
pending_tasks_.push_back(TestPendingTask(from_here, std::move(task),
@@ -29,7 +29,7 @@
bool TestSimpleTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
AutoLock auto_lock(lock_);
pending_tasks_.push_back(TestPendingTask(from_here, std::move(task),
diff --git a/base/test/test_simple_task_runner.h b/base/test/test_simple_task_runner.h
index ac609f1..f46e065 100644
--- a/base/test/test_simple_task_runner.h
+++ b/base/test/test_simple_task_runner.h
@@ -44,10 +44,10 @@
// SingleThreadTaskRunner implementation.
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
diff --git a/base/threading/post_task_and_reply_impl.cc b/base/threading/post_task_and_reply_impl.cc
index 802de8c3..cddb898 100644
--- a/base/threading/post_task_and_reply_impl.cc
+++ b/base/threading/post_task_and_reply_impl.cc
@@ -29,8 +29,8 @@
class PostTaskAndReplyRelay {
public:
PostTaskAndReplyRelay(const tracked_objects::Location& from_here,
- Closure task,
- Closure reply)
+ OnceClosure task,
+ OnceClosure reply)
: sequence_checker_(),
from_here_(from_here),
origin_task_runner_(SequencedTaskRunnerHandle::Get()),
@@ -42,8 +42,7 @@
}
void RunTaskAndPostReply() {
- task_.Run();
- task_.Reset();
+ std::move(task_).Run();
origin_task_runner_->PostTask(
from_here_, Bind(&PostTaskAndReplyRelay::RunReplyAndSelfDestruct,
base::Unretained(this)));
@@ -58,7 +57,7 @@
// while |reply_| is executing.
DCHECK(!task_);
- reply_.Run();
+ std::move(reply_).Run();
// Cue mission impossible theme.
delete this;
@@ -67,8 +66,8 @@
const SequenceChecker sequence_checker_;
const tracked_objects::Location from_here_;
const scoped_refptr<SequencedTaskRunner> origin_task_runner_;
- Closure reply_;
- Closure task_;
+ OnceClosure reply_;
+ OnceClosure task_;
};
} // namespace
@@ -77,8 +76,8 @@
bool PostTaskAndReplyImpl::PostTaskAndReply(
const tracked_objects::Location& from_here,
- Closure task,
- Closure reply) {
+ OnceClosure task,
+ OnceClosure reply) {
DCHECK(!task.is_null()) << from_here.ToString();
DCHECK(!reply.is_null()) << from_here.ToString();
PostTaskAndReplyRelay* relay =
diff --git a/base/threading/post_task_and_reply_impl.h b/base/threading/post_task_and_reply_impl.h
index a02c32ec..00aee6d 100644
--- a/base/threading/post_task_and_reply_impl.h
+++ b/base/threading/post_task_and_reply_impl.h
@@ -29,12 +29,12 @@
// SequencedTaskRunnerHandle::IsSet(). Both |task| and |reply| are guaranteed
// to be deleted on the sequence or thread that called this.
bool PostTaskAndReply(const tracked_objects::Location& from_here,
- Closure task,
- Closure reply);
+ OnceClosure task,
+ OnceClosure reply);
private:
virtual bool PostTask(const tracked_objects::Location& from_here,
- Closure task) = 0;
+ OnceClosure task) = 0;
};
} // namespace internal
diff --git a/base/threading/post_task_and_reply_impl_unittest.cc b/base/threading/post_task_and_reply_impl_unittest.cc
index 5385739..f1b1d7a 100644
--- a/base/threading/post_task_and_reply_impl_unittest.cc
+++ b/base/threading/post_task_and_reply_impl_unittest.cc
@@ -29,7 +29,7 @@
private:
bool PostTask(const tracked_objects::Location& from_here,
- Closure task) override {
+ OnceClosure task) override {
return destination_->PostTask(from_here, std::move(task));
}
diff --git a/base/threading/sequenced_worker_pool.cc b/base/threading/sequenced_worker_pool.cc
index 9830604..64f1bbd 100644
--- a/base/threading/sequenced_worker_pool.cc
+++ b/base/threading/sequenced_worker_pool.cc
@@ -93,12 +93,15 @@
~SequencedTask() {}
+ SequencedTask(SequencedTask&&) = default;
+ SequencedTask& operator=(SequencedTask&&) = default;
+
int sequence_token_id;
int trace_id;
int64_t sequence_task_number;
SequencedWorkerPool::WorkerShutdown shutdown_behavior;
tracked_objects::Location posted_from;
- Closure task;
+ OnceClosure task;
// Non-delayed tasks and delayed tasks are managed together by time-to-run
// order. We calculate the time by adding the posted time and the given delay.
@@ -140,7 +143,7 @@
// TaskRunner implementation
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
@@ -164,7 +167,7 @@
bool SequencedWorkerPoolTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
if (delay.is_zero()) {
return pool_->PostWorkerTaskWithShutdownBehavior(from_here, std::move(task),
@@ -194,13 +197,13 @@
// TaskRunner implementation
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
// SequencedTaskRunner implementation
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
private:
@@ -229,7 +232,7 @@
bool SequencedWorkerPool::PoolSequencedTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
if (delay.is_zero()) {
return pool_->PostSequencedWorkerTaskWithShutdownBehavior(
@@ -246,7 +249,7 @@
bool SequencedWorkerPool::PoolSequencedTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
// There's no way to run nested tasks, so simply forward to
// PostDelayedTask.
@@ -349,7 +352,7 @@
SequenceToken sequence_token,
WorkerShutdown shutdown_behavior,
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay);
bool RunsTasksOnCurrentThread() const;
@@ -394,8 +397,7 @@
// Returns true if the task may run at some point in the future and false if
// it will definitely not run.
// Coalesce upon resolution of http://crbug.com/622400.
- bool PostTaskToTaskScheduler(const SequencedTask& sequenced,
- const TimeDelta& delay);
+ bool PostTaskToTaskScheduler(SequencedTask sequenced, const TimeDelta& delay);
// Returns the TaskScheduler TaskRunner for the specified |sequence_token_id|
// and |traits|.
@@ -693,7 +695,7 @@
SequenceToken sequence_token,
WorkerShutdown shutdown_behavior,
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
DCHECK(task);
@@ -754,12 +756,14 @@
sequenced.sequence_token_id = LockedGetNamedTokenID(*optional_token_name);
if (g_all_pools_state == AllPoolsState::REDIRECTED_TO_TASK_SCHEDULER) {
- if (!PostTaskToTaskScheduler(sequenced, delay))
+ if (!PostTaskToTaskScheduler(std::move(sequenced), delay))
return false;
} else {
- pending_tasks_.insert(sequenced);
+ SequencedWorkerPool::WorkerShutdown shutdown_behavior =
+ sequenced.shutdown_behavior;
+ pending_tasks_.insert(std::move(sequenced));
- if (sequenced.shutdown_behavior == BLOCK_SHUTDOWN)
+ if (shutdown_behavior == BLOCK_SHUTDOWN)
blocking_shutdown_pending_task_count_++;
create_thread_id = PrepareToStartAdditionalThreadIfHelpful();
@@ -796,7 +800,7 @@
}
bool SequencedWorkerPool::Inner::PostTaskToTaskScheduler(
- const SequencedTask& sequenced,
+ SequencedTask sequenced,
const TimeDelta& delay) {
DCHECK_EQ(AllPoolsState::REDIRECTED_TO_TASK_SCHEDULER, g_all_pools_state);
@@ -826,7 +830,8 @@
.WithPriority(task_priority_)
.WithShutdownBehavior(task_shutdown_behavior);
return GetTaskSchedulerTaskRunner(sequenced.sequence_token_id, traits)
- ->PostDelayedTask(sequenced.posted_from, sequenced.task, delay);
+ ->PostDelayedTask(sequenced.posted_from, std::move(sequenced.task),
+ delay);
}
scoped_refptr<TaskRunner>
@@ -1244,7 +1249,11 @@
// refcounted, so we just need to keep a copy of them alive until the lock
// is exited. The calling code can just clear() the vector they passed to
// us once the lock is exited to make this happen.
- delete_these_outside_lock->push_back(*i);
+ //
+ // The const_cast here is safe since the object is erased from
+ // |pending_tasks_| soon after the move.
+ delete_these_outside_lock->push_back(
+ std::move(const_cast<SequencedTask&>(*i)));
pending_tasks_.erase(i++);
continue;
}
@@ -1255,14 +1264,18 @@
status = GET_WORK_WAIT;
if (cleanup_state_ == CLEANUP_RUNNING) {
// Deferred tasks are deleted when cleaning up, see Inner::ThreadLoop.
- delete_these_outside_lock->push_back(*i);
+ // The const_cast here is safe since the object is erased from
+ // |pending_tasks_| soon after the move.
+ delete_these_outside_lock->push_back(
+ std::move(const_cast<SequencedTask&>(*i)));
pending_tasks_.erase(i);
}
break;
}
- // Found a runnable task.
- *task = *i;
+ // Found a runnable task. The const_cast is safe here since the object is
+ // erased from |pending_tasks_| soon after the move.
+ *task = std::move(const_cast<SequencedTask&>(*i));
pending_tasks_.erase(i);
if (task->shutdown_behavior == BLOCK_SHUTDOWN) {
blocking_shutdown_pending_task_count_--;
@@ -1535,14 +1548,14 @@
bool SequencedWorkerPool::PostWorkerTask(
const tracked_objects::Location& from_here,
- Closure task) {
+ OnceClosure task) {
return inner_->PostTask(NULL, SequenceToken(), BLOCK_SHUTDOWN, from_here,
std::move(task), TimeDelta());
}
bool SequencedWorkerPool::PostDelayedWorkerTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
WorkerShutdown shutdown_behavior =
delay.is_zero() ? BLOCK_SHUTDOWN : SKIP_ON_SHUTDOWN;
@@ -1552,7 +1565,7 @@
bool SequencedWorkerPool::PostWorkerTaskWithShutdownBehavior(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
WorkerShutdown shutdown_behavior) {
return inner_->PostTask(NULL, SequenceToken(), shutdown_behavior, from_here,
std::move(task), TimeDelta());
@@ -1561,7 +1574,7 @@
bool SequencedWorkerPool::PostSequencedWorkerTask(
SequenceToken sequence_token,
const tracked_objects::Location& from_here,
- Closure task) {
+ OnceClosure task) {
return inner_->PostTask(NULL, sequence_token, BLOCK_SHUTDOWN, from_here,
std::move(task), TimeDelta());
}
@@ -1569,7 +1582,7 @@
bool SequencedWorkerPool::PostDelayedSequencedWorkerTask(
SequenceToken sequence_token,
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
WorkerShutdown shutdown_behavior =
delay.is_zero() ? BLOCK_SHUTDOWN : SKIP_ON_SHUTDOWN;
@@ -1580,7 +1593,7 @@
bool SequencedWorkerPool::PostNamedSequencedWorkerTask(
const std::string& token_name,
const tracked_objects::Location& from_here,
- Closure task) {
+ OnceClosure task) {
DCHECK(!token_name.empty());
return inner_->PostTask(&token_name, SequenceToken(), BLOCK_SHUTDOWN,
from_here, std::move(task), TimeDelta());
@@ -1589,7 +1602,7 @@
bool SequencedWorkerPool::PostSequencedWorkerTaskWithShutdownBehavior(
SequenceToken sequence_token,
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
WorkerShutdown shutdown_behavior) {
return inner_->PostTask(NULL, sequence_token, shutdown_behavior, from_here,
std::move(task), TimeDelta());
@@ -1597,7 +1610,7 @@
bool SequencedWorkerPool::PostDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
return PostDelayedWorkerTask(from_here, std::move(task), delay);
}
diff --git a/base/threading/sequenced_worker_pool.h b/base/threading/sequenced_worker_pool.h
index 8cdeb0b5d..e577e1b 100644
--- a/base/threading/sequenced_worker_pool.h
+++ b/base/threading/sequenced_worker_pool.h
@@ -275,7 +275,8 @@
//
// Returns true if the task was posted successfully. This may fail during
// shutdown regardless of the specified ShutdownBehavior.
- bool PostWorkerTask(const tracked_objects::Location& from_here, Closure task);
+ bool PostWorkerTask(const tracked_objects::Location& from_here,
+ OnceClosure task);
// Same as PostWorkerTask but allows a delay to be specified (although doing
// so changes the shutdown behavior). The task will be run after the given
@@ -287,13 +288,13 @@
// task will be guaranteed to run to completion before shutdown
// (BLOCK_SHUTDOWN semantics).
bool PostDelayedWorkerTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay);
// Same as PostWorkerTask but allows specification of the shutdown behavior.
bool PostWorkerTaskWithShutdownBehavior(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
WorkerShutdown shutdown_behavior);
// Like PostWorkerTask above, but provides sequencing semantics. This means
@@ -309,13 +310,13 @@
// shutdown regardless of the specified ShutdownBehavior.
bool PostSequencedWorkerTask(SequenceToken sequence_token,
const tracked_objects::Location& from_here,
- Closure task);
+ OnceClosure task);
// Like PostSequencedWorkerTask above, but allows you to specify a named
// token, which saves an extra call to GetNamedSequenceToken.
bool PostNamedSequencedWorkerTask(const std::string& token_name,
const tracked_objects::Location& from_here,
- Closure task);
+ OnceClosure task);
// Same as PostSequencedWorkerTask but allows a delay to be specified
// (although doing so changes the shutdown behavior). The task will be run
@@ -329,7 +330,7 @@
bool PostDelayedSequencedWorkerTask(
SequenceToken sequence_token,
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay);
// Same as PostSequencedWorkerTask but allows specification of the shutdown
@@ -337,12 +338,12 @@
bool PostSequencedWorkerTaskWithShutdownBehavior(
SequenceToken sequence_token,
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
WorkerShutdown shutdown_behavior);
// TaskRunner implementation. Forwards to PostDelayedWorkerTask().
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
diff --git a/base/threading/worker_pool.cc b/base/threading/worker_pool.cc
index bc313ce..26ff10f 100644
--- a/base/threading/worker_pool.cc
+++ b/base/threading/worker_pool.cc
@@ -27,7 +27,7 @@
private:
bool PostTask(const tracked_objects::Location& from_here,
- Closure task) override {
+ OnceClosure task) override {
return WorkerPool::PostTask(from_here, std::move(task), task_is_slow_);
}
@@ -45,7 +45,7 @@
// TaskRunner implementation
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
@@ -56,7 +56,7 @@
// zero because non-zero delays are not supported.
bool PostDelayedTaskAssertZeroDelay(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
base::TimeDelta delay);
const bool tasks_are_slow_;
@@ -73,7 +73,7 @@
bool WorkerPoolTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) {
return PostDelayedTaskAssertZeroDelay(from_here, std::move(task), delay);
}
@@ -84,7 +84,7 @@
bool WorkerPoolTaskRunner::PostDelayedTaskAssertZeroDelay(
const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
base::TimeDelta delay) {
DCHECK_EQ(delay.InMillisecondsRoundedUp(), 0)
<< "WorkerPoolTaskRunner does not support non-zero delays";
@@ -102,8 +102,8 @@
} // namespace
bool WorkerPool::PostTaskAndReply(const tracked_objects::Location& from_here,
- Closure task,
- Closure reply,
+ OnceClosure task,
+ OnceClosure reply,
bool task_is_slow) {
// Do not report PostTaskAndReplyRelay leaks in tests. There's nothing we can
// do about them because WorkerPool doesn't have a flushing API.
diff --git a/base/threading/worker_pool.h b/base/threading/worker_pool.h
index d97dbd6..d1c666d2 100644
--- a/base/threading/worker_pool.h
+++ b/base/threading/worker_pool.h
@@ -32,15 +32,15 @@
// false if |task| could not be posted to a worker thread. Regardless of
// return value, ownership of |task| is transferred to the worker pool.
static bool PostTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
bool task_is_slow);
// Just like TaskRunner::PostTaskAndReply, except the destination
// for |task| is a worker thread and you can specify |task_is_slow| just
// like you can for PostTask above.
static bool PostTaskAndReply(const tracked_objects::Location& from_here,
- Closure task,
- Closure reply,
+ OnceClosure task,
+ OnceClosure reply,
bool task_is_slow);
// Return true if the current thread is one that this WorkerPool runs tasks
diff --git a/base/threading/worker_pool_posix.cc b/base/threading/worker_pool_posix.cc
index 5d0689b..851480ad 100644
--- a/base/threading/worker_pool_posix.cc
+++ b/base/threading/worker_pool_posix.cc
@@ -49,7 +49,7 @@
~WorkerPoolImpl() = delete;
void PostTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
bool task_is_slow);
private:
@@ -61,7 +61,7 @@
kIdleSecondsBeforeExit)) {}
void WorkerPoolImpl::PostTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
bool task_is_slow) {
pool_->PostTask(from_here, std::move(task));
}
@@ -114,7 +114,7 @@
// static
bool WorkerPool::PostTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
bool task_is_slow) {
g_lazy_worker_pool.Pointer()->PostTask(from_here, std::move(task),
task_is_slow);
@@ -140,7 +140,7 @@
void PosixDynamicThreadPool::PostTask(
const tracked_objects::Location& from_here,
- base::Closure task) {
+ base::OnceClosure task) {
PendingTask pending_task(from_here, std::move(task));
AddTask(&pending_task);
}
diff --git a/base/threading/worker_pool_posix.h b/base/threading/worker_pool_posix.h
index cfa50c2..0b10adf8f 100644
--- a/base/threading/worker_pool_posix.h
+++ b/base/threading/worker_pool_posix.h
@@ -51,7 +51,7 @@
int idle_seconds_before_exit);
// Adds |task| to the thread pool.
- void PostTask(const tracked_objects::Location& from_here, Closure task);
+ void PostTask(const tracked_objects::Location& from_here, OnceClosure task);
// Worker thread method to wait for up to |idle_seconds_before_exit| for more
// work from the thread pool. Returns NULL if no work is available.
diff --git a/base/threading/worker_pool_win.cc b/base/threading/worker_pool_win.cc
index 4e5d9085..9b1192c9 100644
--- a/base/threading/worker_pool_win.cc
+++ b/base/threading/worker_pool_win.cc
@@ -64,7 +64,7 @@
// static
bool WorkerPool::PostTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
bool task_is_slow) {
PendingTask* pending_task = new PendingTask(from_here, std::move(task));
return PostTaskInternal(pending_task, task_is_slow);
diff --git a/base/trace_event/memory_dump_manager_unittest.cc b/base/trace_event/memory_dump_manager_unittest.cc
index faae270..e126edd 100644
--- a/base/trace_event/memory_dump_manager_unittest.cc
+++ b/base/trace_event/memory_dump_manager_unittest.cc
@@ -105,7 +105,7 @@
// Posts |task| to |task_runner| and blocks until it is executed.
void PostTaskAndWait(const tracked_objects::Location& from_here,
SequencedTaskRunner* task_runner,
- base::Closure task) {
+ base::OnceClosure task) {
base::WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
WaitableEvent::InitialState::NOT_SIGNALED);
task_runner->PostTask(from_here, std::move(task));
@@ -182,14 +182,14 @@
unsigned no_of_post_tasks() const { return num_of_post_tasks_; }
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override {
NOTREACHED();
return false;
}
bool PostDelayedTask(const tracked_objects::Location& from_here,
- Closure task,
+ OnceClosure task,
TimeDelta delay) override {
num_of_post_tasks_++;
if (enabled_) {
diff --git a/cc/test/ordered_simple_task_runner.cc b/cc/test/ordered_simple_task_runner.cc
index fd263f07..4b3a80a 100644
--- a/cc/test/ordered_simple_task_runner.cc
+++ b/cc/test/ordered_simple_task_runner.cc
@@ -36,7 +36,7 @@
TestOrderablePendingTask::TestOrderablePendingTask(
const tracked_objects::Location& location,
- base::Closure task,
+ base::OnceClosure task,
base::TimeTicks post_time,
base::TimeDelta delay,
TestNestability nestability)
@@ -109,7 +109,7 @@
// base::TestSimpleTaskRunner implementation
bool OrderedSimpleTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
DCHECK(thread_checker_.CalledOnValidThread());
TestOrderablePendingTask pt(from_here, std::move(task), now_src_->NowTicks(),
@@ -122,7 +122,7 @@
bool OrderedSimpleTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
DCHECK(thread_checker_.CalledOnValidThread());
TestOrderablePendingTask pt(from_here, std::move(task), now_src_->NowTicks(),
diff --git a/cc/test/ordered_simple_task_runner.h b/cc/test/ordered_simple_task_runner.h
index 0f9c2f56..8051415f 100644
--- a/cc/test/ordered_simple_task_runner.h
+++ b/cc/test/ordered_simple_task_runner.h
@@ -29,7 +29,7 @@
public:
TestOrderablePendingTask();
TestOrderablePendingTask(const tracked_objects::Location& location,
- base::Closure task,
+ base::OnceClosure task,
base::TimeTicks post_time,
base::TimeDelta delay,
TestNestability nestability);
@@ -64,10 +64,10 @@
// base::TestSimpleTaskRunner implementation:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
diff --git a/cc/tiles/image_controller_unittest.cc b/cc/tiles/image_controller_unittest.cc
index 6e6dc24..b0eec200 100644
--- a/cc/tiles/image_controller_unittest.cc
+++ b/cc/tiles/image_controller_unittest.cc
@@ -26,7 +26,7 @@
void Run() override {
for (;;) {
- base::Closure task;
+ base::OnceClosure task;
{
base::AutoLock hold(lock_);
if (shutdown_)
@@ -50,7 +50,7 @@
condition_.Signal();
}
- void PostTask(base::Closure task) {
+ void PostTask(base::OnceClosure task) {
base::AutoLock hold(lock_);
queue_.push_back(std::move(task));
condition_.Signal();
@@ -59,7 +59,7 @@
private:
base::Lock lock_;
base::ConditionVariable condition_;
- std::vector<base::Closure> queue_;
+ std::vector<base::OnceClosure> queue_;
bool shutdown_ = false;
};
@@ -68,13 +68,13 @@
WorkerTaskRunner() { thread_.Start(); }
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return PostDelayedTask(from_here, std::move(task), delay);
}
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
thread_.PostTask(std::move(task));
return true;
@@ -142,7 +142,7 @@
class DecodeClient {
public:
DecodeClient() {}
- void Callback(base::Closure quit_closure,
+ void Callback(base::OnceClosure quit_closure,
ImageController::ImageDecodeRequestId id,
ImageController::ImageDecodeResult result) {
id_ = id;
diff --git a/cc/tiles/tile_manager_unittest.cc b/cc/tiles/tile_manager_unittest.cc
index 3675241..59e73f36 100644
--- a/cc/tiles/tile_manager_unittest.cc
+++ b/cc/tiles/tile_manager_unittest.cc
@@ -57,7 +57,7 @@
class SynchronousSimpleTaskRunner : public base::TestSimpleTaskRunner {
public:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
TestSimpleTaskRunner::PostDelayedTask(from_here, std::move(task), delay);
if (run_tasks_synchronously_)
@@ -66,7 +66,7 @@
}
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return PostDelayedTask(from_here, std::move(task), delay);
}
diff --git a/chrome/browser/after_startup_task_utils.cc b/chrome/browser/after_startup_task_utils.cc
index 7b81016..5b1513c 100644
--- a/chrome/browser/after_startup_task_utils.cc
+++ b/chrome/browser/after_startup_task_utils.cc
@@ -34,13 +34,13 @@
struct AfterStartupTask {
AfterStartupTask(const tracked_objects::Location& from_here,
const scoped_refptr<base::TaskRunner>& task_runner,
- base::Closure task)
+ base::OnceClosure task)
: from_here(from_here), task_runner(task_runner), task(std::move(task)) {}
~AfterStartupTask() {}
const tracked_objects::Location from_here;
const scoped_refptr<base::TaskRunner> task_runner;
- base::Closure task;
+ base::OnceClosure task;
};
// The flag may be read on any thread, but must only be set on the UI thread.
@@ -204,7 +204,7 @@
bool AfterStartupTaskUtils::Runner::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
DCHECK(delay.is_zero());
AfterStartupTaskUtils::PostTask(from_here, destination_runner_,
@@ -224,7 +224,7 @@
void AfterStartupTaskUtils::PostTask(
const tracked_objects::Location& from_here,
const scoped_refptr<base::TaskRunner>& destination_runner,
- base::Closure task) {
+ base::OnceClosure task) {
if (IsBrowserStartupComplete()) {
destination_runner->PostTask(from_here, std::move(task));
return;
diff --git a/chrome/browser/after_startup_task_utils.h b/chrome/browser/after_startup_task_utils.h
index dbd9b63c..a190c06 100644
--- a/chrome/browser/after_startup_task_utils.h
+++ b/chrome/browser/after_startup_task_utils.h
@@ -26,7 +26,7 @@
// Overrides from base::TaskRunner:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
@@ -47,7 +47,7 @@
static void PostTask(
const tracked_objects::Location& from_here,
const scoped_refptr<base::TaskRunner>& destination_runner,
- base::Closure task);
+ base::OnceClosure task);
// Returns true if browser startup is complete. Only use this on a one-off
// basis; If you need to poll this function constantly, use the above
diff --git a/chrome/browser/after_startup_task_utils_unittest.cc b/chrome/browser/after_startup_task_utils_unittest.cc
index 6f3dad8..6b1a9c5b 100644
--- a/chrome/browser/after_startup_task_utils_unittest.cc
+++ b/chrome/browser/after_startup_task_utils_unittest.cc
@@ -31,12 +31,13 @@
: real_task_runner_(real_runner) {}
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
++posted_task_count_;
return real_task_runner_->PostDelayedTask(
from_here,
- base::Bind(&WrappedTaskRunner::RunWrappedTask, this, std::move(task)),
+ base::BindOnce(&WrappedTaskRunner::RunWrappedTask, this,
+ std::move(task)),
base::TimeDelta()); // Squash all delays so our tests complete asap.
}
@@ -58,7 +59,7 @@
private:
~WrappedTaskRunner() override {}
- void RunWrappedTask(base::Closure task) {
+ void RunWrappedTask(base::OnceClosure task) {
++ran_task_count_;
std::move(task).Run();
}
@@ -98,12 +99,12 @@
void PostAfterStartupTaskFromDBThread(
const tracked_objects::Location& from_here,
const scoped_refptr<base::TaskRunner>& task_runner,
- base::Closure task) {
+ base::OnceClosure task) {
RunLoop run_loop;
db_thread_->real_runner()->PostTaskAndReply(
FROM_HERE,
- base::Bind(&AfterStartupTaskUtils::PostTask, from_here, task_runner,
- std::move(task)),
+ base::BindOnce(&AfterStartupTaskUtils::PostTask, from_here, task_runner,
+ std::move(task)),
base::Bind(&RunLoop::Quit, base::Unretained(&run_loop)));
run_loop.Run();
}
diff --git a/chrome/browser/chrome_content_browser_client.cc b/chrome/browser/chrome_content_browser_client.cc
index c397c07d..40ef7bf 100644
--- a/chrome/browser/chrome_content_browser_client.cc
+++ b/chrome/browser/chrome_content_browser_client.cc
@@ -1081,7 +1081,7 @@
void ChromeContentBrowserClient::PostAfterStartupTask(
const tracked_objects::Location& from_here,
const scoped_refptr<base::TaskRunner>& task_runner,
- base::Closure task) {
+ base::OnceClosure task) {
AfterStartupTaskUtils::PostTask(from_here, task_runner, std::move(task));
}
diff --git a/chrome/browser/chrome_content_browser_client.h b/chrome/browser/chrome_content_browser_client.h
index 1bdb651..f13add81 100644
--- a/chrome/browser/chrome_content_browser_client.h
+++ b/chrome/browser/chrome_content_browser_client.h
@@ -67,7 +67,7 @@
const content::MainFunctionParams& parameters) override;
void PostAfterStartupTask(const tracked_objects::Location& from_here,
const scoped_refptr<base::TaskRunner>& task_runner,
- base::Closure task) override;
+ base::OnceClosure task) override;
bool IsBrowserStartupComplete() override;
std::string GetStoragePartitionIdForSite(
content::BrowserContext* browser_context,
diff --git a/chrome/browser/chromeos/login/users/fake_chrome_user_manager.cc b/chrome/browser/chromeos/login/users/fake_chrome_user_manager.cc
index 5881b69..d731dd1a 100644
--- a/chrome/browser/chromeos/login/users/fake_chrome_user_manager.cc
+++ b/chrome/browser/chromeos/login/users/fake_chrome_user_manager.cc
@@ -37,7 +37,7 @@
private:
// base::TaskRunner overrides.
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
std::move(task).Run();
return true;
diff --git a/chrome/browser/chromeos/login/users/mock_user_manager.cc b/chrome/browser/chromeos/login/users/mock_user_manager.cc
index 26812e0a..3dd798a 100644
--- a/chrome/browser/chromeos/login/users/mock_user_manager.cc
+++ b/chrome/browser/chromeos/login/users/mock_user_manager.cc
@@ -13,7 +13,7 @@
class FakeTaskRunner : public base::TaskRunner {
public:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
std::move(task).Run();
return true;
diff --git a/chrome/browser/memory/tab_manager_unittest.cc b/chrome/browser/memory/tab_manager_unittest.cc
index 0129a78..c62a285 100644
--- a/chrome/browser/memory/tab_manager_unittest.cc
+++ b/chrome/browser/memory/tab_manager_unittest.cc
@@ -100,7 +100,7 @@
using MockTaskRunner = testing::StrictMock<LenientMockTaskRunner>;
// Represents a pending task.
-using Task = std::pair<base::TimeTicks, base::Closure>;
+using Task = std::pair<base::TimeTicks, base::OnceClosure>;
// Comparator used for sorting Task objects. Can't use std::pair's default
// comparison operators because Closure's are comparable.
@@ -120,7 +120,7 @@
: mock_(mock), clock_(clock) {}
bool RunsTasksOnCurrentThread() const override { return true; }
bool PostDelayedTask(const tracked_objects::Location& location,
- base::Closure closure,
+ base::OnceClosure closure,
base::TimeDelta delta) override {
mock_->PostDelayedTask(location, delta);
base::TimeTicks when = clock_->NowTicks() + delta;
@@ -169,7 +169,7 @@
base::SimpleTestTickClock* clock_;
// A min-heap of outstanding tasks.
- using Task = std::pair<base::TimeTicks, base::Closure>;
+ using Task = std::pair<base::TimeTicks, base::OnceClosure>;
std::vector<Task> tasks_;
DISALLOW_COPY_AND_ASSIGN(TaskRunnerProxy);
diff --git a/chromecast/base/system_time_change_notifier_unittest.cc b/chromecast/base/system_time_change_notifier_unittest.cc
index 3372aa9..41c0be4 100644
--- a/chromecast/base/system_time_change_notifier_unittest.cc
+++ b/chromecast/base/system_time_change_notifier_unittest.cc
@@ -28,14 +28,14 @@
// base::SequencedTaskRunner implementation:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
base::ThreadTaskRunnerHandle::Get()->PostTask(from_here, std::move(task));
return true;
}
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return true;
}
diff --git a/chromeos/dbus/blocking_method_caller_unittest.cc b/chromeos/dbus/blocking_method_caller_unittest.cc
index 24588c90..f126408 100644
--- a/chromeos/dbus/blocking_method_caller_unittest.cc
+++ b/chromeos/dbus/blocking_method_caller_unittest.cc
@@ -28,7 +28,7 @@
class FakeTaskRunner : public base::TaskRunner {
public:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
std::move(task).Run();
return true;
diff --git a/chromeos/tpm/tpm_token_info_getter_unittest.cc b/chromeos/tpm/tpm_token_info_getter_unittest.cc
index db58ad6..2b49d093 100644
--- a/chromeos/tpm/tpm_token_info_getter_unittest.cc
+++ b/chromeos/tpm/tpm_token_info_getter_unittest.cc
@@ -61,7 +61,7 @@
// base::TaskRunner overrides:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
delays_->push_back(delay.InMilliseconds());
base::ThreadTaskRunnerHandle::Get()->PostTask(from_here, std::move(task));
diff --git a/components/history/core/browser/history_service.cc b/components/history/core/browser/history_service.cc
index f4c9e77d..b9ebe00 100644
--- a/components/history/core/browser/history_service.cc
+++ b/components/history/core/browser/history_service.cc
@@ -937,7 +937,7 @@
}
void HistoryService::ScheduleTask(SchedulePriority priority,
- base::Closure task) {
+ base::OnceClosure task) {
DCHECK(thread_checker_.CalledOnValidThread());
CHECK(backend_task_runner_);
// TODO(brettw): Do prioritization.
diff --git a/components/history/core/browser/history_service.h b/components/history/core/browser/history_service.h
index 9e44870..c89868c 100644
--- a/components/history/core/browser/history_service.h
+++ b/components/history/core/browser/history_service.h
@@ -801,7 +801,7 @@
// Call to schedule a given task for running on the history thread with the
// specified priority. The task will have ownership taken.
- void ScheduleTask(SchedulePriority priority, base::Closure task);
+ void ScheduleTask(SchedulePriority priority, base::OnceClosure task);
// Called when the favicons for the given page URLs (e.g.
// http://www.google.com) and the given icon URL (e.g.
diff --git a/components/memory_pressure/memory_pressure_monitor_unittest.cc b/components/memory_pressure/memory_pressure_monitor_unittest.cc
index e295c835..ac608bf 100644
--- a/components/memory_pressure/memory_pressure_monitor_unittest.cc
+++ b/components/memory_pressure/memory_pressure_monitor_unittest.cc
@@ -48,7 +48,7 @@
explicit TaskRunnerProxy(MockTaskRunner* mock) : mock_(mock) {}
bool RunsTasksOnCurrentThread() const override { return true; }
bool PostDelayedTask(const tracked_objects::Location& location,
- base::Closure closure,
+ base::OnceClosure closure,
base::TimeDelta delta) override {
return mock_->PostDelayedTask(location, delta);
}
diff --git a/components/subresource_filter/content/browser/content_ruleset_service_unittest.cc b/components/subresource_filter/content/browser/content_ruleset_service_unittest.cc
index b7914875..e99b4be 100644
--- a/components/subresource_filter/content/browser/content_ruleset_service_unittest.cc
+++ b/components/subresource_filter/content/browser/content_ruleset_service_unittest.cc
@@ -48,7 +48,7 @@
// ::content::ContentBrowserClient:
void PostAfterStartupTask(const tracked_objects::Location&,
const scoped_refptr<base::TaskRunner>& task_runner,
- base::Closure task) override {
+ base::OnceClosure task) override {
scoped_refptr<base::TaskRunner> ui_task_runner =
content::BrowserThread::GetTaskRunnerForThread(
content::BrowserThread::UI);
@@ -62,7 +62,7 @@
}
private:
- base::Closure last_task_;
+ base::OnceClosure last_task_;
DISALLOW_COPY_AND_ASSIGN(TestContentBrowserClient);
};
diff --git a/components/user_manager/fake_user_manager.cc b/components/user_manager/fake_user_manager.cc
index 6ff3481..69cb7469 100644
--- a/components/user_manager/fake_user_manager.cc
+++ b/components/user_manager/fake_user_manager.cc
@@ -19,7 +19,7 @@
class FakeTaskRunner : public base::TaskRunner {
public:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
std::move(task).Run();
return true;
diff --git a/content/browser/browser_thread_impl.cc b/content/browser/browser_thread_impl.cc
index f4e0383..8df7974 100644
--- a/content/browser/browser_thread_impl.cc
+++ b/content/browser/browser_thread_impl.cc
@@ -62,14 +62,14 @@
// SingleThreadTaskRunner implementation.
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return BrowserThread::PostDelayedTask(id_, from_here, std::move(task),
delay);
}
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return BrowserThread::PostNonNestableDelayedTask(id_, from_here,
std::move(task), delay);
@@ -490,7 +490,7 @@
bool BrowserThreadImpl::PostTaskHelper(
BrowserThread::ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay,
bool nestable) {
DCHECK_GE(identifier, 0);
@@ -534,7 +534,7 @@
// static
bool BrowserThread::PostBlockingPoolTask(
const tracked_objects::Location& from_here,
- base::Closure task) {
+ base::OnceClosure task) {
return g_globals.Get().blocking_pool->PostWorkerTask(from_here,
std::move(task));
}
@@ -542,8 +542,8 @@
// static
bool BrowserThread::PostBlockingPoolTaskAndReply(
const tracked_objects::Location& from_here,
- base::Closure task,
- base::Closure reply) {
+ base::OnceClosure task,
+ base::OnceClosure reply) {
return g_globals.Get().blocking_pool->PostTaskAndReply(
from_here, std::move(task), std::move(reply));
}
@@ -552,7 +552,7 @@
bool BrowserThread::PostBlockingPoolSequencedTask(
const std::string& sequence_token_name,
const tracked_objects::Location& from_here,
- base::Closure task) {
+ base::OnceClosure task) {
return g_globals.Get().blocking_pool->PostNamedSequencedWorkerTask(
sequence_token_name, from_here, std::move(task));
}
@@ -561,7 +561,7 @@
void BrowserThread::PostAfterStartupTask(
const tracked_objects::Location& from_here,
const scoped_refptr<base::TaskRunner>& task_runner,
- base::Closure task) {
+ base::OnceClosure task) {
GetContentClient()->browser()->PostAfterStartupTask(from_here, task_runner,
std::move(task));
}
@@ -623,7 +623,7 @@
// static
bool BrowserThread::PostTask(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task) {
+ base::OnceClosure task) {
return BrowserThreadImpl::PostTaskHelper(
identifier, from_here, std::move(task), base::TimeDelta(), true);
}
@@ -631,7 +631,7 @@
// static
bool BrowserThread::PostDelayedTask(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return BrowserThreadImpl::PostTaskHelper(identifier, from_here,
std::move(task), delay, true);
@@ -641,7 +641,7 @@
bool BrowserThread::PostNonNestableTask(
ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task) {
+ base::OnceClosure task) {
return BrowserThreadImpl::PostTaskHelper(
identifier, from_here, std::move(task), base::TimeDelta(), false);
}
@@ -650,7 +650,7 @@
bool BrowserThread::PostNonNestableDelayedTask(
ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return BrowserThreadImpl::PostTaskHelper(identifier, from_here,
std::move(task), delay, false);
@@ -659,8 +659,8 @@
// static
bool BrowserThread::PostTaskAndReply(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
- base::Closure reply) {
+ base::OnceClosure task,
+ base::OnceClosure reply) {
return GetTaskRunnerForThread(identifier)
->PostTaskAndReply(from_here, std::move(task), std::move(reply));
}
diff --git a/content/browser/browser_thread_impl.h b/content/browser/browser_thread_impl.h
index b4a84399..51adc53 100644
--- a/content/browser/browser_thread_impl.h
+++ b/content/browser/browser_thread_impl.h
@@ -87,7 +87,7 @@
static bool PostTaskHelper(BrowserThread::ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay,
bool nestable);
diff --git a/content/browser/compositor/reflector_impl_unittest.cc b/content/browser/compositor/reflector_impl_unittest.cc
index b926b4c..aa62722d 100644
--- a/content/browser/compositor/reflector_impl_unittest.cc
+++ b/content/browser/compositor/reflector_impl_unittest.cc
@@ -35,12 +35,12 @@
FakeTaskRunner() {}
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return true;
}
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return true;
}
diff --git a/content/browser/dom_storage/dom_storage_task_runner.cc b/content/browser/dom_storage/dom_storage_task_runner.cc
index f4e18f0..738be98 100644
--- a/content/browser/dom_storage/dom_storage_task_runner.cc
+++ b/content/browser/dom_storage/dom_storage_task_runner.cc
@@ -31,7 +31,7 @@
bool DOMStorageWorkerPoolTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return primary_sequence_->PostDelayedTask(from_here, std::move(task), delay);
}
@@ -39,7 +39,7 @@
bool DOMStorageWorkerPoolTaskRunner::PostShutdownBlockingTask(
const tracked_objects::Location& from_here,
SequenceID sequence_id,
- base::Closure task) {
+ base::OnceClosure task) {
return GetSequencedTaskRunner(sequence_id)
->PostTask(from_here, std::move(task));
}
@@ -74,7 +74,7 @@
bool MockDOMStorageTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return task_runner_->PostTask(from_here, std::move(task));
}
@@ -82,7 +82,7 @@
bool MockDOMStorageTaskRunner::PostShutdownBlockingTask(
const tracked_objects::Location& from_here,
SequenceID sequence_id,
- base::Closure task) {
+ base::OnceClosure task) {
return task_runner_->PostTask(from_here, std::move(task));
}
diff --git a/content/browser/dom_storage/dom_storage_task_runner.h b/content/browser/dom_storage/dom_storage_task_runner.h
index 6dcbe783..ef90833 100644
--- a/content/browser/dom_storage/dom_storage_task_runner.h
+++ b/content/browser/dom_storage/dom_storage_task_runner.h
@@ -34,14 +34,14 @@
// The PostTask() and PostDelayedTask() methods defined by TaskRunner
// post shutdown-blocking tasks on the primary sequence.
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override = 0;
// Posts a shutdown blocking task to |sequence_id|.
virtual bool PostShutdownBlockingTask(
const tracked_objects::Location& from_here,
SequenceID sequence_id,
- base::Closure task) = 0;
+ base::OnceClosure task) = 0;
virtual void AssertIsRunningOnPrimarySequence() const = 0;
virtual void AssertIsRunningOnCommitSequence() const = 0;
@@ -66,12 +66,12 @@
bool RunsTasksOnCurrentThread() const override;
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostShutdownBlockingTask(const tracked_objects::Location& from_here,
SequenceID sequence_id,
- base::Closure task) override;
+ base::OnceClosure task) override;
void AssertIsRunningOnPrimarySequence() const override;
void AssertIsRunningOnCommitSequence() const override;
@@ -103,12 +103,12 @@
bool RunsTasksOnCurrentThread() const override;
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostShutdownBlockingTask(const tracked_objects::Location& from_here,
SequenceID sequence_id,
- base::Closure task) override;
+ base::OnceClosure task) override;
void AssertIsRunningOnPrimarySequence() const override;
void AssertIsRunningOnCommitSequence() const override;
diff --git a/content/browser/startup_task_runner_unittest.cc b/content/browser/startup_task_runner_unittest.cc
index cec2ec3..747c313f 100644
--- a/content/browser/startup_task_runner_unittest.cc
+++ b/content/browser/startup_task_runner_unittest.cc
@@ -88,25 +88,25 @@
TaskRunnerProxy(MockTaskRunner* mock) : mock_(mock) {}
bool RunsTasksOnCurrentThread() const override { return true; }
bool PostDelayedTask(const tracked_objects::Location& location,
- base::Closure closure,
+ base::OnceClosure closure,
base::TimeDelta delta) override {
last_task_ = std::move(closure);
return mock_->PostDelayedTask(location, delta);
}
bool PostNonNestableDelayedTask(const tracked_objects::Location& location,
- base::Closure closure,
+ base::OnceClosure closure,
base::TimeDelta delta) override {
last_task_ = std::move(closure);
return mock_->PostNonNestableDelayedTask(location, delta);
}
- base::Closure TakeLastTaskClosure() { return std::move(last_task_); }
+ base::OnceClosure TakeLastTaskClosure() { return std::move(last_task_); }
private:
~TaskRunnerProxy() override {}
MockTaskRunner* mock_;
- base::Closure last_task_;
+ base::OnceClosure last_task_;
};
TEST_F(StartupTaskRunnerTest, SynchronousExecution) {
diff --git a/content/child/worker_thread_registry.cc b/content/child/worker_thread_registry.cc
index 8eae438..80fe598 100644
--- a/content/child/worker_thread_registry.cc
+++ b/content/child/worker_thread_registry.cc
@@ -38,7 +38,7 @@
~DoNothingTaskRunner() override {}
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return false;
}
@@ -56,7 +56,7 @@
return base::PlatformThread::CurrentId();
}
-void WorkerThread::PostTask(int id, base::Closure task) {
+void WorkerThread::PostTask(int id, base::OnceClosure task) {
WorkerThreadRegistry::Instance()->PostTask(id, std::move(task));
}
@@ -125,7 +125,7 @@
: task_runner_for_dead_worker_.get();
}
-bool WorkerThreadRegistry::PostTask(int id, base::Closure closure) {
+bool WorkerThreadRegistry::PostTask(int id, base::OnceClosure closure) {
DCHECK(id > 0);
base::AutoLock locker(task_runner_map_lock_);
IDToTaskRunnerMap::iterator found = task_runner_map_.find(id);
diff --git a/content/child/worker_thread_registry.h b/content/child/worker_thread_registry.h
index 3e8f994d..657d88c 100644
--- a/content/child/worker_thread_registry.h
+++ b/content/child/worker_thread_registry.h
@@ -39,7 +39,7 @@
friend class WorkerThread;
friend class WorkerThreadRegistryTest;
- bool PostTask(int id, base::Closure task);
+ bool PostTask(int id, base::OnceClosure task);
using IDToTaskRunnerMap = std::map<base::PlatformThreadId, base::TaskRunner*>;
diff --git a/content/public/browser/browser_thread.h b/content/public/browser/browser_thread.h
index f410569..ad2db91 100644
--- a/content/public/browser/browser_thread.h
+++ b/content/public/browser/browser_thread.h
@@ -116,24 +116,24 @@
// the target thread may already have a Quit message in its queue.
static bool PostTask(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task);
+ base::OnceClosure task);
static bool PostDelayedTask(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay);
static bool PostNonNestableTask(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task);
+ base::OnceClosure task);
static bool PostNonNestableDelayedTask(
ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay);
static bool PostTaskAndReply(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
- base::Closure reply);
+ base::OnceClosure task,
+ base::OnceClosure reply);
template <typename ReturnType, typename ReplyArgType>
static bool PostTaskAndReplyWithResult(
@@ -193,15 +193,15 @@
// base::PostTaskAndReplyWithResult() with GetBlockingPool() as the task
// runner.
static bool PostBlockingPoolTask(const tracked_objects::Location& from_here,
- base::Closure task);
+ base::OnceClosure task);
static bool PostBlockingPoolTaskAndReply(
const tracked_objects::Location& from_here,
- base::Closure task,
- base::Closure reply);
+ base::OnceClosure task,
+ base::OnceClosure reply);
static bool PostBlockingPoolSequencedTask(
const std::string& sequence_token_name,
const tracked_objects::Location& from_here,
- base::Closure task);
+ base::OnceClosure task);
// For use with scheduling non-critical tasks for execution after startup.
// The order or execution of tasks posted here is unspecified even when
@@ -213,7 +213,7 @@
static void PostAfterStartupTask(
const tracked_objects::Location& from_here,
const scoped_refptr<base::TaskRunner>& task_runner,
- base::Closure task);
+ base::OnceClosure task);
// Returns the thread pool used for blocking file I/O. Use this object to
// perform random blocking operations such as file writes.
diff --git a/content/public/browser/content_browser_client.cc b/content/public/browser/content_browser_client.cc
index bf8f8fb..754c5c6 100644
--- a/content/public/browser/content_browser_client.cc
+++ b/content/public/browser/content_browser_client.cc
@@ -31,7 +31,7 @@
void ContentBrowserClient::PostAfterStartupTask(
const tracked_objects::Location& from_here,
const scoped_refptr<base::TaskRunner>& task_runner,
- base::Closure task) {
+ base::OnceClosure task) {
task_runner->PostTask(from_here, std::move(task));
}
diff --git a/content/public/browser/content_browser_client.h b/content/public/browser/content_browser_client.h
index bdb9182..f360af58 100644
--- a/content/public/browser/content_browser_client.h
+++ b/content/public/browser/content_browser_client.h
@@ -160,7 +160,7 @@
virtual void PostAfterStartupTask(
const tracked_objects::Location& from_here,
const scoped_refptr<base::TaskRunner>& task_runner,
- base::Closure task);
+ base::OnceClosure task);
// Allows the embedder to indicate whether it considers startup to be
// complete. May be called on any thread. This should be called on a one-off
diff --git a/content/public/child/worker_thread.h b/content/public/child/worker_thread.h
index c35ce8bd..926b3bd 100644
--- a/content/public/child/worker_thread.h
+++ b/content/public/child/worker_thread.h
@@ -42,7 +42,7 @@
static int GetCurrentId();
// Posts a task to the worker thread with ID |id|. ID must be > 0.
- static void PostTask(int id, base::Closure task);
+ static void PostTask(int id, base::OnceClosure task);
private:
WorkerThread(){};
diff --git a/content/renderer/categorized_worker_pool.cc b/content/renderer/categorized_worker_pool.cc
index 8ce19ba..5569e06a 100644
--- a/content/renderer/categorized_worker_pool.cc
+++ b/content/renderer/categorized_worker_pool.cc
@@ -53,7 +53,7 @@
// Overridden from base::TaskRunner:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return PostNonNestableDelayedTask(from_here, std::move(task), delay);
}
@@ -61,7 +61,7 @@
// Overridden from base::SequencedTaskRunner:
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
DCHECK(task);
base::AutoLock lock(lock_);
@@ -187,7 +187,7 @@
// Overridden from base::TaskRunner:
bool CategorizedWorkerPool::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
base::AutoLock lock(lock_);
@@ -415,7 +415,7 @@
}
}
-CategorizedWorkerPool::ClosureTask::ClosureTask(base::Closure closure)
+CategorizedWorkerPool::ClosureTask::ClosureTask(base::OnceClosure closure)
: closure_(std::move(closure)) {}
// Overridden from cc::Task:
diff --git a/content/renderer/categorized_worker_pool.h b/content/renderer/categorized_worker_pool.h
index ec65e4af..83d0fe1 100644
--- a/content/renderer/categorized_worker_pool.h
+++ b/content/renderer/categorized_worker_pool.h
@@ -36,7 +36,7 @@
// Overridden from base::TaskRunner:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
@@ -85,7 +85,7 @@
// |task_graph_runner_|.
class ClosureTask : public cc::Task {
public:
- explicit ClosureTask(base::Closure closure);
+ explicit ClosureTask(base::OnceClosure closure);
// Overridden from cc::Task:
void RunOnWorkerThread() override;
@@ -94,7 +94,7 @@
~ClosureTask() override;
private:
- base::Closure closure_;
+ base::OnceClosure closure_;
DISALLOW_COPY_AND_ASSIGN(ClosureTask);
};
diff --git a/content/renderer/render_thread_impl_browsertest.cc b/content/renderer/render_thread_impl_browsertest.cc
index c896a6b..d9de9dda 100644
--- a/content/renderer/render_thread_impl_browsertest.cc
+++ b/content/renderer/render_thread_impl_browsertest.cc
@@ -84,7 +84,7 @@
// SingleThreadTaskRunner implementation.
bool PostDelayedTask(const tracked_objects::Location&,
- base::Closure,
+ base::OnceClosure,
base::TimeDelta) override {
base::AutoLock auto_lock(lock_);
count_++;
@@ -92,7 +92,7 @@
}
bool PostNonNestableDelayedTask(const tracked_objects::Location&,
- base::Closure,
+ base::OnceClosure,
base::TimeDelta) override {
base::AutoLock auto_lock(lock_);
count_++;
diff --git a/content/test/test_blink_web_unit_test_support.cc b/content/test/test_blink_web_unit_test_support.cc
index de1fbdc..52c86cb 100644
--- a/content/test/test_blink_web_unit_test_support.cc
+++ b/content/test/test_blink_web_unit_test_support.cc
@@ -65,14 +65,14 @@
DummyTaskRunner() : thread_id_(base::PlatformThread::CurrentId()) {}
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
// Drop the delayed task.
return false;
}
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
// Drop the delayed task.
return false;
diff --git a/ios/chrome/app/application_delegate/app_state.mm b/ios/chrome/app/application_delegate/app_state.mm
index 6c0bc350..2062c8f 100644
--- a/ios/chrome/app/application_delegate/app_state.mm
+++ b/ios/chrome/app/application_delegate/app_state.mm
@@ -50,7 +50,7 @@
namespace {
// Helper method to post |closure| on the UI thread.
-void PostTaskOnUIThread(base::Closure closure) {
+void PostTaskOnUIThread(base::OnceClosure closure) {
web::WebThread::PostTask(web::WebThread::UI, FROM_HERE, std::move(closure));
}
NSString* const kStartupAttemptReset = @"StartupAttempReset";
@@ -215,17 +215,19 @@
[[_browserLauncher browserViewInformation] currentBVC]
.browserState->GetRequestContext();
_savingCookies = YES;
- base::Closure criticalClosure =
+ base::OnceClosure criticalClosure =
base::MakeCriticalClosure(base::BindBlockArc(^{
DCHECK_CURRENTLY_ON(web::WebThread::UI);
_savingCookies = NO;
}));
+ base::Closure post_back_to_ui =
+ base::Bind(&PostTaskOnUIThread, base::Passed(&criticalClosure));
web::WebThread::PostTask(
web::WebThread::IO, FROM_HERE, base::BindBlockArc(^{
net::CookieStoreIOS* store = static_cast<net::CookieStoreIOS*>(
getter->GetURLRequestContext()->cookie_store());
// FlushStore() runs its callback on any thread. Jump back to UI.
- store->FlushStore(base::Bind(&PostTaskOnUIThread, criticalClosure));
+ store->FlushStore(post_back_to_ui);
}));
}
diff --git a/ios/web/public/web_thread.h b/ios/web/public/web_thread.h
index 6a7930b..be41b30 100644
--- a/ios/web/public/web_thread.h
+++ b/ios/web/public/web_thread.h
@@ -101,31 +101,31 @@
// They return true iff the thread existed and the task was posted.
static bool PostTask(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task);
+ base::OnceClosure task);
static bool PostDelayedTask(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay);
static bool PostNonNestableTask(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task);
+ base::OnceClosure task);
static bool PostNonNestableDelayedTask(
ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay);
static bool PostTaskAndReply(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
- base::Closure reply);
+ base::OnceClosure task,
+ base::OnceClosure reply);
template <typename ReturnType, typename ReplyArgType>
static bool PostTaskAndReplyWithResult(
ID identifier,
const tracked_objects::Location& from_here,
- base::Callback<ReturnType()> task,
- base::Callback<void(ReplyArgType)> reply) {
+ base::OnceCallback<ReturnType()> task,
+ base::OnceCallback<void(ReplyArgType)> reply) {
scoped_refptr<base::SingleThreadTaskRunner> task_runner =
GetTaskRunnerForThread(identifier);
return base::PostTaskAndReplyWithResult(task_runner.get(), from_here,
@@ -161,15 +161,15 @@
// base::PostTaskAndReplyWithResult() with GetBlockingPool() as the task
// runner.
static bool PostBlockingPoolTask(const tracked_objects::Location& from_here,
- base::Closure task);
+ base::OnceClosure task);
static bool PostBlockingPoolTaskAndReply(
const tracked_objects::Location& from_here,
- base::Closure task,
- base::Closure reply);
+ base::OnceClosure task,
+ base::OnceClosure reply);
static bool PostBlockingPoolSequencedTask(
const std::string& sequence_token_name,
const tracked_objects::Location& from_here,
- base::Closure task);
+ base::OnceClosure task);
// Returns the thread pool used for blocking file I/O. Use this object to
// perform random blocking operations such as file writes.
diff --git a/ios/web/web_thread_impl.cc b/ios/web/web_thread_impl.cc
index d03e29df..236759af 100644
--- a/ios/web/web_thread_impl.cc
+++ b/ios/web/web_thread_impl.cc
@@ -49,13 +49,13 @@
// SingleThreadTaskRunner implementation.
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return WebThread::PostDelayedTask(id_, from_here, std::move(task), delay);
}
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return WebThread::PostNonNestableDelayedTask(id_, from_here,
std::move(task), delay);
@@ -291,7 +291,7 @@
// static
bool WebThreadImpl::PostTaskHelper(WebThread::ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay,
bool nestable) {
DCHECK(identifier >= 0 && identifier < ID_COUNT);
@@ -331,7 +331,7 @@
// static
bool WebThread::PostBlockingPoolTask(const tracked_objects::Location& from_here,
- base::Closure task) {
+ base::OnceClosure task) {
return g_globals.Get().blocking_pool->PostWorkerTask(from_here,
std::move(task));
}
@@ -339,8 +339,8 @@
// static
bool WebThread::PostBlockingPoolTaskAndReply(
const tracked_objects::Location& from_here,
- base::Closure task,
- base::Closure reply) {
+ base::OnceClosure task,
+ base::OnceClosure reply) {
return g_globals.Get().blocking_pool->PostTaskAndReply(
from_here, std::move(task), std::move(reply));
}
@@ -349,7 +349,7 @@
bool WebThread::PostBlockingPoolSequencedTask(
const std::string& sequence_token_name,
const tracked_objects::Location& from_here,
- base::Closure task) {
+ base::OnceClosure task) {
return g_globals.Get().blocking_pool->PostNamedSequencedWorkerTask(
sequence_token_name, from_here, std::move(task));
}
@@ -409,7 +409,7 @@
// static
bool WebThread::PostTask(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task) {
+ base::OnceClosure task) {
return WebThreadImpl::PostTaskHelper(identifier, from_here, std::move(task),
base::TimeDelta(), true);
}
@@ -417,7 +417,7 @@
// static
bool WebThread::PostDelayedTask(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return WebThreadImpl::PostTaskHelper(identifier, from_here, std::move(task),
delay, true);
@@ -426,7 +426,7 @@
// static
bool WebThread::PostNonNestableTask(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task) {
+ base::OnceClosure task) {
return WebThreadImpl::PostTaskHelper(identifier, from_here, std::move(task),
base::TimeDelta(), false);
}
@@ -435,7 +435,7 @@
bool WebThread::PostNonNestableDelayedTask(
ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return WebThreadImpl::PostTaskHelper(identifier, from_here, std::move(task),
delay, false);
@@ -444,8 +444,8 @@
// static
bool WebThread::PostTaskAndReply(ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
- base::Closure reply) {
+ base::OnceClosure task,
+ base::OnceClosure reply) {
return GetTaskRunnerForThread(identifier)
->PostTaskAndReply(from_here, std::move(task), std::move(reply));
}
diff --git a/ios/web/web_thread_impl.h b/ios/web/web_thread_impl.h
index 1341d63..c2e388b 100644
--- a/ios/web/web_thread_impl.h
+++ b/ios/web/web_thread_impl.h
@@ -49,7 +49,7 @@
static bool PostTaskHelper(WebThread::ID identifier,
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay,
bool nestable);
diff --git a/media/base/fake_single_thread_task_runner.cc b/media/base/fake_single_thread_task_runner.cc
index 63d741f..c57ae1f 100644
--- a/media/base/fake_single_thread_task_runner.cc
+++ b/media/base/fake_single_thread_task_runner.cc
@@ -20,7 +20,7 @@
bool FakeSingleThreadTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
if (fail_on_next_task_) {
LOG(FATAL) << "Infinite task posting loop detected. Possibly caused by "
@@ -69,7 +69,7 @@
if (clock_->NowTicks() < it->first.first)
return;
- base::Closure task = std::move(it->second);
+ base::OnceClosure task = std::move(it->second);
tasks_.erase(it);
std::move(task).Run();
}
@@ -90,9 +90,9 @@
}
clock_->Advance(it->first.first - clock_->NowTicks());
- const base::Closure task = it->second;
+ base::OnceClosure task = std::move(it->second);
tasks_.erase(it);
- task.Run();
+ std::move(task).Run();
}
// If this point is reached, there's likely some sort of case where a new
@@ -106,7 +106,7 @@
bool FakeSingleThreadTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
NOTIMPLEMENTED();
return false;
diff --git a/media/base/fake_single_thread_task_runner.h b/media/base/fake_single_thread_task_runner.h
index 504e27d..7b77455 100644
--- a/media/base/fake_single_thread_task_runner.h
+++ b/media/base/fake_single_thread_task_runner.h
@@ -25,14 +25,14 @@
// base::SingleThreadTaskRunner implementation.
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) final;
bool RunsTasksOnCurrentThread() const final;
// This function is currently not used, and will return false.
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) final;
protected:
@@ -49,7 +49,7 @@
// Note: The std::map data structure was chosen because the entire
// cast_unittests suite performed 20% faster than when using
// std::priority_queue. http://crbug.com/530842
- std::map<TaskKey, base::Closure> tasks_;
+ std::map<TaskKey, base::OnceClosure> tasks_;
bool fail_on_next_task_;
diff --git a/media/cast/test/skewed_single_thread_task_runner.cc b/media/cast/test/skewed_single_thread_task_runner.cc
index 6797d6fa..28361438 100644
--- a/media/cast/test/skewed_single_thread_task_runner.cc
+++ b/media/cast/test/skewed_single_thread_task_runner.cc
@@ -28,7 +28,7 @@
bool SkewedSingleThreadTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return task_runner_->PostDelayedTask(
from_here, std::move(task),
@@ -41,7 +41,7 @@
bool SkewedSingleThreadTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return task_runner_->PostNonNestableDelayedTask(
from_here, std::move(task),
diff --git a/media/cast/test/skewed_single_thread_task_runner.h b/media/cast/test/skewed_single_thread_task_runner.h
index 3fd6bdc..f03d0db 100644
--- a/media/cast/test/skewed_single_thread_task_runner.h
+++ b/media/cast/test/skewed_single_thread_task_runner.h
@@ -31,14 +31,14 @@
// base::SingleThreadTaskRunner implementation.
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) final;
bool RunsTasksOnCurrentThread() const final;
// This function is currently not used, and will return false.
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) final;
protected:
diff --git a/mojo/public/cpp/bindings/tests/bind_task_runner_unittest.cc b/mojo/public/cpp/bindings/tests/bind_task_runner_unittest.cc
index 757ed5e5..569eb51 100644
--- a/mojo/public/cpp/bindings/tests/bind_task_runner_unittest.cc
+++ b/mojo/public/cpp/bindings/tests/bind_task_runner_unittest.cc
@@ -32,14 +32,14 @@
base::WaitableEvent::InitialState::NOT_SIGNALED) {}
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
NOTREACHED();
return false;
}
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
{
base::AutoLock locker(lock_);
@@ -112,7 +112,7 @@
// Protect |tasks_|.
base::Lock lock_;
- std::queue<base::Closure> tasks_;
+ std::queue<base::OnceClosure> tasks_;
DISALLOW_COPY_AND_ASSIGN(TestTaskRunner);
};
diff --git a/net/quic/chromium/test_task_runner.cc b/net/quic/chromium/test_task_runner.cc
index eee1ad76..6ff86e5 100644
--- a/net/quic/chromium/test_task_runner.cc
+++ b/net/quic/chromium/test_task_runner.cc
@@ -18,7 +18,7 @@
TestTaskRunner::~TestTaskRunner() {}
bool TestTaskRunner::PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
EXPECT_GE(delay, base::TimeDelta());
tasks_.push_back(PostedTask(from_here, std::move(task), clock_->NowInTicks(),
diff --git a/net/quic/chromium/test_task_runner.h b/net/quic/chromium/test_task_runner.h
index a7d72e207..0c6478e1 100644
--- a/net/quic/chromium/test_task_runner.h
+++ b/net/quic/chromium/test_task_runner.h
@@ -28,7 +28,7 @@
// base::TaskRunner implementation.
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
diff --git a/remoting/base/auto_thread_task_runner.cc b/remoting/base/auto_thread_task_runner.cc
index be997110..552b985 100644
--- a/remoting/base/auto_thread_task_runner.cc
+++ b/remoting/base/auto_thread_task_runner.cc
@@ -12,14 +12,14 @@
AutoThreadTaskRunner::AutoThreadTaskRunner(
scoped_refptr<base::SingleThreadTaskRunner> task_runner,
- base::Closure stop_task)
+ base::OnceClosure stop_task)
: stop_task_(std::move(stop_task)), task_runner_(task_runner) {
DCHECK(!stop_task_.is_null());
}
bool AutoThreadTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
CHECK(task_runner_->PostDelayedTask(from_here, std::move(task), delay));
return true;
@@ -27,7 +27,7 @@
bool AutoThreadTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
CHECK(task_runner_->PostNonNestableDelayedTask(from_here, std::move(task),
delay));
diff --git a/remoting/base/auto_thread_task_runner.h b/remoting/base/auto_thread_task_runner.h
index 39e8f3c..f29173e 100644
--- a/remoting/base/auto_thread_task_runner.h
+++ b/remoting/base/auto_thread_task_runner.h
@@ -23,14 +23,14 @@
// |stop_task| is posted to |task_runner| when the last reference to
// the AutoThreadTaskRunner is dropped.
AutoThreadTaskRunner(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
- base::Closure stop_task);
+ base::OnceClosure stop_task);
// SingleThreadTaskRunner implementation
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
@@ -42,7 +42,7 @@
~AutoThreadTaskRunner() override;
// Task posted to |task_runner_| to notify the caller that it may be stopped.
- base::Closure stop_task_;
+ base::OnceClosure stop_task_;
// The wrapped task runner.
scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
diff --git a/remoting/client/plugin/pepper_main_thread_task_runner.cc b/remoting/client/plugin/pepper_main_thread_task_runner.cc
index 8f3ca24..c350566 100644
--- a/remoting/client/plugin/pepper_main_thread_task_runner.cc
+++ b/remoting/client/plugin/pepper_main_thread_task_runner.cc
@@ -17,8 +17,9 @@
namespace {
void RunAndDestroy(void* task_ptr, int32_t) {
- std::unique_ptr<base::Closure> task(static_cast<base::Closure*>(task_ptr));
- task->Run();
+ std::unique_ptr<base::OnceClosure> task(
+ static_cast<base::OnceClosure*>(task_ptr));
+ std::move(*task).Run();
}
} // namespace
@@ -31,9 +32,9 @@
bool PepperMainThreadTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
- auto task_ptr = base::MakeUnique<base::Closure>(base::Bind(
+ auto task_ptr = base::MakeUnique<base::OnceClosure>(base::Bind(
&PepperMainThreadTaskRunner::RunTask, weak_ptr_, base::Passed(&task)));
core_->CallOnMainThread(
delay.InMillisecondsRoundedUp(),
@@ -43,7 +44,7 @@
bool PepperMainThreadTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return PostDelayedTask(from_here, std::move(task), delay);
}
@@ -54,7 +55,7 @@
PepperMainThreadTaskRunner::~PepperMainThreadTaskRunner() {}
-void PepperMainThreadTaskRunner::RunTask(base::Closure task) {
+void PepperMainThreadTaskRunner::RunTask(base::OnceClosure task) {
std::move(task).Run();
}
diff --git a/remoting/client/plugin/pepper_main_thread_task_runner.h b/remoting/client/plugin/pepper_main_thread_task_runner.h
index 320d8f5..7cc953f9 100644
--- a/remoting/client/plugin/pepper_main_thread_task_runner.h
+++ b/remoting/client/plugin/pepper_main_thread_task_runner.h
@@ -27,10 +27,10 @@
// base::SingleThreadTaskRunner interface.
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
@@ -40,7 +40,7 @@
private:
// Helper that allows a base::Closure to be used as a pp::CompletionCallback,
// by ignoring the completion result.
- void RunTask(base::Closure task);
+ void RunTask(base::OnceClosure task);
pp::Core* core_;
diff --git a/third_party/WebKit/Source/platform/WebTaskRunner.h b/third_party/WebKit/Source/platform/WebTaskRunner.h
index 1dda249..e35fa389 100644
--- a/third_party/WebKit/Source/platform/WebTaskRunner.h
+++ b/third_party/WebKit/Source/platform/WebTaskRunner.h
@@ -62,7 +62,7 @@
// Schedule a task to be run after |delayMs| on the the associated WebThread.
// Can be called from any thread.
virtual void postDelayedTask(const WebTraceLocation&,
- base::Closure,
+ base::OnceClosure,
double delayMs) = 0;
// Returns true if the current thread is a thread on which a task may be run.
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
index f0758ba..b34de09 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
@@ -119,7 +119,7 @@
}
TaskQueueImpl::Task::Task(const tracked_objects::Location& posted_from,
- base::Closure task,
+ base::OnceClosure task,
base::TimeTicks desired_run_time,
EnqueueOrder sequence_number,
bool nestable)
@@ -132,7 +132,7 @@
}
TaskQueueImpl::Task::Task(const tracked_objects::Location& posted_from,
- base::Closure task,
+ base::OnceClosure task,
base::TimeTicks desired_run_time,
EnqueueOrder sequence_number,
bool nestable,
@@ -194,7 +194,7 @@
}
bool TaskQueueImpl::PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
if (delay.is_zero())
return PostImmediateTaskImpl(from_here, std::move(task), TaskType::NORMAL);
@@ -205,7 +205,7 @@
bool TaskQueueImpl::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
if (delay.is_zero())
return PostImmediateTaskImpl(from_here, std::move(task),
@@ -217,7 +217,7 @@
bool TaskQueueImpl::PostImmediateTaskImpl(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
TaskType task_type) {
DCHECK(task);
base::AutoLock lock(any_thread_lock_);
@@ -235,7 +235,7 @@
bool TaskQueueImpl::PostDelayedTaskImpl(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay,
TaskType task_type) {
DCHECK(task);
@@ -332,7 +332,7 @@
void TaskQueueImpl::PushOntoImmediateIncomingQueueLocked(
const tracked_objects::Location& posted_from,
- base::Closure task,
+ base::OnceClosure task,
base::TimeTicks desired_run_time,
EnqueueOrder sequence_number,
bool nestable) {
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.h b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.h
index a50de15..b786e22 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.h
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.h
@@ -69,13 +69,13 @@
public:
Task();
Task(const tracked_objects::Location& posted_from,
- base::Closure task,
+ base::OnceClosure task,
base::TimeTicks desired_run_time,
EnqueueOrder sequence_number,
bool nestable);
Task(const tracked_objects::Location& posted_from,
- base::Closure task,
+ base::OnceClosure task,
base::TimeTicks desired_run_time,
EnqueueOrder sequence_number,
bool nestable,
@@ -131,10 +131,10 @@
void UnregisterTaskQueue() override;
bool RunsTasksOnCurrentThread() const override;
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
std::unique_ptr<QueueEnabledVoter> CreateQueueEnabledVoter() override;
bool IsQueueEnabled() const override;
@@ -283,10 +283,10 @@
~TaskQueueImpl() override;
bool PostImmediateTaskImpl(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
TaskType task_type);
bool PostDelayedTaskImpl(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay,
TaskType task_type);
@@ -308,7 +308,7 @@
// empty.
void PushOntoImmediateIncomingQueueLocked(
const tracked_objects::Location& posted_from,
- base::Closure task,
+ base::OnceClosure task,
base::TimeTicks desired_run_time,
EnqueueOrder sequence_number,
bool nestable);
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_delegate_for_test.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_delegate_for_test.cc
index 0893006..b22d977 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_delegate_for_test.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_delegate_for_test.cc
@@ -30,14 +30,14 @@
bool TaskQueueManagerDelegateForTest::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return task_runner_->PostDelayedTask(from_here, std::move(task), delay);
}
bool TaskQueueManagerDelegateForTest::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return task_runner_->PostNonNestableDelayedTask(from_here, std::move(task),
delay);
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_delegate_for_test.h b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_delegate_for_test.h
index 6ac74f8..81495a4 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_delegate_for_test.h
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_delegate_for_test.h
@@ -23,10 +23,10 @@
// NestableSingleThreadTaskRunner implementation
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
bool IsNested() const override;
diff --git a/third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc b/third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc
index 345a443b..a86fafd6 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc
+++ b/third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc
@@ -29,13 +29,13 @@
}
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return task_runner_->PostDelayedTask(from_here, std::move(task), delay);
}
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
return task_runner_->PostNonNestableDelayedTask(from_here, std::move(task),
delay);
diff --git a/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_for_test.cc b/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_for_test.cc
index ad6fa03..e296540 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_for_test.cc
+++ b/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_for_test.cc
@@ -41,14 +41,14 @@
bool SchedulerTqmDelegateForTest::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return task_runner_->PostDelayedTask(from_here, std::move(task), delay);
}
bool SchedulerTqmDelegateForTest::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return task_runner_->PostNonNestableDelayedTask(from_here, std::move(task),
delay);
diff --git a/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_for_test.h b/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_for_test.h
index 445d7aa..5946dbc 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_for_test.h
+++ b/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_for_test.h
@@ -28,10 +28,10 @@
scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
void RestoreDefaultTaskRunner() override;
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
bool IsNested() const override;
diff --git a/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_impl.cc b/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_impl.cc
index 8425c34..007dd53 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_impl.cc
@@ -40,7 +40,7 @@
bool SchedulerTqmDelegateImpl::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return message_loop_task_runner_->PostDelayedTask(from_here, std::move(task),
delay);
@@ -48,7 +48,7 @@
bool SchedulerTqmDelegateImpl::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return message_loop_task_runner_->PostNonNestableDelayedTask(
from_here, std::move(task), delay);
diff --git a/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_impl.h b/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_impl.h
index b8308a7..b043ff4 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_impl.h
+++ b/third_party/WebKit/Source/platform/scheduler/child/scheduler_tqm_delegate_impl.h
@@ -29,10 +29,10 @@
scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
void RestoreDefaultTaskRunner() override;
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
bool IsNested() const override;
diff --git a/third_party/WebKit/Source/platform/scheduler/child/web_task_runner_impl.cc b/third_party/WebKit/Source/platform/scheduler/child/web_task_runner_impl.cc
index f340294..b9d79069 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/web_task_runner_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/child/web_task_runner_impl.cc
@@ -22,7 +22,7 @@
}
void WebTaskRunnerImpl::postDelayedTask(const WebTraceLocation& location,
- base::Closure task,
+ base::OnceClosure task,
double delayMs) {
DCHECK_GE(delayMs, 0.0) << location.function_name() << " "
<< location.file_name();
diff --git a/third_party/WebKit/Source/platform/scheduler/child/web_task_runner_impl.h b/third_party/WebKit/Source/platform/scheduler/child/web_task_runner_impl.h
index fe21732..fbc49c26 100644
--- a/third_party/WebKit/Source/platform/scheduler/child/web_task_runner_impl.h
+++ b/third_party/WebKit/Source/platform/scheduler/child/web_task_runner_impl.h
@@ -24,7 +24,7 @@
// WebTaskRunner implementation:
void postDelayedTask(const WebTraceLocation&,
- base::Closure,
+ base::OnceClosure,
double delayMs) override;
bool runsTasksOnCurrentThread() override;
double virtualTimeSeconds() const override;
diff --git a/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.cc b/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.cc
index 57f06be..682decb 100644
--- a/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.cc
+++ b/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.cc
@@ -19,11 +19,12 @@
public:
Data() : time_(0.0) {}
- void PostTask(const base::Closure& task, base::TimeDelta delay) {
- task_queue_.push_back(std::make_pair(task, time_ + delay.InSecondsF()));
+ void PostTask(base::OnceClosure task, base::TimeDelta delay) {
+ task_queue_.push_back(
+ std::make_pair(std::move(task), time_ + delay.InSecondsF()));
}
- using QueueItem = std::pair<base::Closure, double>;
+ using QueueItem = std::pair<base::OnceClosure, double>;
std::deque<QueueItem>::iterator FindRunnableTask() {
// TODO(tkent): This should return an item which has the minimum |second|.
return std::find_if(
@@ -47,14 +48,14 @@
explicit BaseTaskRunner(PassRefPtr<Data> data) : data_(std::move(data)) {}
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
data_->PostTask(std::move(task), delay);
return true;
}
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override {
data_->PostTask(std::move(task), delay);
return true;
@@ -82,7 +83,7 @@
}
void FakeWebTaskRunner::postDelayedTask(const WebTraceLocation&,
- base::Closure closure,
+ base::OnceClosure closure,
double delay_ms) {
data_->PostTask(std::move(closure),
base::TimeDelta::FromMillisecondsD(delay_ms));
@@ -108,7 +109,7 @@
while (!data_->task_queue_.empty()) {
// Move the task to run into a local variable in case it touches the
// task queue by posting a new task.
- base::Closure task = std::move(data_->task_queue_.front()).first;
+ base::OnceClosure task = std::move(data_->task_queue_.front()).first;
data_->task_queue_.pop_front();
std::move(task).Run();
}
@@ -118,13 +119,13 @@
data_->time_ += delta_seconds;
for (auto it = data_->FindRunnableTask(); it != data_->task_queue_.end();
it = data_->FindRunnableTask()) {
- base::Closure task = std::move(*it).first;
+ base::OnceClosure task = std::move(*it).first;
data_->task_queue_.erase(it);
- task.Run();
+ std::move(task).Run();
}
}
-std::deque<std::pair<base::Closure, double>>
+std::deque<std::pair<base::OnceClosure, double>>
FakeWebTaskRunner::takePendingTasksForTesting() {
return std::move(data_->task_queue_);
}
diff --git a/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.h b/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.h
index 192ec09..ce82ab2 100644
--- a/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.h
+++ b/third_party/WebKit/Source/platform/scheduler/test/fake_web_task_runner.h
@@ -25,7 +25,9 @@
void setTime(double new_time);
// WebTaskRunner implementation:
- void postDelayedTask(const WebTraceLocation&, base::Closure, double) override;
+ void postDelayedTask(const WebTraceLocation&,
+ base::OnceClosure,
+ double) override;
bool runsTasksOnCurrentThread() override;
double virtualTimeSeconds() const override;
double monotonicallyIncreasingVirtualTimeSeconds() const override;
@@ -33,7 +35,7 @@
void runUntilIdle();
void advanceTimeAndRun(double delta_seconds);
- std::deque<std::pair<base::Closure, double>> takePendingTasksForTesting();
+ std::deque<std::pair<base::OnceClosure, double>> takePendingTasksForTesting();
private:
~FakeWebTaskRunner() override;
diff --git a/third_party/WebKit/Source/platform/scheduler/test/lazy_scheduler_message_loop_delegate_for_tests.cc b/third_party/WebKit/Source/platform/scheduler/test/lazy_scheduler_message_loop_delegate_for_tests.cc
index c089abf2..bd41c59f 100644
--- a/third_party/WebKit/Source/platform/scheduler/test/lazy_scheduler_message_loop_delegate_for_tests.cc
+++ b/third_party/WebKit/Source/platform/scheduler/test/lazy_scheduler_message_loop_delegate_for_tests.cc
@@ -68,7 +68,7 @@
bool LazySchedulerMessageLoopDelegateForTests::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
EnsureMessageLoop();
return original_task_runner_->PostDelayedTask(from_here, std::move(task),
@@ -77,7 +77,7 @@
bool LazySchedulerMessageLoopDelegateForTests::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
EnsureMessageLoop();
return original_task_runner_->PostNonNestableDelayedTask(
diff --git a/third_party/WebKit/Source/platform/scheduler/test/lazy_scheduler_message_loop_delegate_for_tests.h b/third_party/WebKit/Source/platform/scheduler/test/lazy_scheduler_message_loop_delegate_for_tests.h
index 6044dc6..bdbd746 100644
--- a/third_party/WebKit/Source/platform/scheduler/test/lazy_scheduler_message_loop_delegate_for_tests.h
+++ b/third_party/WebKit/Source/platform/scheduler/test/lazy_scheduler_message_loop_delegate_for_tests.h
@@ -32,10 +32,10 @@
scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
void RestoreDefaultTaskRunner() override;
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
bool IsNested() const override;
diff --git a/ui/accelerated_widget_mac/window_resize_helper_mac.cc b/ui/accelerated_widget_mac/window_resize_helper_mac.cc
index 2c999b8..88bf682a 100644
--- a/ui/accelerated_widget_mac/window_resize_helper_mac.cc
+++ b/ui/accelerated_widget_mac/window_resize_helper_mac.cc
@@ -32,7 +32,7 @@
// yet, to avoid running them twice.
class WrappedTask {
public:
- WrappedTask(base::Closure closure, base::TimeDelta delay);
+ WrappedTask(base::OnceClosure closure, base::TimeDelta delay);
~WrappedTask();
bool ShouldRunBefore(const WrappedTask& other);
void Run();
@@ -41,7 +41,7 @@
const base::TimeTicks& can_run_time() const { return can_run_time_; }
private:
- base::Closure closure_;
+ base::OnceClosure closure_;
base::TimeTicks can_run_time_;
bool has_run_;
uint64_t sequence_number_;
@@ -74,11 +74,11 @@
// base::SingleThreadTaskRunner implementation:
bool PostDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) override;
bool RunsTasksOnCurrentThread() const override;
@@ -114,7 +114,7 @@
////////////////////////////////////////////////////////////////////////////////
// WrappedTask
-WrappedTask::WrappedTask(base::Closure closure, base::TimeDelta delay)
+WrappedTask::WrappedTask(base::OnceClosure closure, base::TimeDelta delay)
: closure_(std::move(closure)),
can_run_time_(base::TimeTicks::Now() + delay),
has_run_(false),
@@ -260,7 +260,7 @@
bool PumpableTaskRunner::PostDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
return EnqueueAndPostWrappedTask(
from_here, new WrappedTask(std::move(task), delay), delay);
@@ -268,7 +268,7 @@
bool PumpableTaskRunner::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
- base::Closure task,
+ base::OnceClosure task,
base::TimeDelta delay) {
// The correctness of non-nestable events hasn't been proven for this
// structure.
