TaskScheduler: Add FlushForTesting().

base/task_scheduler/task_tracker_unittest.cc

 // Copyright 2016 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/task_scheduler/task_tracker.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequence_token.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
+#include "base/synchronization/atomic_flag.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_scheduler/scheduler_lock.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/test/gtest_util.h"
 #include "base/test/test_simple_task_runner.h"
+#include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 
 namespace {
 
 constexpr size_t kLoadTestNumIterations = 100;
 
-// Calls TaskTracker::Shutdown() asynchronously.
-class ThreadCallingShutdown : public SimpleThread {
+// Invokes a closure asynchronously.
+class CallbackThread : public SimpleThread {
  public:
-  explicit ThreadCallingShutdown(TaskTracker* tracker)
-      : SimpleThread("ThreadCallingShutdown"),
-        tracker_(tracker),
-        has_returned_(WaitableEvent::ResetPolicy::MANUAL,
-                      WaitableEvent::InitialState::NOT_SIGNALED) {}
+  explicit CallbackThread(const Closure& closure)
+      : SimpleThread("CallbackThread"), closure_(closure) {}
 
   // Returns true once the async call to Shutdown() has returned.
-  bool has_returned() { return has_returned_.IsSignaled(); }
+  bool has_returned() { return has_returned_.IsSet(); }
 
  private:
   void Run() override {
-    tracker_->Shutdown();
-    has_returned_.Signal();
+    closure_.Run();
+    has_returned_.Set();
   }
 
-  TaskTracker* const tracker_;
-  WaitableEvent has_returned_;
+  const Closure closure_;
+  AtomicFlag has_returned_;
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadCallingShutdown);
+  DISALLOW_COPY_AND_ASSIGN(CallbackThread);
 };
 
 class ThreadPostingAndRunningTask : public SimpleThread {
  public:
   enum class Action {
     WILL_POST,
     RUN,
     WILL_POST_AND_RUN,
   };
 
@@ skipping 52 matching lines @@
         FROM_HERE,
         Bind(&TaskSchedulerTaskTrackerTest::RunTaskCallback, Unretained(this)),
         TaskTraits().WithShutdownBehavior(shutdown_behavior), TimeDelta());
   }
 
   // Calls tracker_->Shutdown() on a new thread. When this returns, Shutdown()
   // method has been entered on the new thread, but it hasn't necessarily
   // returned.
   void CallShutdownAsync() {
     ASSERT_FALSE(thread_calling_shutdown_);
-    thread_calling_shutdown_.reset(new ThreadCallingShutdown(&tracker_));
+    thread_calling_shutdown_.reset(new CallbackThread(
+        Bind(&TaskTracker::Shutdown, Unretained(&tracker_))));
     thread_calling_shutdown_->Start();
     while (!tracker_.HasShutdownStarted())
       PlatformThread::YieldCurrentThread();
   }
 
   void WaitForAsyncIsShutdownComplete() {
     ASSERT_TRUE(thread_calling_shutdown_);
     thread_calling_shutdown_->Join();
     EXPECT_TRUE(thread_calling_shutdown_->has_returned());
     EXPECT_TRUE(tracker_.IsShutdownComplete());
   }
 
   void VerifyAsyncShutdownInProgress() {
     ASSERT_TRUE(thread_calling_shutdown_);
     EXPECT_FALSE(thread_calling_shutdown_->has_returned());
     EXPECT_TRUE(tracker_.HasShutdownStarted());
     EXPECT_FALSE(tracker_.IsShutdownComplete());
   }
 
+  // Calls tracker_->FlushForTesting() on a new thread.
+  void CallFlushForTestingAsync() {
+    ASSERT_FALSE(thread_calling_flush_for_testing_);
+    thread_calling_flush_for_testing_.reset(new CallbackThread(
+        Bind(&TaskTracker::FlushForTesting, Unretained(&tracker_))));
+    thread_calling_flush_for_testing_->Start();
+  }
+
+  void WaitForAsyncFlushForTestingReturned() {
+    ASSERT_TRUE(thread_calling_flush_for_testing_);
+    thread_calling_flush_for_testing_->Join();
+    EXPECT_TRUE(thread_calling_flush_for_testing_->has_returned());
+  }
+
+  void VerifyAsyncFlushForTestingInProgress() {
+    ASSERT_TRUE(thread_calling_flush_for_testing_);
+    EXPECT_FALSE(thread_calling_flush_for_testing_->has_returned());
+  }
+
   size_t NumTasksExecuted() {
     AutoSchedulerLock auto_lock(lock_);
     return num_tasks_executed_;
   }
 
   TaskTracker tracker_;
 
  private:
   void RunTaskCallback() {
     AutoSchedulerLock auto_lock(lock_);
     ++num_tasks_executed_;
   }
 
