base: Change WeakPtr to use SequenceChecker instead of ThreadChecker.

base/threading/sequenced_worker_pool.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.
 
 #ifndef BASE_THREADING_SEQUENCED_WORKER_POOL_H_
 #define BASE_THREADING_SEQUENCED_WORKER_POOL_H_
 
 #include <cstddef>
 #include <string>
 
@@ skipping 141 matching lines @@
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix);
 
   // Like above, but with |observer| for testing.  Does not take
   // ownership of |observer|.
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix,
                       TestingObserver* observer);
 
   // Returns a unique token that can be used to sequence tasks posted to
-  // PostSequencedWorkerTask(). Valid tokens are alwys nonzero.
+  // PostSequencedWorkerTask(). Valid tokens are always nonzero.
   SequenceToken GetSequenceToken();
 
   // Returns the sequence token associated with the given name. Calling this
   // function multiple times with the same string will always produce the
   // same sequence token. If the name has not been used before, a new token
   // will be created.
   SequenceToken GetNamedSequenceToken(const std::string& name);
 
+  // Retrieves the sequence token associated with the current thread.
+  // If current thread is not part in worker pool, this returns false and
+  // |result_token| is unmodified. |result_token| may not be NULL.
+  bool GetCurrentThreadSequenceToken(SequenceToken* result_token) const;
+
   // Returns a SequencedTaskRunner wrapper which posts to this
   // SequencedWorkerPool using the given sequence token. Tasks with nonzero
   // delay are posted with SKIP_ON_SHUTDOWN behavior and tasks with zero delay
   // are posted with BLOCK_SHUTDOWN behavior.
   scoped_refptr<SequencedTaskRunner> GetSequencedTaskRunner(
       SequenceToken token);
 
   // Returns a SequencedTaskRunner wrapper which posts to this
   // SequencedWorkerPool using the given sequence token. Tasks with nonzero
   // delay are posted with SKIP_ON_SHUTDOWN behavior and tasks with zero delay
@@ skipping 134 matching lines @@
   //
   // Must be called from the same thread this object was constructed on.
   void Shutdown(int max_new_blocking_tasks_after_shutdown);
 
  protected:
   virtual ~SequencedWorkerPool();
 
   virtual void OnDestruct() const OVERRIDE;
 
  private:
+  friend class SequenceCheckerImpl;
+
+  // Gets the SequencedWorkerPool that owns the current thread. May be NULL.
+  static SequencedWorkerPool* Owner();
+
   friend class RefCountedThreadSafe<SequencedWorkerPool>;
   friend class DeleteHelper<SequencedWorkerPool>;
 
   class Inner;
   class Worker;
 
   const scoped_refptr<MessageLoopProxy> constructor_message_loop_;
 
   // Avoid pulling in too many headers by putting (almost) everything
   // into |inner_|.
   const scoped_ptr<Inner> inner_;
 
   DISALLOW_COPY_AND_ASSIGN(SequencedWorkerPool);
 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_SEQUENCED_WORKER_POOL_H_