Replace Closure in TaskRunner::PostTask with OneShotCallback

content/browser/startup_task_runner_unittest.cc

Index: content/browser/startup_task_runner_unittest.cc
diff --git a/content/browser/startup_task_runner_unittest.cc b/content/browser/startup_task_runner_unittest.cc
index 2ecf9ca63c58c4c32e3f780f607d552e53768ab8..ebc6642a10cd3b92fb3bb8714546020a5e23eb32 100644
--- a/content/browser/startup_task_runner_unittest.cc
+++ b/content/browser/startup_task_runner_unittest.cc
@@ -21,19 +21,11 @@ using base::Closure;
 using testing::_;
 using testing::Assign;
 using testing::Invoke;
-using testing::WithArg;
+using testing::Return;
 
 int observer_calls = 0;
 int task_count = 0;
 int observer_result;
-base::Closure task;
-
-// I couldn't get gMock's SaveArg to compile, hence had to save the argument
-// this way
-bool SaveTaskArg(const Closure& arg) {
-  task = arg;
-  return true;
-}
 
 void Observer(int result) {
   observer_calls++;
@@ -84,12 +76,8 @@ class StartupTaskRunnerTest : public testing::Test {
 
 class MockTaskRunner {
  public:
-  MOCK_METHOD3(
-      PostDelayedTask,
-      bool(const tracked_objects::Location&, const Closure&, base::TimeDelta));
-  MOCK_METHOD3(
-      PostNonNestableDelayedTask,
-      bool(const tracked_objects::Location&, const Closure&, base::TimeDelta));
+  MOCK_METHOD0(PostDelayedTask, bool());
+  MOCK_METHOD1(PostNonNestableDelayedTask, bool(base::TimeDelta));
 };
 
 class TaskRunnerProxy : public base::SingleThreadTaskRunner {
@@ -97,17 +85,22 @@ class TaskRunnerProxy : public base::SingleThreadTaskRunner {
   TaskRunnerProxy(MockTaskRunner* mock) : mock_(mock) {}
   bool RunsTasksOnCurrentThread() const override { return true; }
   bool PostDelayedTask(const tracked_objects::Location& location,
-                       const Closure& closure,
+                       base::OnceClosure closure,
                        base::TimeDelta delta) override {
-    return mock_->PostDelayedTask(location, closure, delta);
+    task_ = std::move(closure);
+    return mock_->PostDelayedTask();
   }
   bool PostNonNestableDelayedTask(const tracked_objects::Location& location,
-                                  const Closure& closure,
+                                  base::OnceClosure closure,
                                   base::TimeDelta delta) override {
-    return mock_->PostNonNestableDelayedTask(location, closure, delta);
+    task_ = std::move(closure);
+    return mock_->PostNonNestableDelayedTask(delta);
   }
 
+  base::OnceClosure TakeTask() { return std::move(task_); }
+
  private:
+  base::OnceClosure task_;
   MockTaskRunner* mock_;
   ~TaskRunnerProxy() override {}
 };
@@ -116,8 +109,8 @@ TEST_F(StartupTaskRunnerTest, SynchronousExecution) {
   MockTaskRunner mock_runner;
   scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner);
 
-  EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0);
-  EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_, _, _)).Times(0);
+  EXPECT_CALL(mock_runner, PostDelayedTask()).Times(0);
+  EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_)).Times(0);
 
   StartupTaskRunner runner(base::Bind(&Observer), proxy);
 
@@ -154,8 +147,8 @@ TEST_F(StartupTaskRunnerTest, NullObserver) {
   MockTaskRunner mock_runner;
   scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner);
 
-  EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0);
-  EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_, _, _)).Times(0);
+  EXPECT_CALL(mock_runner, PostDelayedTask()).Times(0);
+  EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_)).Times(0);
 
   StartupTaskRunner runner(base::Callback<void(int)>(), proxy);
 
@@ -189,8 +182,8 @@ TEST_F(StartupTaskRunnerTest, SynchronousExecutionFailedTask) {
   MockTaskRunner mock_runner;
   scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner);
 
-  EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0);
-  EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_, _, _)).Times(0);
+  EXPECT_CALL(mock_runner, PostDelayedTask()).Times(0);
+  EXPECT_CALL(mock_runner, PostNonNestableDelayedTask(_)).Times(0);
 
   StartupTaskRunner runner(base::Bind(&Observer), proxy);
 
@@ -227,12 +220,11 @@ TEST_F(StartupTaskRunnerTest, AsynchronousExecution) {
   MockTaskRunner mock_runner;
   scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner);
 
-  EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0);
-  EXPECT_CALL(
-      mock_runner,
-      PostNonNestableDelayedTask(_, _, base::TimeDelta::FromMilliseconds(0)))
+  EXPECT_CALL(mock_runner, PostDelayedTask()).Times(0);
+  EXPECT_CALL(mock_runner,
+              PostNonNestableDelayedTask(base::TimeDelta::FromMilliseconds(0)))
       .Times(testing::Between(2, 3))
-      .WillRepeatedly(WithArg<1>(Invoke(SaveTaskArg)));
+      .WillRepeatedly(Return(true));
 
   StartupTaskRunner runner(base::Bind(&Observer), proxy);
 
@@ -255,7 +247,7 @@ TEST_F(StartupTaskRunnerTest, AsynchronousExecution) {
   // at most 3 times (once for each task plus possibly once for the observer),
   // the "4" is a backstop.
   for (int i = 0; i < 4 && observer_calls == 0; i++) {
-    task.Run();
+    proxy->TakeTask().Run();
     EXPECT_EQ(i + 1, GetLastTask());
   }
   EXPECT_EQ(task_count, 2);
@@ -274,12 +266,11 @@ TEST_F(StartupTaskRunnerTest, AsynchronousExecutionFailedTask) {
   MockTaskRunner mock_runner;
   scoped_refptr<TaskRunnerProxy> proxy = new TaskRunnerProxy(&mock_runner);
 
-  EXPECT_CALL(mock_runner, PostDelayedTask(_, _, _)).Times(0);
-  EXPECT_CALL(
-      mock_runner,
-      PostNonNestableDelayedTask(_, _, base::TimeDelta::FromMilliseconds(0)))
+  EXPECT_CALL(mock_runner, PostDelayedTask()).Times(0);
+  EXPECT_CALL(mock_runner,
+              PostNonNestableDelayedTask(base::TimeDelta::FromMilliseconds(0)))
       .Times(testing::Between(1, 2))
-      .WillRepeatedly(WithArg<1>(Invoke(SaveTaskArg)));
+      .WillRepeatedly(Return(true));
 
   StartupTaskRunner runner(base::Bind(&Observer), proxy);
 
@@ -302,7 +293,7 @@ TEST_F(StartupTaskRunnerTest, AsynchronousExecutionFailedTask) {
   // at most twice (once for the failed task plus possibly once for the
   // observer), the "4" is a backstop.
   for (int i = 0; i < 4 && observer_calls == 0; i++) {
-    task.Run();
+    proxy->TakeTask().Run();
   }
   EXPECT_EQ(GetLastTask(), 3);
   EXPECT_EQ(task_count, 1);