Test SequencedWorkerPool with redirection to the TaskScheduler.

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 154 matching lines @@
   static SequenceToken GetSequenceTokenForCurrentThread();
 
   // Returns the SequencedWorkerPool that owns this thread, or null if the
   // current thread is not a SequencedWorkerPool worker thread.
   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();
 
-  // Invoke this once on the main thread of a process, before any other threads
-  // are created and before any tasks are posted to that process'
-  // SequencedWorkerPools but after TaskScheduler was instantiated, to force all
-  // SequencedWorkerPools in that process to redirect their tasks to the
-  // TaskScheduler. Note: SequencedWorkerPool instances with |max_threads == 1|
-  // will be special cased to send all of their work as
-  // ExecutionMode::SINGLE_THREADED.
+  // Invoke this to start 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 method of
+  // SequencedWorkerPool 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 RedirectSequencedWorkerPoolsToTaskSchedulerForProcess();
+  static void RedirectToTaskSchedulerForProcess();
+
+  // Stops redirecting tasks posted to this process' SequencedWorkerPools to the
+  // registered TaskScheduler. Also allows RedirectToTaskSchedulerForProcess()
+  // to be called again after tasks have been posted to this process'
+  // SequencedWorkerPools. Calling this while there are active
+  // SequencedWorkerPools isn't supported. This is not thread-safe; proper
+  // synchronization is required to call any method of SequencedWorkerPool 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.
@@ skipping 144 matching lines @@
   void FlushForTesting();
 
   // Spuriously signal that there is work to be done.
   void SignalHasWorkForTesting();
 
   // Implements the worker pool shutdown. This should be called during app
   // shutdown, and will discard/join with appropriate tasks before returning.
   // After this call, subsequent calls to post tasks will fail.
   //
   // Must be called from the same thread this object was constructed on.
+  //
+  // No-op when redirection to the TaskScheduler is enabled. You must shutdown
+  // the TaskScheduler to wait for SKIP_ON_SHUTDOWN tasks that were already
+  // running and for all BLOCK_SHUTDOWN tasks to complete their execution.
   void Shutdown() { Shutdown(0); }
 
   // A variant that allows an arbitrary number of new blocking tasks to be
   // posted during shutdown. The tasks cannot be posted within the execution
   // context of tasks whose shutdown behavior is not BLOCKING_SHUTDOWN. Once
   // the limit is reached, subsequent calls to post task fail in all cases.
   // Must be called from the same thread this object was constructed on.
+  //
+  // No-op when redirection to the TaskScheduler is enabled. You must shutdown
+  // the TaskScheduler to wait for SKIP_ON_SHUTDOWN tasks that were already
+  // running and for all BLOCK_SHUTDOWN tasks to complete their execution.
   void Shutdown(int max_new_blocking_tasks_after_shutdown);
 
   // Check if Shutdown was called for given threading pool. This method is used
   // for aborting time consuming operation to avoid blocking shutdown.
   //
   // Can be called from any thread.
   bool IsShutdownInProgress();
 
  protected:
   ~SequencedWorkerPool() override;
@@ skipping 12 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_