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..8cd081b9810f3b34c552b68b39245472ee17cceb 100644
--- a/base/sequence_checker_impl.cc
+++ b/base/sequence_checker_impl.cc
@@ -4,43 +4,52 @@
 
 #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())
+    return sequence_token_ == internal::SequenceToken::GetCurrent();
+
+  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_ = internal::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_ = internal::SequenceToken::GetCurrent();
+  sequenced_worker_pool_token_ =
+      SequencedWorkerPool::GetSequenceTokenForCurrentThread();
+  DCHECK(!sequence_token_.IsValid() || !sequenced_worker_pool_token_.IsValid());
 }
 
 }  // namespace base