Disallow posting tasks to SequencedWorkerPools by default.

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 41 matching lines @@
 //   pool.PostSequencedWorkerTask(token, SequencedWorkerPool::SKIP_ON_SHUTDOWN,
 //                                FROM_HERE, base::Bind(...));
 //
 // You can make named sequence tokens to make it easier to share a token
 // across different components.
 //
 // You can also post tasks to the pool without ordering using PostWorkerTask.
 // These will be executed in an unspecified order. The order of execution
 // between tasks with different sequence tokens is also unspecified.
 //
+// You must call EnableForProcess() or
+// EnableWithRedirectionToTaskSchedulerForProcess() before starting to post
+// tasks to a process' SequencedWorkerPools.
+//
 // This class may be leaked on shutdown to facilitate fast shutdown. The
 // expected usage, however, is to call Shutdown(), which correctly accounts
 // for CONTINUE_ON_SHUTDOWN behavior and is required for BLOCK_SHUTDOWN
 // behavior.
 //
 // Implementation note: This does not use a base::WorkerPool since that does
 // not enforce shutdown semantics or allow us to specify how many worker
 // threads to run. For the typical use case of random background work, we don't
 // necessarily want to be super aggressive about creating threads.
 //
@@ skipping 99 matching lines @@
   // DEPRECATED. Use SequencedTaskRunnerHandle::Get() instead. Consequentially
   // the only remaining use case is in sequenced_task_runner_handle.cc to
   // implement that and will soon be removed along with SequencedWorkerPool:
   // http://crbug.com/622400.
   static scoped_refptr<SequencedWorkerPool> GetWorkerPoolForCurrentThread();
 
   // Returns a unique token that can be used to sequence tasks posted to
   // PostSequencedWorkerTask(). Valid tokens are always nonzero.
   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.
+  // Enables posting tasks to this process' SequencedWorkerPools. Cannot be
+  // called if already enabled. This is not thread-safe; proper synchronization
+  // is required to use any SequencedWorkerPool method after calling this.
+  static void EnableForProcess();
+
+  // Same as EnableForProcess(), but tasks are redirected to the registered
+  // TaskScheduler. There must be a registered TaskScheduler when this is
+  // called.
   // TODO(gab): Remove this if http://crbug.com/622400 fails
   // (SequencedWorkerPool will be phased out completely otherwise).
-  static void RedirectToTaskSchedulerForProcess();
+  static void EnableWithRedirectionToTaskSchedulerForProcess();
 
-  // 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();
+  // Disables posting tasks to this process' SequencedWorkerPools. 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 DisableForProcessForTesting();
+
+  // Returns true if posting tasks to this process' SequencedWorkerPool is
+  // enabled (with or without redirection to TaskScheduler).
+  static bool IsEnabled();
 
   // When constructing a SequencedWorkerPool, there must be a
   // ThreadTaskRunnerHandle on the current thread unless you plan to
   // deliberately leak it.
 
   // 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
@@ skipping 191 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_