Allow SequencedTaskRunnerHandle::Get() while running unsequenced tasks.

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 <cstddef>
 #include <string>
 
@@ skipping 27 matching lines @@
 //
 //   - No two tasks with the same token will run at the same time.
 //
 //   - Given two tasks T1 and T2 with the same token such that T2 will
 //     run after T1, then T2 will start after T1 is destroyed.
 //
 //   - If T2 will run after T1, then all memory changes in T1 and T1's
 //     destruction will be visible to T2.
 //
 // Example:
-//   SequencedWorkerPool::SequenceToken token = pool.GetSequenceToken();
+//   SequencedWorkerPool::SequenceToken token =
+//       SequencedWorkerPool::GetSequenceToken();
 //   pool.PostSequencedWorkerTask(token, SequencedWorkerPool::SKIP_ON_SHUTDOWN,
 //                                FROM_HERE, base::Bind(...));
 //   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
@@ skipping 95 matching lines @@
     virtual void OnHasWork() = 0;
     virtual void WillWaitForShutdown() = 0;
     virtual void OnDestruct() = 0;
   };
 
   // Gets the SequencedToken of the current thread.
   // If current thread is not a SequencedWorkerPool worker thread or is running
   // an unsequenced task, returns an invalid SequenceToken.
   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();
+  // Gets a SequencedTaskRunner for the current thread. If the current thread is
+  // running an unsequenced task, a new SequenceToken will be generated and set,
+  // so that the returned SequencedTaskRunner is guaranteed to run tasks after
+  // the current task has finished running.
+  static scoped_refptr<SequencedTaskRunner>
+  GetSequencedTaskRunnerForCurrentThread();
+
+  // Returns a unique token that can be used to sequence tasks posted to
+  // PostSequencedWorkerTask(). Valid tokens are always nonzero.
+  // TODO(bauerb): Rename this to better differentiate from
+  // GetSequenceTokenForCurrentThread().
+  static SequenceToken GetSequenceToken();
 
   // 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.
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix);
 
   // Like above, but with |observer| for testing.  Does not take ownership of
   // |observer|.
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix,
                       TestingObserver* observer);
 
-  // Returns a unique token that can be used to sequence tasks posted to
-  // PostSequencedWorkerTask(). Valid tokens are always nonzero.
-  SequenceToken GetSequenceToken();
-
   // Returns the sequence token associated with the given name. Calling this
   // function multiple times with the same string will always produce the
   // same sequence token. If the name has not been used before, a new token
   // will be created.
   SequenceToken GetNamedSequenceToken(const std::string& name);
 
   // Returns a SequencedTaskRunner wrapper which posts to this
   // SequencedWorkerPool using the given sequence token. Tasks with nonzero
   // delay are posted with SKIP_ON_SHUTDOWN behavior and tasks with zero delay
   // are posted with BLOCK_SHUTDOWN behavior.
@@ skipping 104 matching lines @@
   // TaskRunner implementation. Forwards to PostDelayedWorkerTask().
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const Closure& task,
                        TimeDelta delay) override;
   bool RunsTasksOnCurrentThread() const override;
 
   // Returns true if the current thread is processing a task with the given
   // sequence_token.
   bool IsRunningSequenceOnCurrentThread(SequenceToken sequence_token) const;
 
+  // Returns true if any thread is currently processing a task with the given
+  // sequence token. Should only be called with a valid sequence token.
+  bool IsRunningSequence(SequenceToken sequence_token) const;
+
   // Blocks until all pending tasks are complete. This should only be called in
   // unit tests when you want to validate something that should have happened.
   // This will not flush delayed tasks; delayed tasks get deleted.
   //
   // Note that calling this will not prevent other threads from posting work to
   // the queue while the calling thread is waiting on Flush(). In this case,
   // Flush will return only when there's no more work in the queue. Normally,
   // this doesn't come up since in a test, all the work is being posted from
   // the main thread.
   void FlushForTesting();
@@ skipping 38 matching lines @@
   // Avoid pulling in too many headers by putting (almost) everything
   // into |inner_|.
   const scoped_ptr<Inner> inner_;
 
   DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPool);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_SEQUENCED_WORKER_POOL_H_