Revert of 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();
 
-  // 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.
+  // 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.
   // TODO(gab): Remove this if http://crbug.com/622400 fails
   // (SequencedWorkerPool will be phased out completely otherwise).
-  static void EnableWithRedirectionToTaskSchedulerForProcess();
+  static void RedirectToTaskSchedulerForProcess();
 
-  // 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();
+  // 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.
 
   // 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_