Pass Callback to TaskRunner by value and consume it on invocation (1)

ui/accelerated_widget_mac/window_resize_helper_mac.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/accelerated_widget_mac/window_resize_helper_mac.h"
 
 #include <stdint.h>
 
 #include <list>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
 
 namespace ui {
 namespace {
 
 class WrappedTask;
 class PumpableTaskRunner;
 typedef std::list<WrappedTask*> WrappedTaskQueue;
 typedef base::Callback<void(base::WaitableEvent*, base::TimeDelta)>
     EventTimedWaitCallback;
 
 // A wrapper for IPCs and tasks that we may potentially execute in
 // WaitForSingleTaskToRun. Because these tasks are sent to two places to run,
 // we to wrap them in this structure and track whether or not they have run
 // yet, to avoid running them twice.
 class WrappedTask {
  public:
-  WrappedTask(const base::Closure& closure, base::TimeDelta delay);
+  WrappedTask(base::Closure closure, base::TimeDelta delay);
   ~WrappedTask();
   bool ShouldRunBefore(const WrappedTask& other);
   void Run();
   void AddToTaskRunnerQueue(PumpableTaskRunner* pumpable_task_runner);
   void RemoveFromTaskRunnerQueue();
   const base::TimeTicks& can_run_time() const { return can_run_time_; }
 
  private:
   base::Closure closure_;
   base::TimeTicks can_run_time_;
@@ skipping 21 matching lines @@
   // Enqueue WrappedTask and post it to |target_task_runner_|.
   bool EnqueueAndPostWrappedTask(const tracked_objects::Location& from_here,
                                  WrappedTask* task,
                                  base::TimeDelta delay);
 
   // Wait at most |max_delay| to run an enqueued task.
   bool WaitForSingleWrappedTaskToRun(const base::TimeDelta& max_delay);
 
   // base::SingleThreadTaskRunner implementation:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
-                       const base::Closure& task,
+                       base::Closure task,
                        base::TimeDelta delay) override;
 
   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
-                                  const base::Closure& task,
+                                  base::Closure task,
                                   base::TimeDelta delay) override;
 
   bool RunsTasksOnCurrentThread() const override;
 
  private:
   friend class WrappedTask;
 
   ~PumpableTaskRunner() override;
 
   // A queue of live messages.  Must hold |task_queue_lock_| to access. Tasks
@@ skipping 15 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PumpableTaskRunner);
 };
 
 base::LazyInstance<WindowResizeHelperMac>::Leaky g_window_resize_helper =
     LAZY_INSTANCE_INITIALIZER;
 
 ////////////////////////////////////////////////////////////////////////////////
 // WrappedTask
 
-WrappedTask::WrappedTask(const base::Closure& closure, base::TimeDelta delay)
-    : closure_(closure),
+WrappedTask::WrappedTask(base::Closure closure, base::TimeDelta delay)
+    : closure_(std::move(closure)),
       can_run_time_(base::TimeTicks::Now() + delay),
       has_run_(false),
       sequence_number_(0) {}
 
 WrappedTask::~WrappedTask() {
   RemoveFromTaskRunnerQueue();
 }
 
 bool WrappedTask::ShouldRunBefore(const WrappedTask& other) {
   if (can_run_time_ < other.can_run_time_)
     return true;
   if (can_run_time_ > other.can_run_time_)
     return false;
   if (sequence_number_ < other.sequence_number_)
     return true;
   if (sequence_number_ > other.sequence_number_)
     return false;
   // Sequence numbers are unique, so this should never happen.
   NOTREACHED();
   return false;
 }
 
 void WrappedTask::Run() {
   if (has_run_)
     return;
   RemoveFromTaskRunnerQueue();
   has_run_ = true;
-  closure_.Run();
+  std::move(closure_).Run();
 }
 
 void WrappedTask::AddToTaskRunnerQueue(
     PumpableTaskRunner* pumpable_task_runner) {
   pumpable_task_runner_ = pumpable_task_runner;
   base::AutoLock lock(pumpable_task_runner_->task_queue_lock_);
   static uint64_t last_sequence_number = 0;
   last_sequence_number += 1;
   sequence_number_ = last_sequence_number;
   iterator_ = pumpable_task_runner_->task_queue_.insert(
@@ skipping 96 matching lines @@
 
   return target_task_runner_->PostDelayedTask(
       from_here, base::Bind(&WrappedTask::Run, base::Owned(task)), delay);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PumpableTaskRunner, base::SingleThreadTaskRunner implementation:
 
 bool PumpableTaskRunner::PostDelayedTask(
     const tracked_objects::Location& from_here,
-    const base::Closure& task,
+    base::Closure task,
     base::TimeDelta delay) {
-  return EnqueueAndPostWrappedTask(from_here, new WrappedTask(task, delay),
-                                   delay);
+  return EnqueueAndPostWrappedTask(
+      from_here, new WrappedTask(std::move(task), delay), delay);
 }
 
 bool PumpableTaskRunner::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here,
-    const base::Closure& task,
+    base::Closure task,
     base::TimeDelta delay) {
   // The correctness of non-nestable events hasn't been proven for this
   // structure.
   NOTREACHED();
   return false;
 }
 
 bool PumpableTaskRunner::RunsTasksOnCurrentThread() const {
   return target_task_runner_->RunsTasksOnCurrentThread();
 }
@@ skipping 36 matching lines @@
 WindowResizeHelperMac::WindowResizeHelperMac() {}
 WindowResizeHelperMac::~WindowResizeHelperMac() {}
 
 void WindowResizeHelperMac::EventTimedWait(base::WaitableEvent* event,
                                            base::TimeDelta delay) {
   base::ThreadRestrictions::ScopedAllowWait allow_wait;
   event->TimedWait(delay);
 }
 
 }  // namespace ui