base: Change WeakPtr to use SequenceChecker instead of ThreadChecker.

base/sequence_checker_impl.cc

 // 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.
 
 #include "base/sequence_checker_impl.h"
 
-#include "base/sequenced_task_runner.h"
-
 namespace base {
 
-SequenceCheckerImpl::SequenceCheckerImpl(
-    const scoped_refptr<SequencedTaskRunner>& sequenced_task_runner)
-    : sequenced_task_runner_(sequenced_task_runner) {}
+SequenceCheckerImpl::SequenceCheckerImpl()
+    : sequence_token_assigned_(false) {
+  EnsureSequenceTokenAssigned();
+}
 
 SequenceCheckerImpl::~SequenceCheckerImpl() {}
 
-bool SequenceCheckerImpl::CalledOnValidSequence() const {
+bool SequenceCheckerImpl::CalledOnValidSequencedThread() const {
+  EnsureSequenceTokenAssigned();

[akalin, 2013/07/12 00:26:38]

i think this is racy. It's entirely possible that when
EnsureSequenceTokenAssigned() finishes, another thread comes in and calls
DetachFromSequence(), and then when the lock is entered the token isn't assigned
anymore.

It looks like ThreadChecker suffers from the same problem.

Maybe assert that the lock is held in EnsureSequenceTokenAssigned() instead of
holding the lock? Maybe fix ThreadChecker, too?

[tommycli, 2013/07/12 00:48:06]

Done. Wow good eye.

   AutoLock auto_lock(lock_);
-  return sequenced_task_runner_.get() ?
-      sequenced_task_runner_->RunsTasksOnCurrentThread() :
-      thread_checker_.CalledOnValidThread();
+
+  // 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();
+
+  return sequence_token_.Equals(
+      SequencedWorkerPool::GetSequenceTokenForCurrentThread());
 }
 
-void SequenceCheckerImpl::ChangeSequence(
-    const scoped_refptr<SequencedTaskRunner>& sequenced_task_runner) {
+void SequenceCheckerImpl::DetachFromSequence() {
   AutoLock auto_lock(lock_);
-  sequenced_task_runner_ = sequenced_task_runner;
   thread_checker_.DetachFromThread();
+  sequence_token_assigned_ = false;
+  sequence_token_ = SequencedWorkerPool::SequenceToken();
+}
+
+void SequenceCheckerImpl::EnsureSequenceTokenAssigned() const {
+  AutoLock auto_lock(lock_);
+  if (sequence_token_assigned_)
+    return;
+
+  sequence_token_assigned_ = true;
+  sequence_token_ = SequencedWorkerPool::GetSequenceTokenForCurrentThread();
 }
 
 }  // namespace base