base: Make SequencedWorkerPool issue globally unique SequenceTokens.

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 108 matching lines @@
   // pool.
   class SequenceToken {
    public:
     SequenceToken() : id_(0) {}
     ~SequenceToken() {}
 
     bool Equals(const SequenceToken& other) const {
       return id_ == other.id_;
     }
 
+    // Returns false if current thread is executing an unsequenced task.
+    bool IsValid() const {
+      return id_ != 0;
+    }
+
    private:
     friend class SequencedWorkerPool;
 
     explicit SequenceToken(int id) : id_(id) {}
 
     int id_;
   };
 
   // Allows tests to perform certain actions.
   class TestingObserver {
    public:
     virtual ~TestingObserver() {}
     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();
+
   // When constructing a SequencedWorkerPool, there must be a
   // MessageLoop 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 alwys nonzero.
+  // 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
@@ skipping 160 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_