Disallow single-threaded SequencedWorkerPools.

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 <stdint.h>
 
 #include <list>
 #include <map>
@@ skipping 634 matching lines @@
       blocking_shutdown_thread_count_(0),
       next_sequence_task_number_(0),
       blocking_shutdown_pending_task_count_(0),
       trace_id_(0),
       shutdown_called_(false),
       max_blocking_tasks_after_shutdown_(0),
       cleanup_state_(CLEANUP_DONE),
       cleanup_idlers_(0),
       cleanup_cv_(&lock_),
       testing_observer_(observer),
-      task_priority_(task_priority) {}
+      task_priority_(task_priority) {
+  DCHECK_GT(max_threads_, 1U);
+}
 
 SequencedWorkerPool::Inner::~Inner() {
   // You must call Shutdown() before destroying the pool.
   DCHECK(shutdown_called_);
 
   // Need to explicitly join with the threads before they're destroyed or else
   // they will be running when our object is half torn down.
   for (ThreadMap::iterator it = threads_.begin(); it != threads_.end(); ++it)
     it->second->Join();
   threads_.clear();
@@ skipping 175 matching lines @@
       sequence_token_id ? sequenced_task_runner_map_[sequence_token_id]
                         : unsequenced_task_runners_[static_cast<int>(
                               traits.shutdown_behavior())];
 
   // TODO(fdoray): DCHECK that all tasks posted to the same sequence have the
   // same shutdown behavior.
 
   if (!task_runner) {
     ExecutionMode execution_mode =
         sequence_token_id ? ExecutionMode::SEQUENCED : ExecutionMode::PARALLEL;
-
-    if (max_threads_ == 1U) {
-      // Tasks posted to single-threaded pools can assume thread affinity.
-      execution_mode = ExecutionMode::SINGLE_THREADED;
-
-      // Disallow posting tasks with different sequence tokens to single-
-      // threaded pools since the TaskScheduler can't force different sequences
-      // to run on the same thread.
-      DCHECK_LE(sequenced_task_runner_map_.size(), 1U);
-
-      // Disallow posting tasks without a sequence token to a single-threaded
-      // pool. No users do that currently and we don't want to support new use
-      // cases.
-      DCHECK(sequence_token_id);
-    }
-
     task_runner = CreateTaskRunnerWithTraits(traits, execution_mode);
   }
 
   return task_runner;
 }
 
 bool SequencedWorkerPool::Inner::RunsTasksOnCurrentThread() const {
   AutoLock lock(lock_);
   if (subtle::NoBarrier_Load(&g_all_pools_state) ==
       AllPoolsState::REDIRECTED_TO_TASK_SCHEDULER) {
@@ skipping 750 matching lines @@
 bool SequencedWorkerPool::IsShutdownInProgress() {
   return inner_->IsShutdownInProgress();
 }
 
 bool SequencedWorkerPool::IsRunningSequenceOnCurrentThread(
     SequenceToken sequence_token) const {
   return inner_->IsRunningSequenceOnCurrentThread(sequence_token);
 }
 
 }  // namespace base