1 files changed, 49 insertions, 26 deletions
diff --git a/base/sequence_checker_impl.cc b/base/sequence_checker_impl.cc
index e95b8ee5f3..df2a8cb24f 100644
--- a/base/sequence_checker_impl.cc
+++ b/base/sequence_checker_impl.cc
@@ -4,43 +4,66 @@
 
 #include "base/sequence_checker_impl.h"
 
+#include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/sequence_token.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "base/threading/thread_checker_impl.h"
+
 namespace base {
 
-SequenceCheckerImpl::SequenceCheckerImpl()
-    : sequence_token_assigned_(false) {
-  AutoLock auto_lock(lock_);
-  EnsureSequenceTokenAssigned();
-}
+class SequenceCheckerImpl::Core {
+ public:
+  Core()
+      : 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());
+  }
 
-SequenceCheckerImpl::~SequenceCheckerImpl() {}
+  ~Core() = default;
 
-bool SequenceCheckerImpl::CalledOnValidSequencedThread() const {
-  AutoLock auto_lock(lock_);
-  EnsureSequenceTokenAssigned();
+  bool CalledOnValidThread() const {
+    if (sequence_token_.IsValid())
+      return sequence_token_ == SequenceToken::GetForCurrentThread();
 
-  // If this thread is not associated with a SequencedWorkerPool,
-  // SequenceChecker behaves as a ThreadChecker. See header for details.
-  if (!sequence_token_.IsValid())
+    if (sequenced_worker_pool_token_.IsValid()) {
+      return sequenced_worker_pool_token_.Equals(
+          SequencedWorkerPool::GetSequenceTokenForCurrentThread());
+    }
+
+    // SequenceChecker behaves as a ThreadChecker when it is not bound to a
+    // valid sequence token.
     return thread_checker_.CalledOnValidThread();
+  }
 
-  return sequence_token_.Equals(
-      SequencedWorkerPool::GetSequenceTokenForCurrentThread());
-}
+ private:
+  SequenceToken sequence_token_;
 
-void SequenceCheckerImpl::DetachFromSequence() {
+  // TODO(gab): Remove this when SequencedWorkerPool is deprecated in favor of
+  // TaskScheduler. crbug.com/622400
+  SequencedWorkerPool::SequenceToken sequenced_worker_pool_token_;
+
+  // Used when |sequenced_worker_pool_token_| and |sequence_token_| are invalid.
+  ThreadCheckerImpl thread_checker_;
+};
+
+SequenceCheckerImpl::SequenceCheckerImpl() : core_(MakeUnique<Core>()) {}
+SequenceCheckerImpl::~SequenceCheckerImpl() = default;
+
+bool SequenceCheckerImpl::CalledOnValidSequence() const {
   AutoLock auto_lock(lock_);
-  thread_checker_.DetachFromThread();
-  sequence_token_assigned_ = false;
-  sequence_token_ = SequencedWorkerPool::SequenceToken();
+  if (!core_)
+    core_ = MakeUnique<Core>();
+  return core_->CalledOnValidThread();
 }
 
-void SequenceCheckerImpl::EnsureSequenceTokenAssigned() const {
-  lock_.AssertAcquired();
-  if (sequence_token_assigned_)
-    return;
-
-  sequence_token_assigned_ = true;
-  sequence_token_ = SequencedWorkerPool::GetSequenceTokenForCurrentThread();
+void SequenceCheckerImpl::DetachFromSequence() {
+  AutoLock auto_lock(lock_);
+  core_.reset();
 }
 
 }  // namespace base