Implementation of SequencedTaskRunner based on SequencedWorkerPool.

base/threading/sequenced_worker_pool.cc

Index: base/threading/sequenced_worker_pool.cc
===================================================================
--- base/threading/sequenced_worker_pool.cc	(revision 127368)
+++ base/threading/sequenced_worker_pool.cc	(working copy)
@@ -22,6 +22,7 @@
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
+#include "base/threading/sequenced_task_runner_impl.h"
 #include "base/threading/simple_thread.h"
 #include "base/time.h"
 #include "base/tracked_objects.h"
@@ -81,6 +82,9 @@
 
   SequenceToken GetNamedSequenceToken(const std::string& name);
 
+  scoped_refptr<SequencedTaskRunner> GetSequencedTaskRunner(
+      SequenceToken sequence_token);
+
   // This function accepts a name and an ID. If the name is null, the
   // token ID is used. This allows us to implement the optional name lookup
   // from a single function without having to enter the lock a separate time.
@@ -112,6 +116,11 @@
   // token ID, creating a new one if necessary.
   int LockedGetNamedTokenID(const std::string& name);
 
+  // Called from within the lock, this returns a reference to a
+  // SequencedTaskRunner which wraps the SequencedWorkerPool object.
+  scoped_refptr<SequencedTaskRunner> LockedGetSequencedTaskRunner(
+      SequenceToken token);
+
   // The calling code should clear the given delete_these_oustide_lock
   // vector the next time the lock is released. See the implementation for
   // a more detailed description.
@@ -158,6 +167,8 @@
 
   SequencedWorkerPool* const worker_pool_;
 
+  WeakPtr<SequencedTaskRunner> sequenced_task_runner_;
+
   // The last sequence number used. Managed by GetSequenceToken, since this
   // only does threadsafe increment operations, you do not need to hold the
   // lock.
@@ -305,6 +316,12 @@
   return SequenceToken(LockedGetNamedTokenID(name));
 }
 
+scoped_refptr<SequencedTaskRunner>
+SequencedWorkerPool::Inner::GetSequencedTaskRunner(SequenceToken token) {
+  AutoLock lock(lock_);
+  return LockedGetSequencedTaskRunner(token);
+}
+
 bool SequencedWorkerPool::Inner::PostTask(
     const std::string* optional_token_name,
     SequenceToken sequence_token,
@@ -481,6 +498,18 @@
   return result.id_;
 }
 
+scoped_refptr<SequencedTaskRunner>
+SequencedWorkerPool::Inner::LockedGetSequencedTaskRunner(SequenceToken token) {
+  if (!sequenced_task_runner_) {
+    scoped_refptr<SequencedTaskRunner> ref = new SequencedTaskRunnerImpl(
+        scoped_refptr<SequencedWorkerPool>(worker_pool_), token);
+    sequenced_task_runner_ =
+        static_cast<SequencedTaskRunnerImpl*>(ref.get())->AsWeakPtr();
+    return ref;
+  }
+  return scoped_refptr<SequencedTaskRunner>(sequenced_task_runner_.get());
+}
+
 bool SequencedWorkerPool::Inner::GetWork(
     SequencedTask* task,
     std::vector<Closure>* delete_these_outside_lock) {
@@ -725,6 +754,11 @@
   return inner_->GetNamedSequenceToken(name);
 }
 
+scoped_refptr<SequencedTaskRunner> SequencedWorkerPool::GetSequencedTaskRunner(
+    SequenceToken token) {
+  return inner_->GetSequencedTaskRunner(token);
+}
+
 bool SequencedWorkerPool::PostWorkerTask(
     const tracked_objects::Location& from_here,
     const Closure& task) {