SharedWorkerPool.Shutdown(int max_new_blocking_tasks)

BUG=158934,163096

Review URL: https://chromiumcodereview.appspot.com/11415246

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@173829 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 65 insertions, 4 deletions

diff --git a/base/threading/sequenced_worker_pool_unittest.cc b/base/threading/sequenced_worker_pool_unittest.cc
index 2dcda60..79f08c8 100644
--- a/base/threading/sequenced_worker_pool_unittest.cc
+++ b/base/threading/sequenced_worker_pool_unittest.cc
@@ -97,6 +97,22 @@ class TestTracker : public base::RefCountedThreadSafe<TestTracker> {
     SignalWorkerDone(id);
   }
 
+  void PostAdditionalTasks(int id, SequencedWorkerPool* pool) {
+    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));
+    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) {
     {
@@ -377,20 +393,21 @@ TEST_F(SequencedWorkerPoolTest, IgnoresAfterShutdown) {
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
-  // Shutdown the worker pool. This should discard all non-blocking tasks.
   SetWillWaitForShutdownCallback(
       base::Bind(&EnsureTasksToCompleteCountAndUnblock,
                  scoped_refptr<TestTracker>(tracker()), 0,
                  &blocker, kNumWorkerThreads));
-  pool()->Shutdown();
+
+  // Shutdown the worker pool. This should discard all non-blocking tasks.
+  const int kMaxNewBlockingTasksAfterShutdown = 100;
+  pool()->Shutdown(kMaxNewBlockingTasksAfterShutdown);
 
   int old_has_work_call_count = has_work_call_count();
 
   std::vector<int> result =
       tracker()->WaitUntilTasksComplete(kNumWorkerThreads);
 
-  // The kNumWorkerThread items should have completed, in no particular
-  // order.
+  // The kNumWorkerThread items should have completed, in no particular order.
   ASSERT_EQ(kNumWorkerThreads, result.size());
   for (size_t i = 0; i < kNumWorkerThreads; i++) {
     EXPECT_TRUE(std::find(result.begin(), result.end(), static_cast<int>(i)) !=
@@ -414,6 +431,50 @@ TEST_F(SequencedWorkerPoolTest, IgnoresAfterShutdown) {
   ASSERT_EQ(old_has_work_call_count, has_work_call_count());
 }
 
+TEST_F(SequencedWorkerPoolTest, AllowsAfterShutdown) {
+  // Test that <n> new blocking tasks are allowed provided they're posted
+  // by a running tasks.
+  EnsureAllWorkersCreated();
+  ThreadBlocker blocker;
+
+  // Start tasks to take all the threads and block them.
+  const int kNumBlockTasks = static_cast<int>(kNumWorkerThreads);
+  for (int i = 0; i < kNumBlockTasks; ++i) {
+    EXPECT_TRUE(pool()->PostWorkerTask(
+        FROM_HERE,
+        base::Bind(&TestTracker::BlockTask, tracker(), i, &blocker)));
+  }
+  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()),
+        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.
+  const int kNumNewBlockingTasksToAllow = kNumWorkerThreads / 2;
+  pool()->Shutdown(kNumNewBlockingTasksToAllow);
+
+  // Ensure that the correct number of tasks actually got run.
+  tracker()->WaitUntilTasksComplete(static_cast<size_t>(
+      kNumBlockTasks + kNumQueuedTasks + kNumNewBlockingTasksToAllow));
+
+  // Clean up the task IDs we added and go home.
+  tracker()->ClearCompleteSequence();
+}
+
 // Tests that unrun tasks are discarded properly according to their shutdown
 // mode.
 TEST_F(SequencedWorkerPoolTest, DiscardOnShutdown) {