-  std::unique_ptr<ThreadCallingShutdown> thread_calling_shutdown_;
+  std::unique_ptr<CallbackThread> thread_calling_shutdown_;
+  std::unique_ptr<CallbackThread> thread_calling_flush_for_testing_;
 
   // Synchronizes accesses to |num_tasks_executed_|.
   SchedulerLock lock_;
 
   size_t num_tasks_executed_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerTaskTrackerTest);
 };
 
 #define WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED() \
   do {                                      \
     SCOPED_TRACE("");                       \
     WaitForAsyncIsShutdownComplete();       \
   } while (false)
 
 #define VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS() \
   do {                                      \
     SCOPED_TRACE("");                       \
     VerifyAsyncShutdownInProgress();        \
   } while (false)
 
+#define WAIT_FOR_ASYNC_FLUSH_FOR_TESTING_RETURNED() \
+  do {                                              \
+    SCOPED_TRACE("");                               \
+    WaitForAsyncFlushForTestingReturned();          \
+  } while (false)
+
+#define VERIFY_ASYNC_FLUSH_FOR_TESTING_IN_PROGRESS() \
+  do {                                               \
+    SCOPED_TRACE("");                                \
+    VerifyAsyncFlushForTestingInProgress();          \
+  } while (false)
+
 }  // namespace
 
 TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunBeforeShutdown) {
   std::unique_ptr<Task> task(CreateTask(GetParam()));
 
   // Inform |task_tracker_| that |task| will be posted.
   EXPECT_TRUE(tracker_.WillPostTask(task.get()));
 
   // Run the task.
   EXPECT_EQ(0U, NumTasksExecuted());
@@ skipping 249 matching lines @@
   // being set on it.
   std::unique_ptr<Task> verify_task(
       new Task(FROM_HERE, Bind(&VerifyThreadTaskRunnerHandle,
                                base::Unretained(test_task_runner.get())),
                TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta()));
   verify_task->single_thread_task_runner_ref = test_task_runner;
 
   RunTaskRunnerHandleVerificationTask(&tracker_, std::move(verify_task));
 }
 
