Migrate base::TaskRunner from Closure to OnceClosure

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>
@@ skipping 14 matching lines @@
 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(base::Closure closure, base::TimeDelta delay);
+  WrappedTask(base::OnceClosure 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::OnceClosure closure_;
   base::TimeTicks can_run_time_;
   bool has_run_;
   uint64_t sequence_number_;
   WrappedTaskQueue::iterator iterator_;
 
   // Back pointer to the pumpable task runner that this task is enqueued in.
   scoped_refptr<PumpableTaskRunner> pumpable_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WrappedTask);
 };
@@ skipping 12 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,
-                       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;
 
  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(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),
       sequence_number_(0) {}
 
 WrappedTask::~WrappedTask() {
   RemoveFromTaskRunnerQueue();
 }
 
 bool WrappedTask::ShouldRunBefore(const WrappedTask& other) {
@@ skipping 125 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,
-    base::Closure task,
+    base::OnceClosure task,
     base::TimeDelta delay) {
   return EnqueueAndPostWrappedTask(
       from_here, new WrappedTask(std::move(task), delay), delay);
 }
 
 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.
   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