Ensure SequencedWorkerPool::Shutdown() blocks for already-started SKIP_ON_SHUTDOWN tasks

base/threading/sequenced_worker_pool.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 <list>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 355 matching lines @@
 
   // Set to true when we're in the process of creating another thread.
   // See PrepareToStartAdditionalThreadIfHelpful for more.
   bool thread_being_created_;
 
   // Number of threads currently waiting for work.
   size_t waiting_thread_count_;
 
   // Number of threads currently running tasks that have the BLOCK_SHUTDOWN
   // flag set.
   size_t blocking_shutdown_thread_count_;

[jar (doing other things), 2012/07/20 01:46:33]

nit: You need to correct the comment.

Suggest:

"... that have the BLOCK_SHUTDOWN or SKIP_ON_SHUTDOWN flag set."

 
   // In-order list of all pending tasks. These are tasks waiting for a thread
   // to run on or that are blocked on a previous task in their sequence.
   //
   // We maintain the pending_task_count_ separately for metrics because
   // list.size() can be linear time.
   std::list<SequencedTask> pending_tasks_;
   size_t pending_task_count_;
 
   // Number of tasks in the pending_tasks_ list that are marked as blocking
@@ skipping 365 matching lines @@
   return found_task;
 }
 
 int SequencedWorkerPool::Inner::WillRunWorkerTask(const SequencedTask& task) {
   lock_.AssertAcquired();
 
   // Mark the task's sequence number as in use.
   if (task.sequence_token_id)
     current_sequences_.insert(task.sequence_token_id);
 
-  if (task.shutdown_behavior == BLOCK_SHUTDOWN)
+  // Ensure that threads running tasks posted with either SKIP_ON_SHUTDOWN
+  // or BLOCK_SHUTDOWN will prevent shutdown until that task or thread
+  // completes.
+  if (task.shutdown_behavior != CONTINUE_ON_SHUTDOWN)
     blocking_shutdown_thread_count_++;
 
   // We just picked up a task. Since StartAdditionalThreadIfHelpful only
   // creates a new thread if there is no free one, there is a race when posting
   // tasks that many tasks could have been posted before a thread started
   // running them, so only one thread would have been created. So we also check
   // whether we should create more threads after removing our task from the
   // queue, which also has the nice side effect of creating the workers from
   // background threads rather than the main thread of the app.
   //
   // If another thread wasn't created, we want to wake up an existing thread
   // if there is one waiting to pick up the next task.
   //
   // Note that we really need to do this *before* running the task, not
   // after. Otherwise, if more than one task is posted, the creation of the
   // second thread (since we only create one at a time) will be blocked by
   // the execution of the first task, which could be arbitrarily long.
   return PrepareToStartAdditionalThreadIfHelpful();
 }
 
 void SequencedWorkerPool::Inner::DidRunWorkerTask(const SequencedTask& task) {
   lock_.AssertAcquired();
 
-  if (task.shutdown_behavior == BLOCK_SHUTDOWN) {
+  if (task.shutdown_behavior != CONTINUE_ON_SHUTDOWN) {
     DCHECK_GT(blocking_shutdown_thread_count_, 0u);
     blocking_shutdown_thread_count_--;
   }
 
   if (task.sequence_token_id)
     current_sequences_.erase(task.sequence_token_id);
 }
 
 bool SequencedWorkerPool::Inner::IsSequenceTokenRunnable(
     int sequence_token_id) const {
@@ skipping 201 matching lines @@
 void SequencedWorkerPool::SignalHasWorkForTesting() {
   inner_->SignalHasWorkForTesting();
 }
 
 void SequencedWorkerPool::Shutdown() {
   DCHECK(constructor_message_loop_->BelongsToCurrentThread());
   inner_->Shutdown();
 }
 
 }  // namespace base