Make WeakPtr use SequenceChecker instead of ThreadChecker

base/memory/weak_ptr.cc

 // Copyright (c) 2011 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/memory/weak_ptr.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 
 namespace base {
 namespace internal {
 
-WeakReference::Flag::Flag() : is_valid_(true) {
+WeakReference::Flag::Flag()
+    : sequence_checker_(ThreadTaskRunnerHandle::GetIfExists()),
+      is_valid_(true) {
 }
 
 void WeakReference::Flag::Invalidate() {
   // The flag being invalidated with a single ref implies that there are no
   // weak pointers in existence. Allow deletion on other thread in this case.
-  DCHECK(thread_checker_.CalledOnValidThread() || HasOneRef());
+  DCHECK(sequence_checker_.CalledInSequence() || HasOneRef());

[jar (doing other things), 2013/02/16 02:37:27]

nit: Although the semantics may be as intended (to replace CalledOnValidThread),
this method name is very confusing.

Can you suggest a better name, or perhaps even (worst case) have another method
that CalledOnValidThread() or maybe CalledOnConsistentThread()?

   is_valid_ = false;
 }
 
 bool WeakReference::Flag::IsValid() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(sequence_checker_.CalledInSequence());
   return is_valid_;
 }
 
+void WeakReference::Flag::DetachFromThread() {
+  sequence_checker_.ChangeSequence(ThreadTaskRunnerHandle::GetIfExists());

[jar (doing other things), 2013/02/16 02:37:27]

nit: This "ChangeSequence" also seems confusing :-(.

Maybe it would help if at least the slot was called something like:
consistent_thread_checker_ 
or (though even this bothers me):
valide_thread_checker_

In truth, I  again feel like the method name does not help the reader understand
what this is doing, or why we're calling it :-(.

Suggestions?

+}
+
 WeakReference::Flag::~Flag() {
 }
 
 WeakReference::WeakReference() {
 }
 
 WeakReference::WeakReference(const Flag* flag) : flag_(flag) {
 }
 
 WeakReference::~WeakReference() {
@@ skipping 29 matching lines @@
 }
 
 WeakPtrBase::~WeakPtrBase() {
 }
 
 WeakPtrBase::WeakPtrBase(const WeakReference& ref) : ref_(ref) {
 }
 
 }  // namespace internal
 }  // namespace base