Make WeakPtr use SequenceChecker instead of ThreadChecker

base/memory/weak_ptr.h

 // 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.
 
 // Weak pointers help in cases where you have many objects referring back to a
 // shared object and you wish for the lifetime of the shared object to not be
 // bound to the lifetime of the referrers.  In other words, this is useful when
 // reference counting is not a good fit.
 //
 // A common alternative to weak pointers is to have the shared object hold a
@@ skipping 56 matching lines @@
 // may only be dereferenced on the thread that the original WeakPtr was bound
 // to.
 
 #ifndef BASE_MEMORY_WEAK_PTR_H_
 #define BASE_MEMORY_WEAK_PTR_H_
 
 #include "base/basictypes.h"
 #include "base/base_export.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
+#include "base/sequence_checker.h"
 #include "base/template_util.h"
-#include "base/threading/thread_checker.h"
 
 namespace base {
 
 template <typename T> class SupportsWeakPtr;
 template <typename T> class WeakPtr;
 
 namespace internal {
 // These classes are part of the WeakPtr implementation.
 // DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
 
 class BASE_EXPORT WeakReference {
  public:
   // While Flag is bound to a specific thread, it may be deleted from another
   // via base::WeakPtr::~WeakPtr().
   class Flag : public RefCountedThreadSafe<Flag> {
    public:
     Flag();
 
     void Invalidate();
     bool IsValid() const;
 
-    void DetachFromThread() { thread_checker_.DetachFromThread(); }
+    void DetachFromThread();
 
    private:
     friend class base::RefCountedThreadSafe<Flag>;
 
     ~Flag();
 
-    ThreadChecker thread_checker_;
+    SequenceChecker sequence_checker_;
     bool is_valid_;
   };
 
   WeakReference();
   explicit WeakReference(const Flag* flag);
   ~WeakReference();
 
   bool is_valid() const;
 
  private:
@@ skipping 120 matching lines @@
   WeakPtr(const internal::WeakReference& ref, T* ptr)
       : WeakPtrBase(ref),
         ptr_(ptr) {
   }
 
   // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its
   // value is undefined (as opposed to NULL).
   T* ptr_;
 };
 
+// TODO(akalin): Make WeakPtrFactory and SupportsWeakPtr support

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

nit: Can you add a bug number.

+// binding to a SequencedTaskRunner instead of just a single thread.
+
 // A class may extend from SupportsWeakPtr to expose weak pointers to itself.
 // This is useful in cases where you want others to be able to get a weak
 // pointer to your class.  It also has the property that you don't need to
 // initialize it from your constructor.
 template <class T>
 class SupportsWeakPtr : public internal::SupportsWeakPtrBase {
  public:
   SupportsWeakPtr() {}
 
   WeakPtr<T> AsWeakPtr() {
@@ skipping 76 matching lines @@
 
  private:
   internal::WeakReferenceOwner weak_reference_owner_;
   T* ptr_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);
 };
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_WEAK_PTR_H_