Use OnceClosure in TestPendingTask

base/test/scoped_mock_time_message_loop_task_runner_unittest.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 "base/test/scoped_mock_time_message_loop_task_runner.h"
 
 #include <deque>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/test/test_pending_task.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace {
 
 TaskRunner* GetCurrentTaskRunner() {
   return MessageLoop::current()->task_runner().get();
 }
 
+void AssignTrue(bool* out) {
+  *out = true;
+}
+
 // Pops a task from the front of |pending_tasks| and returns it.
 TestPendingTask PopFront(std::deque<TestPendingTask>* pending_tasks) {
-  TestPendingTask task = pending_tasks->front();
+  TestPendingTask task = std::move(pending_tasks->front());
   pending_tasks->pop_front();
   return task;
 }
 
 class ScopedMockTimeMessageLoopTaskRunnerTest : public testing::Test {
  public:
   ScopedMockTimeMessageLoopTaskRunnerTest()
       : original_task_runner_(new TestMockTimeTaskRunner()) {
     MessageLoop::current()->SetTaskRunner(original_task_runner_);
   }
@@ skipping 20 matching lines @@
   EXPECT_EQ(scoped_task_runner_->task_runner(), GetCurrentTaskRunner());
   scoped_task_runner_.reset();
   EXPECT_EQ(original_task_runner(), GetCurrentTaskRunner());
 }
 
 TEST_F(ScopedMockTimeMessageLoopTaskRunnerTest,
        IncompleteTasksAreCopiedToPreviousTaskRunnerAfterDestruction) {
   auto scoped_task_runner_ =
       base::MakeUnique<ScopedMockTimeMessageLoopTaskRunner>();
 
+  bool task_10_has_run = false;
+  bool task_11_has_run = false;
+
   Closure task_1 = Bind(&DoNothing);
   Closure task_2 = Bind(&DoNothing);
-  Closure task_10 = Bind(&DoNothing);
-  Closure task_11 = Bind(&DoNothing);
+  Closure task_10 = Bind(&AssignTrue, &task_10_has_run);
+  Closure task_11 = Bind(&AssignTrue, &task_11_has_run);
 
   constexpr TimeDelta task_1_delay = TimeDelta::FromSeconds(1);
   constexpr TimeDelta task_2_delay = TimeDelta::FromSeconds(2);
   constexpr TimeDelta task_10_delay = TimeDelta::FromSeconds(10);
   constexpr TimeDelta task_11_delay = TimeDelta::FromSeconds(11);
 
   constexpr TimeDelta step_time_by = TimeDelta::FromSeconds(5);
 
   GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, task_1, task_1_delay);
   GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, task_2, task_2_delay);
   GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, task_10, task_10_delay);
   GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, task_11, task_11_delay);
 
   scoped_task_runner_->task_runner()->FastForwardBy(step_time_by);
 
   scoped_task_runner_.reset();
 
   std::deque<TestPendingTask> pending_tasks =
       original_task_runner()->TakePendingTasks();
 
   EXPECT_EQ(2U, pending_tasks.size());
 
   TestPendingTask pending_task = PopFront(&pending_tasks);
-  EXPECT_TRUE(task_10.Equals(pending_task.task));
+  EXPECT_FALSE(task_10_has_run);
+  std::move(pending_task.task).Run();
+  EXPECT_TRUE(task_10_has_run);
   EXPECT_EQ(task_10_delay - step_time_by, pending_task.delay);
 
   pending_task = PopFront(&pending_tasks);
-  EXPECT_TRUE(task_11.Equals(pending_task.task));
+  EXPECT_FALSE(task_11_has_run);
+  std::move(pending_task.task).Run();
+  EXPECT_TRUE(task_11_has_run);
   EXPECT_EQ(task_11_delay - step_time_by, pending_task.delay);
 }
 
 }  // namespace
 }  // namespace base