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 125 matching lines @@
 
   // 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, this returns
+  // false and |result_token| is unmodified. |result_token| may not be NULL.
+  static bool CurrentThreadSequenceToken(SequenceToken* result_token);

[akalin, 2013/07/03 20:41:14]

valid sequence tokens are non-zero. can you have this return a SequenceToken
that is zero on failure instead?

[tommycli, 2013/07/03 21:04:02]

This is kind of a messed-up point about SequencedWorkerPool.

SequenceToken(0) is used internally to indicate an unsequenced task that can be
run at any time. All the SequenceTokens issued by GetSequenceToken are non-zero,
but SequenceToken == 0 isn't quite invalid so much as an internal sentinel
value.

Although I could re-use SequenceToken(0) as an error sentinel value here, I felt
it was bad to assign yet another special meaning to '0'.

If you think this explanation belongs in the code itself, let me know where, and
I'll put it in!

[akalin, 2013/07/03 22:43:46]

Hmm. Is there a need to distinguish the case where the current thread isn't a
worker thread from the case where the current thread is a worker thread running
an unsequenced task? If not, then I'm still inclined to have it return 0, and
comment that that means that the current thread is either not a worker thread or
is running an unsequenced task. What do you think?

[tommycli, 2013/07/03 23:23:12]

Either way seems fine since they both require looking at the comment to figure
out how to use it. I can see the benefits of this approach.

+
   // 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_