Migrate base::TaskRunner from Closure to OnceClosure

chrome/browser/memory/tab_manager_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/memory/tab_manager.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
@@ skipping 82 matching lines @@
   LenientMockTaskRunner() {}
   MOCK_METHOD2(PostDelayedTask,
                bool(const tracked_objects::Location&, base::TimeDelta));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LenientMockTaskRunner);
 };
 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.
 struct TaskComparator {
   bool operator()(const Task& t1, const Task& t2) const {
     // Reverse the sort order so this can be used with a min-heap.
     return t1.first > t2.first;
   }
 };
 
 // A TaskRunner implementation that delegates to a MockTaskRunner for asserting
 // on task insertion order, and which stores tasks for actual later execution.
 class TaskRunnerProxy : public base::TaskRunner {
  public:
   TaskRunnerProxy(MockTaskRunner* mock,
                   base::SimpleTestTickClock* clock)
       : 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;
     tasks_.push_back(Task(when, std::move(closure)));
     // Use 'greater' comparator to make this a min heap.
     std::push_heap(tasks_.begin(), tasks_.end(), TaskComparator());
     return true;
   }
 
   // Runs tasks up to the current time. Returns the number of tasks executed.
@@ skipping 28 matching lines @@
 
   size_t size() const { return tasks_.size(); }
 
  private:
   ~TaskRunnerProxy() override {}
 
   MockTaskRunner* mock_;
   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);
 };
 
 enum TestIndicies {
   kSelected,
   kAutoDiscardable,
   kPinned,
   kApp,
@@ skipping 561 matching lines @@
   // Since tab2 is kept inactive and background for more than time-to-purge,
   // tab2 should be purged.
   EXPECT_TRUE(tab_manager.GetWebContentsData(tab2)->is_purged());
 
   // Activate tab2. Tab2's PurgeAndSuspend state should be NOT_PURGED.
   tabstrip.ActivateTabAt(1, true /* user_gesture */);
   EXPECT_FALSE(tab_manager.GetWebContentsData(tab2)->is_purged());
 }
 
 }  // namespace memory