Disallow single-threaded SequencedWorkerPools.

base/threading/sequenced_worker_pool.h

 // 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.
 
 #ifndef BASE_THREADING_SEQUENCED_WORKER_POOL_H_
 #define BASE_THREADING_SEQUENCED_WORKER_POOL_H_
 
 #include <stddef.h>
 
 #include <cstddef>
@@ skipping 162 matching lines @@
   static SequenceToken GetSequenceToken();
 
   // Starts redirecting tasks posted to this process' SequencedWorkerPools to
   // the registered TaskScheduler. This cannot be called after a task has been
   // posted to a SequencedWorkerPool. This is not thread-safe; proper
   // synchronization is required to use any SequencedWorkerPool method after
   // calling this. There must be a registered TaskScheduler when this is called.
   // Ideally, call this on the main thread of a process, before any other
   // threads are created and before any tasks are posted to that process'
   // SequencedWorkerPools.
-  // Note: SequencedWorkerPool instances with |max_threads == 1| will be special
-  // cased to send all of their work as ExecutionMode::SINGLE_THREADED.
   // TODO(gab): Remove this if http://crbug.com/622400 fails
   // (SequencedWorkerPool will be phased out completely otherwise).
   static void RedirectToTaskSchedulerForProcess();
 
   // Stops redirecting tasks posted to this process' SequencedWorkerPools to the
   // registered TaskScheduler and allows RedirectToTaskSchedulerForProcess() to
   // be called even if tasks have already posted to a SequencedWorkerPool in
   // this process. Calling this while there are active SequencedWorkerPools is
   // not supported. This is not thread-safe; proper synchronization is required
   // to use any SequencedWorkerPool method after calling this.
   static void ResetRedirectToTaskSchedulerForProcessForTesting();
 
   // When constructing a SequencedWorkerPool, there must be a
   // ThreadTaskRunnerHandle on the current thread unless you plan to
   // deliberately leak it.
 
-  // Pass the maximum number of threads (they will be lazily created as needed)
-  // and a prefix for the thread name to aid in debugging. |task_priority| will
-  // be used to hint base::TaskScheduler for an experiment in which all
-  // SequencedWorkerPool tasks will be redirected to it in processes where a
-  // base::TaskScheduler was instantiated.
+  // Constructs a SequencedWorkerPool which will lazily create up to
+  // |max_threads| and a prefix for the thread name to aid in debugging.
+  // |max_threads| must be greater than 1. |task_priority| will be used to hint
+  // base::TaskScheduler for an experiment in which all SequencedWorkerPool
+  // tasks will be redirected to it in processes where a base::TaskScheduler was
+  // instantiated.
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix,
                       base::TaskPriority task_priority);
 
   // Like above, but with |observer| for testing.  Does not take ownership of
   // |observer|.
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix,
                       base::TaskPriority task_priority,
                       TestingObserver* observer);
@@ skipping 174 matching lines @@
   // Avoid pulling in too many headers by putting (almost) everything
   // into |inner_|.
   const std::unique_ptr<Inner> inner_;
 
   DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPool);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_SEQUENCED_WORKER_POOL_H_