TaskScheduler: Add SequenceToken and ScopedSetSequenceTokenForCurrentThread

base/sequence_checker_impl.cc

Index: base/sequence_checker_impl.cc
diff --git a/base/sequence_checker_impl.cc b/base/sequence_checker_impl.cc
index e95b8ee5f3e25e639a609e5cb0c5aad291fe6e59..cbf5053f9651c04bd60e04ef55bcf4ec69253d88 100644
--- a/base/sequence_checker_impl.cc
+++ b/base/sequence_checker_impl.cc
@@ -4,43 +4,55 @@
 
 #include "base/sequence_checker_impl.h"
 
+#include "base/logging.h"
+
 namespace base {
 
-SequenceCheckerImpl::SequenceCheckerImpl()
-    : sequence_token_assigned_(false) {
+SequenceCheckerImpl::SequenceCheckerImpl() {
   AutoLock auto_lock(lock_);
   EnsureSequenceTokenAssigned();
 }
 
-SequenceCheckerImpl::~SequenceCheckerImpl() {}
+SequenceCheckerImpl::~SequenceCheckerImpl() = default;
 
 bool SequenceCheckerImpl::CalledOnValidSequencedThread() const {
   AutoLock auto_lock(lock_);
   EnsureSequenceTokenAssigned();
 
-  // If this thread is not associated with a SequencedWorkerPool,
-  // SequenceChecker behaves as a ThreadChecker. See header for details.
-  if (!sequence_token_.IsValid())
-    return thread_checker_.CalledOnValidThread();
+  if (sequence_token_.IsValid())

[gab, 2016/07/26 20:49:49]

Do we even need IsValid() in a world where invalid tokens aren't equal? I guess
it might be more readable but 

if (sequence_token_ == SequenceToken::GetForCurrentThread())
  return true;

would have the same logic :-)

[fdoray, 2016/07/28 18:10:04]

If we do that, we'll delegate to |thread_checker_| when  |sequence_token_| is
valid and SequenceToken::GetForCurrentThread() isn't, which isn't the desired
behavior.

ThreadChecker also needs IsValid(). When ThreadChecker::sequence_token_ !=
SequenceToken::GetForCurrentThread(), we need to know if
ThreadChecker::sequence_token_ is valid to decide whether we return false right
away or check the thread id.

+    return sequence_token_ == SequenceToken::GetForCurrentThread();
+
+  if (sequenced_worker_pool_token_.IsValid()) {
+    return sequenced_worker_pool_token_.Equals(
+        SequencedWorkerPool::GetSequenceTokenForCurrentThread());
+  }
 
-  return sequence_token_.Equals(
-      SequencedWorkerPool::GetSequenceTokenForCurrentThread());
+  // SequenceChecker behaves as a ThreadChecker when it is not bound to a valid
+  // sequence token.
+  return thread_checker_.CalledOnValidThread();
 }
 
 void SequenceCheckerImpl::DetachFromSequence() {
   AutoLock auto_lock(lock_);
+  is_assigned_ = false;
+  sequence_token_ = SequenceToken();
+  sequenced_worker_pool_token_ = SequencedWorkerPool::SequenceToken();
   thread_checker_.DetachFromThread();
-  sequence_token_assigned_ = false;
-  sequence_token_ = SequencedWorkerPool::SequenceToken();
 }
 
 void SequenceCheckerImpl::EnsureSequenceTokenAssigned() const {
   lock_.AssertAcquired();
-  if (sequence_token_assigned_)
+  if (is_assigned_)
     return;
 
-  sequence_token_assigned_ = true;
-  sequence_token_ = SequencedWorkerPool::GetSequenceTokenForCurrentThread();
+  is_assigned_ = true;
+  sequence_token_ = SequenceToken::GetForCurrentThread();
+  sequenced_worker_pool_token_ =
+      SequencedWorkerPool::GetSequenceTokenForCurrentThread();
+
+  // SequencedWorkerPool doesn't use SequenceToken and code outside of
+  // SequenceWorkerPool doesn't set a SequencedWorkerPool token.
+  DCHECK(!sequence_token_.IsValid() || !sequenced_worker_pool_token_.IsValid());
 }
 
 }  // namespace base