Replace Closure in TaskRunner::PostTask with OneShotCallback

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 69 matching lines @@
   WebContents* new_contents_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTabStripModelObserver);
 };
 
 // A mock task runner. This isn't directly a TaskRunner as the reference
 // counting confuses gmock.
 class LenientMockTaskRunner {
  public:
   LenientMockTaskRunner() {}
-  MOCK_METHOD3(PostDelayedTask,
-               bool(const tracked_objects::Location&,
-                    const base::Closure&,
-                    base::TimeDelta));
+  MOCK_METHOD1(PostDelayedTask, bool(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,
-                       const base::Closure& closure,
+                       base::OnceClosure closure,
                        base::TimeDelta delta) override {
-    mock_->PostDelayedTask(location, closure, delta);
+    mock_->PostDelayedTask(delta);
     base::TimeTicks when = clock_->NowTicks() + delta;
-    tasks_.push_back(Task(when, closure));
+    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.
   size_t RunTasks() {
     base::TimeTicks now = clock_->NowTicks();
     size_t count = 0;
     while (!tasks_.empty() && tasks_.front().first <= now) {
-      tasks_.front().second.Run();
+      std::move(tasks_.front().second).Run();
       std::pop_heap(tasks_.begin(), tasks_.end(), TaskComparator());
       tasks_.pop_back();
       ++count;
     }
     return count;
   }
 
   // Advances the clock and runs the next task in the queue. Can run more than
   // one task if multiple tasks have the same scheduled time.
   size_t RunNextTask() {
@@ skipping 13 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 400 matching lines @@
   EXPECT_EQ(0u, task_runner->size());
   EXPECT_EQ(0u, tm.notified_renderers_.size());
 
   // START OF MEMORY PRESSURE
 
   // Simulate a memory pressure situation that persists. This should cause a
   // task to be scheduled, and a background renderer to be notified.
   tm.get_current_pressure_level_ = base::Bind(
       &ReturnSpecifiedPressure, base::Unretained(&level));
   EXPECT_CALL(mock_task_runner, PostDelayedTask(
-      testing::_,
-      testing::_,
       base::TimeDelta::FromSeconds(tm.kRendererNotificationDelayInSeconds)));
   EXPECT_CALL(*this, NotifyRendererProcess(renderer2, level));
   tm.OnMemoryPressure(level);
   testing::Mock::VerifyAndClearExpectations(&mock_task_runner);
   testing::Mock::VerifyAndClearExpectations(this);
   EXPECT_TRUE(tm.under_memory_pressure_);
   EXPECT_EQ(1u, task_runner->size());
   EXPECT_EQ(1u, tm.notified_renderers_.size());
   EXPECT_EQ(1u, tm.notified_renderers_.count(renderer2));
 
   // REPEATED MEMORY PRESSURE SIGNAL
 
   // Simulate another memory pressure event. This should not cause any
   // additional tasks to be scheduled, nor any further renderer notifications.
   tm.OnMemoryPressure(level);
   testing::Mock::VerifyAndClearExpectations(&mock_task_runner);
   testing::Mock::VerifyAndClearExpectations(this);
   EXPECT_TRUE(tm.under_memory_pressure_);
   EXPECT_EQ(1u, task_runner->size());
   EXPECT_EQ(1u, tm.notified_renderers_.size());
 
   // FIRST SCHEDULED NOTIFICATION
 
   // Run the scheduled task. This should cause another notification, but this
   // time to the foreground tab. It should also cause another scheduled event.
   EXPECT_CALL(mock_task_runner, PostDelayedTask(
-      testing::_,
-      testing::_,
       base::TimeDelta::FromSeconds(tm.kRendererNotificationDelayInSeconds)));
   EXPECT_CALL(*this, NotifyRendererProcess(renderer1, level));
   EXPECT_EQ(1u, task_runner->RunNextTask());
   testing::Mock::VerifyAndClearExpectations(&mock_task_runner);
   testing::Mock::VerifyAndClearExpectations(this);
   EXPECT_TRUE(tm.under_memory_pressure_);
   EXPECT_EQ(1u, task_runner->size());
   EXPECT_EQ(2u, tm.notified_renderers_.size());
   EXPECT_EQ(1u, tm.notified_renderers_.count(renderer1));
 
   // SECOND SCHEDULED NOTIFICATION
 
   // Run the scheduled task. This should cause another notification, to the
   // background tab. It should also cause another scheduled event.
   EXPECT_CALL(mock_task_runner, PostDelayedTask(
-      testing::_,
-      testing::_,
       base::TimeDelta::FromSeconds(tm.kRendererNotificationDelayInSeconds)));
   EXPECT_CALL(*this, NotifyRendererProcess(renderer2, level));
   EXPECT_EQ(1u, task_runner->RunNextTask());
   testing::Mock::VerifyAndClearExpectations(&mock_task_runner);
   testing::Mock::VerifyAndClearExpectations(this);
   EXPECT_TRUE(tm.under_memory_pressure_);
   EXPECT_EQ(1u, task_runner->size());
   EXPECT_EQ(1u, tm.notified_renderers_.size());
 
   // Expect that the background tab has been notified. The list of notified
@@ skipping 14 matching lines @@
   EXPECT_EQ(0u, task_runner->size());
   EXPECT_EQ(0u, tm.notified_renderers_.size());
 
 
   // Clean up the tabstrip.
   tabstrip.CloseAllTabs();
   ASSERT_TRUE(tabstrip.empty());
 }
 
 }  // namespace memory