+TEST_P(TaskSchedulerTaskTrackerTest, FlushForTestingDelayedTask) {
+  const Task delayed_task(FROM_HERE, Bind(&DoNothing),
+                          TaskTraits().WithShutdownBehavior(GetParam()),
+                          TimeDelta::FromSeconds(10));

[gab, 2016/09/23 15:39:18]

Make this minutes so that the test would timeout if the flush waits for it (10s
is still within the range where the test wouldn't timeout)

[fdoray, 2016/09/23 15:56:50]

Ok. But since I'm just testing TaskTracker (not the whole TaskScheduler), it is
already guaranteed that this test will timeout if the flush waits for the
delayed task (there isn't another thread that can call RunTask).

[gab, 2016/09/23 17:05:25]

Sure, but that makes it clear. Increasing readability for free is always a yes
to me :-)

+  tracker_.WillPostTask(&delayed_task);
+  // FlushForTesting() should return even if the delayed task didn't run.
+  tracker_.FlushForTesting();
+}
+
+TEST_P(TaskSchedulerTaskTrackerTest, FlushForTestingUndelayedTask) {
+  const Task undelayed_task(FROM_HERE, Bind(&DoNothing),
+                            TaskTraits().WithShutdownBehavior(GetParam()),
+                            TimeDelta());
+  tracker_.WillPostTask(&undelayed_task);
+
+  // FlushForTesting() shouldn't return before the undelayed task runs.
+  CallFlushForTestingAsync();
+  PlatformThread::Sleep(TestTimeouts::tiny_timeout());
+  VERIFY_ASYNC_FLUSH_FOR_TESTING_IN_PROGRESS();
+
+  // FlushForTesting() should return after the undelayed task runs.
+  tracker_.RunTask(&undelayed_task, SequenceToken::Create());
+  WAIT_FOR_ASYNC_FLUSH_FOR_TESTING_RETURNED();
+}
+
+TEST_P(TaskSchedulerTaskTrackerTest, FlushForTestingPostDuringCall) {
+  const Task undelayed_task(FROM_HERE, Bind(&DoNothing),
+                            TaskTraits().WithShutdownBehavior(GetParam()),
+                            TimeDelta());
+  tracker_.WillPostTask(&undelayed_task);
+
+  // FlushForTesting() shouldn't return before the undelayed task runs.
+  CallFlushForTestingAsync();
+  PlatformThread::Sleep(TestTimeouts::tiny_timeout());
+  VERIFY_ASYNC_FLUSH_FOR_TESTING_IN_PROGRESS();
+
+  // Simulate posting another undelayed task.
+  const Task other_undelayed_task(FROM_HERE, Bind(&DoNothing),
+                                  TaskTraits().WithShutdownBehavior(GetParam()),
+                                  TimeDelta());
+  tracker_.WillPostTask(&other_undelayed_task);
+
+  // Run the first undelayed task.
+  tracker_.RunTask(&undelayed_task, SequenceToken::Create());
+
+  // FlushForTesting() shouldn't return before the second undelayed task runs.
+  PlatformThread::Sleep(TestTimeouts::tiny_timeout());
+  VERIFY_ASYNC_FLUSH_FOR_TESTING_IN_PROGRESS();
+
+  // FlushForTesting() should return after the second undelayed task runs.
+  tracker_.RunTask(&other_undelayed_task, SequenceToken::Create());
+  WAIT_FOR_ASYNC_FLUSH_FOR_TESTING_RETURNED();
+}
+
+TEST_P(TaskSchedulerTaskTrackerTest, FlushForTestingAfterShutdown) {
+  if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN)
+    return;
+
+  // Simulate posting a task.
+  const Task undelayed_task(FROM_HERE, Bind(&DoNothing),
+                            TaskTraits().WithShutdownBehavior(GetParam()),
+                            TimeDelta());
+  tracker_.WillPostTask(&undelayed_task);
+
+  // Shutdown() should return immediately since there are no pending
+  // BLOCK_SHUTDOWN tasks.
+  tracker_.Shutdown();
+
+  // FlushForTesting() should return immediately after shutdown, even if an
+  // undelayed task hasn't run.
+  tracker_.FlushForTesting();
+}
+
+TEST_P(TaskSchedulerTaskTrackerTest, ShutdownDuringFlushForTesting) {
+  if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN)
+    return;
+
+  // Simulate posting a task.
+  const Task undelayed_task(FROM_HERE, Bind(&DoNothing),
+                            TaskTraits().WithShutdownBehavior(GetParam()),
+                            TimeDelta());
+  tracker_.WillPostTask(&undelayed_task);
+
+  // FlushForTesting() shouldn't return before the undelayed task runs or
+  // shutdown completes.
+  CallFlushForTestingAsync();
+  PlatformThread::Sleep(TestTimeouts::tiny_timeout());
+  VERIFY_ASYNC_FLUSH_FOR_TESTING_IN_PROGRESS();
+
+  // Shutdown() should return immediately since there are no pending
+  // BLOCK_SHUTDOWN tasks.
+  tracker_.Shutdown();
+
+  // FlushForTesting() should now return, even if an undelayed task hasn't run.
+  WAIT_FOR_ASYNC_FLUSH_FOR_TESTING_RETURNED();
+}
+
 INSTANTIATE_TEST_CASE_P(
     ContinueOnShutdown,
     TaskSchedulerTaskTrackerTest,
     ::testing::Values(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));
 INSTANTIATE_TEST_CASE_P(
     SkipOnShutdown,
     TaskSchedulerTaskTrackerTest,
     ::testing::Values(TaskShutdownBehavior::SKIP_ON_SHUTDOWN));
 INSTANTIATE_TEST_CASE_P(
     BlockShutdown,
@@ skipping 152 matching lines @@
 
   // Unblock shutdown by running |block_shutdown_task|.
   EXPECT_TRUE(
       tracker_.RunTask(block_shutdown_task.get(), SequenceToken::Create()));
   EXPECT_EQ(kLoadTestNumIterations + 1, NumTasksExecuted());
   WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 }
 
 }  // namespace internal
 }  // namespace base