Flush SequenceWorkerPool tasks after each unit test.

base/threading/sequenced_worker_pool_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 "base/threading/sequenced_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 81 matching lines @@
     {
       base::AutoLock lock(lock_);
       started_events_++;
     }
     cond_var_.Signal();
 
     blocker->Block();
     SignalWorkerDone(id);
   }
 
-  void PostAdditionalTasks(int id, SequencedWorkerPool* pool) {
+  void PostAdditionalTasks(
+        int id, SequencedWorkerPool* pool,
+        bool expected_return_value) {
     Closure fast_task = base::Bind(&TestTracker::FastTask, this, 100);
-    EXPECT_FALSE(
-        pool->PostWorkerTaskWithShutdownBehavior(
-            FROM_HERE, fast_task,
-            SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
-    EXPECT_FALSE(
-        pool->PostWorkerTaskWithShutdownBehavior(
-            FROM_HERE, fast_task,
-            SequencedWorkerPool::SKIP_ON_SHUTDOWN));
+    EXPECT_EQ(expected_return_value,
+              pool->PostWorkerTaskWithShutdownBehavior(
+                  FROM_HERE, fast_task,
+                  SequencedWorkerPool::CONTINUE_ON_SHUTDOWN));
+    EXPECT_EQ(expected_return_value,
+              pool->PostWorkerTaskWithShutdownBehavior(
+                  FROM_HERE, fast_task,
+                  SequencedWorkerPool::SKIP_ON_SHUTDOWN));
     pool->PostWorkerTaskWithShutdownBehavior(
         FROM_HERE, fast_task,
         SequencedWorkerPool::BLOCK_SHUTDOWN);
     SignalWorkerDone(id);
   }
 
   // Waits until the given number of tasks have started executing.
   void WaitUntilTasksBlocked(size_t count) {
     {
       base::AutoLock lock(lock_);
@@ skipping 10 matching lines @@
     {
       base::AutoLock lock(lock_);
       while (complete_sequence_.size() < num_tasks)
         cond_var_.Wait();
       ret = complete_sequence_;
     }
     cond_var_.Signal();
     return ret;
   }
 
+  size_t GetTasksCompletedCount() {
+    base::AutoLock lock(lock_);
+    return complete_sequence_.size();
+  }
+
   void ClearCompleteSequence() {
     base::AutoLock lock(lock_);
     complete_sequence_.clear();
     started_events_ = 0;
   }
 
  private:
   friend class base::RefCountedThreadSafe<TestTracker>;
   ~TestTracker() {}
 
@@ skipping 358 matching lines @@
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
   // Queue up shutdown blocking tasks behind those which will attempt to post
   // additional tasks when run, PostAdditionalTasks attemtps to post 3
   // new FastTasks, one for each shutdown_behavior.
   const int kNumQueuedTasks = static_cast<int>(kNumWorkerThreads);
   for (int i = 0; i < kNumQueuedTasks; ++i) {
     EXPECT_TRUE(pool()->PostWorkerTaskWithShutdownBehavior(
         FROM_HERE,
-        base::Bind(&TestTracker::PostAdditionalTasks, tracker(), i, pool()),
+        base::Bind(&TestTracker::PostAdditionalTasks, tracker(), i, pool(),
+                   false),
         SequencedWorkerPool::BLOCK_SHUTDOWN));
   }
 
   // Setup to open the floodgates from within Shutdown().
   SetWillWaitForShutdownCallback(
       base::Bind(&EnsureTasksToCompleteCountAndUnblock,
                  scoped_refptr<TestTracker>(tracker()),
                  0, &blocker, kNumBlockTasks));
 
   // Allow half of the additional blocking tasks thru.
@@ skipping 211 matching lines @@
       base::Bind(&IsRunningOnCurrentThreadTask,
                  token2, unsequenced_token, pool(), unused_pool));
   pool()->PostWorkerTask(
       FROM_HERE,
       base::Bind(&IsRunningOnCurrentThreadTask,
                  unsequenced_token, token1, pool(), unused_pool));
   pool()->Shutdown();
   unused_pool->Shutdown();
 }
 
+// Verify that FlushForTesting works as intended.
+TEST_F(SequencedWorkerPoolTest, FlushForTesting) {
+  // Should be fine to call on a new instance.
+  pool()->FlushForTesting();
+
+  // Queue up a bunch of work, including  a long delayed task and
+  // a task that produces additional tasks as an artifact.
+  pool()->PostDelayedWorkerTask(
+      FROM_HERE,
+      base::Bind(&TestTracker::FastTask, tracker(), 0),
+      TimeDelta::FromMinutes(5));
+  pool()->PostWorkerTask(FROM_HERE,
+                         base::Bind(&TestTracker::SlowTask, tracker(), 0));
+  const size_t kNumFastTasks = 20;
+  for (size_t i = 0; i < kNumFastTasks; i++) {
+    pool()->PostWorkerTask(FROM_HERE,
+                           base::Bind(&TestTracker::FastTask, tracker(), 0));
+  }
+  pool()->PostWorkerTask(
+      FROM_HERE,
+      base::Bind(&TestTracker::PostAdditionalTasks, tracker(), 0, pool(),
+                 true));
+
+  // We expect all except the delayed task to have been run. We verify all
+  // closures have been deleted deleted by looking at the refcount of the
+  // tracker.
+  EXPECT_FALSE(tracker()->HasOneRef());
+  pool()->FlushForTesting();
+  EXPECT_TRUE(tracker()->HasOneRef());
+  EXPECT_EQ(1 + kNumFastTasks + 1 + 3, tracker()->GetTasksCompletedCount());
+
+  // Should be fine to call on an idle instance with all threads created, and
+  // spamming the method shouldn't deadlock or confuse the class.
+  pool()->FlushForTesting();
+  pool()->FlushForTesting();
+
+  // Should be fine to call after shutdown too.
+  pool()->Shutdown();
+  pool()->FlushForTesting();
+}
+
 class SequencedWorkerPoolTaskRunnerTestDelegate {
  public:
   SequencedWorkerPoolTaskRunnerTestDelegate() {}
 
   ~SequencedWorkerPoolTaskRunnerTestDelegate() {}
 
   void StartTaskRunner() {
     pool_owner_.reset(
         new SequencedWorkerPoolOwner(10, "SequencedWorkerPoolTaskRunnerTest"));
   }
 
   scoped_refptr<SequencedWorkerPool> GetTaskRunner() {
     return pool_owner_->pool();
   }
 
   void StopTaskRunner() {
-    // Make sure all tasks (including delayed ones) are run before shutting
-    // down.
+    // Make sure all tasks are run before shutting down. Delayed tasks are
+    // not run, they're simply deleted.
     pool_owner_->pool()->FlushForTesting();
     pool_owner_->pool()->Shutdown();
     // Don't reset |pool_owner_| here, as the test may still hold a
     // reference to the pool.
   }
 
   bool TaskRunnerHandlesNonZeroDelays() const {
     return true;
   }
 
@@ skipping 18 matching lines @@
         new SequencedWorkerPoolOwner(10, "SequencedWorkerPoolTaskRunnerTest"));
     task_runner_ = pool_owner_->pool()->GetTaskRunnerWithShutdownBehavior(
         SequencedWorkerPool::BLOCK_SHUTDOWN);
   }
 
   scoped_refptr<TaskRunner> GetTaskRunner() {
     return task_runner_;
   }
 
   void StopTaskRunner() {
-    // Make sure all tasks (including delayed ones) are run before shutting
-    // down.
+    // Make sure all tasks are run before shutting down. Delayed tasks are
+    // not run, they're simply deleted.
     pool_owner_->pool()->FlushForTesting();
     pool_owner_->pool()->Shutdown();
     // Don't reset |pool_owner_| here, as the test may still hold a
     // reference to the pool.
   }
 
   bool TaskRunnerHandlesNonZeroDelays() const {
     return true;
   }
 
@@ skipping 19 matching lines @@
         10, "SequencedWorkerPoolSequencedTaskRunnerTest"));
     task_runner_ = pool_owner_->pool()->GetSequencedTaskRunner(
         pool_owner_->pool()->GetSequenceToken());
   }
 
   scoped_refptr<SequencedTaskRunner> GetTaskRunner() {
     return task_runner_;
   }
 
   void StopTaskRunner() {
-    // Make sure all tasks (including delayed ones) are run before shutting
-    // down.
+    // Make sure all tasks are run before shutting down. Delayed tasks are
+    // not run, they're simply deleted.
     pool_owner_->pool()->FlushForTesting();
     pool_owner_->pool()->Shutdown();
     // Don't reset |pool_owner_| here, as the test may still hold a
     // reference to the pool.
   }
 
   bool TaskRunnerHandlesNonZeroDelays() const {
     return true;
   }
 
  private:
   MessageLoop message_loop_;
   scoped_ptr<SequencedWorkerPoolOwner> pool_owner_;
   scoped_refptr<SequencedTaskRunner> task_runner_;
 };
 
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner, TaskRunnerTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner, SequencedTaskRunnerTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 
 }  // namespace
 
 }  // namespace base