base: Change WeakPtr to use SequenceChecker instead of ThreadChecker.

base/threading/sequenced_worker_pool.cc

Index: base/threading/sequenced_worker_pool.cc
diff --git a/base/threading/sequenced_worker_pool.cc b/base/threading/sequenced_worker_pool.cc
index f98b23d5d6168a818178fe0c2e0a777edd618bd5..604a0cefbb0655e0d5f95155df6a21693e32efd8 100644
--- a/base/threading/sequenced_worker_pool.cc
+++ b/base/threading/sequenced_worker_pool.cc
@@ -15,16 +15,17 @@
 #include "base/compiler_specific.h"
 #include "base/critical_closure.h"
 #include "base/debug/trace_event.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
-#include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
+#include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/tracked_objects.h"
@@ -33,6 +34,10 @@
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
+#if !defined(OS_NACL)
+#include "base/metrics/histogram.h"
+#endif
+
 namespace base {
 
 namespace {
@@ -213,6 +218,10 @@ uint64 GetTaskTraceID(const SequencedTask& task,
          static_cast<uint64>(reinterpret_cast<intptr_t>(pool));
 }
 
+base::LazyInstance<base::ThreadLocalPointer<
+    SequencedWorkerPool::SequenceToken> > lazy_tls_ptr =
+        LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 // Worker ---------------------------------------------------------------------
@@ -382,8 +391,9 @@ class SequencedWorkerPool::Inner {
 
   // The last sequence number used. Managed by GetSequenceToken, since this
   // only does threadsafe increment operations, you do not need to hold the
-  // lock.
-  volatile subtle::Atomic32 last_sequence_number_;
+  // lock. This is class-static to make SequenceTokens issued by
+  // GetSequenceToken unique across SequencedWorkerPool instances.
+  static volatile subtle::Atomic32 g_last_sequence_number_;

[darin (slow to review), 2013/07/03 07:59:41]

Looks like this code might benefit from using base::StaticAtomicSequenceNumber
(see base/atomic_sequence_num.h)

[tommycli, 2013/07/03 18:16:30]

Done.

 
   // This lock protects |everything in this class|. Do not read or modify
   // anything without holding this lock. Do not block while holding this
@@ -479,6 +489,10 @@ SequencedWorkerPool::Worker::~Worker() {
 }
 
 void SequencedWorkerPool::Worker::Run() {
+  // Store a pointer to the running sequence in thread local storage for
+  // static function access.
+  lazy_tls_ptr.Get().Set(&running_sequence_);
+
   // Just jump back to the Inner object to run the thread, since it has all the
   // tracking information and queues. It might be more natural to implement
   // using DelegateSimpleThread and have Inner implement the Delegate to avoid
@@ -497,7 +511,6 @@ SequencedWorkerPool::Inner::Inner(
     const std::string& thread_name_prefix,
     TestingObserver* observer)
     : worker_pool_(worker_pool),
-      last_sequence_number_(0),
       lock_(),
       has_work_cv_(&lock_),
       can_shutdown_cv_(&lock_),
@@ -533,7 +546,7 @@ SequencedWorkerPool::Inner::~Inner() {
 SequencedWorkerPool::SequenceToken
 SequencedWorkerPool::Inner::GetSequenceToken() {
   subtle::Atomic32 result =
-      subtle::NoBarrier_AtomicIncrement(&last_sequence_number_, 1);
+      subtle::NoBarrier_AtomicIncrement(&g_last_sequence_number_, 1);
   return SequenceToken(static_cast<int>(result));
 }
 
@@ -615,7 +628,7 @@ bool SequencedWorkerPool::Inner::IsRunningSequenceOnCurrentThread(
   ThreadMap::const_iterator found = threads_.find(PlatformThread::CurrentId());
   if (found == threads_.end())
     return false;
-  return found->second->running_sequence().Equals(sequence_token);
+  return sequence_token.Equals(found->second->running_sequence());
 }
 
 // See https://code.google.com/p/chromium/issues/detail?id=168415
@@ -674,8 +687,10 @@ void SequencedWorkerPool::Inner::Shutdown(
     while (!CanShutdown())
       can_shutdown_cv_.Wait();
   }
+#if !defined(OS_NACL)
   UMA_HISTOGRAM_TIMES("SequencedWorkerPool.ShutdownDelayTime",
                       TimeTicks::Now() - shutdown_wait_begin);
+#endif
 }
 
 void SequencedWorkerPool::Inner::ThreadLoop(Worker* this_worker) {
@@ -872,8 +887,10 @@ SequencedWorkerPool::Inner::GetWorkStatus SequencedWorkerPool::Inner::GetWork(
     std::vector<Closure>* delete_these_outside_lock) {
   lock_.AssertAcquired();
 
+#if !defined(OS_NACL)
   UMA_HISTOGRAM_COUNTS_100("SequencedWorkerPool.TaskCount",
                            static_cast<int>(pending_tasks_.size()));
+#endif
 
   // Find the next task with a sequence token that's not currently in use.
   // If the token is in use, that means another thread is running something
@@ -958,8 +975,10 @@ SequencedWorkerPool::Inner::GetWorkStatus SequencedWorkerPool::Inner::GetWork(
   // Track the number of tasks we had to skip over to see if we should be
   // making this more efficient. If this number ever becomes large or is
   // frequently "some", we should consider the optimization above.
+#if !defined(OS_NACL)
   UMA_HISTOGRAM_COUNTS_100("SequencedWorkerPool.UnrunnableTaskCount",
                            unrunnable_tasks);
+#endif
   return status;
 }
 
@@ -1088,8 +1107,21 @@ bool SequencedWorkerPool::Inner::CanShutdown() const {
          blocking_shutdown_pending_task_count_ == 0;
 }
 
+volatile subtle::Atomic32
+SequencedWorkerPool::Inner::g_last_sequence_number_ = 0;
+
 // SequencedWorkerPool --------------------------------------------------------
 
+// static
+bool SequencedWorkerPool::CurrentThreadSequenceToken(
+    SequenceToken* result_token) {
+  SequencedWorkerPool::SequenceToken* token = lazy_tls_ptr.Get().Get();
+  if (!token)
+    return false;
+  *result_token = *token;
+  return true;
+}
+
 SequencedWorkerPool::SequencedWorkerPool(
     size_t max_threads,
     const std::string& thread_name_prefix)