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 126348)
+++ 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"
@@ -80,6 +81,14 @@
 
   SequenceToken GetNamedSequenceToken(const std::string& name);
 
+  scoped_refptr<SequencedTaskRunner> GetSequencedTaskRunner();
+
+  scoped_refptr<SequencedTaskRunner> GetSequencedTaskRunner(

[akalin, 2012/03/15 19:17:35]

Overloads are against style guide -- I think there should only be one function
that takes a SequenceToken; users can either query for a new one or map from a
token_name if they need to.

[Francois, 2012/03/18 16:28:29]

Done.

+      SequenceToken sequence_token);
+
+  scoped_refptr<SequencedTaskRunner> GetSequencedTaskRunner(
+      const std::string& token_name);
+
   // 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.
@@ -113,6 +122,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.
@@ -159,6 +173,8 @@
 
   SequencedWorkerPool* const worker_pool_;
 
+  WeakPtr<SequencedTaskRunner> sequenced_task_runner_;

[akalin, 2012/03/15 19:17:35]

no need for this member variable.  Creating a new STRImpl is cheap enough that
there's no need to reuse one.

[Francois, 2012/03/18 16:28:29]

Do you mean that it should do "return scoped_refptr<STRImpl>(new STRImpl)"? If
so, I did consider it, but I reckoned that it would be pointless to return a
scoped_refptr to a new instance every time. I thought it would be better to
return a scoped_ptr (with a new instance) instead, but I got the impression that
it was quite important for STR to be ref-counted. This is why I went with a
persistent instance inside SWP, which would keep a weak pointer to it. But I
didn't realise that weak_ptrs are not thread-safe. So it will have to be one of
the other two options, but which one?

+
   // The last sequence number used. Managed by GetSequenceToken, since this
   // only does threadsafe increment operations, you do not need to hold the
   // lock.
@@ -309,6 +325,26 @@
   return SequenceToken(LockedGetNamedTokenID(name));
 }
 
+scoped_refptr<SequencedTaskRunner>
+SequencedWorkerPool::Inner::GetSequencedTaskRunner() {
+  AutoLock lock(lock_);
+  return LockedGetSequencedTaskRunner(GetSequenceToken());
+}
+
+scoped_refptr<SequencedTaskRunner>
+SequencedWorkerPool::Inner::GetSequencedTaskRunner(SequenceToken token) {
+  AutoLock lock(lock_);

[akalin, 2012/03/15 19:17:35]

per the comments above, shouldn't need a lock for this

+  return LockedGetSequencedTaskRunner(token);
+}
+
+scoped_refptr<SequencedTaskRunner>
+SequencedWorkerPool::Inner::GetSequencedTaskRunner(
+    const std::string& token_name) {
+  AutoLock lock(lock_);
+  return LockedGetSequencedTaskRunner(
+      SequenceToken(LockedGetNamedTokenID(token_name)));
+}
+
 bool SequencedWorkerPool::Inner::PostTask(
     const std::string* optional_token_name,
     SequenceToken sequence_token,
@@ -496,6 +532,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) {
@@ -732,6 +780,21 @@
   return inner_->GetNamedSequenceToken(name);
 }
 
+scoped_refptr<SequencedTaskRunner> SequencedWorkerPool::GetSequencedTaskRunner(
+) {
+  return inner_->GetSequencedTaskRunner();
+}
+
+scoped_refptr<SequencedTaskRunner> SequencedWorkerPool::GetSequencedTaskRunner(
+    SequenceToken token) {
+  return inner_->GetSequencedTaskRunner(token);
+}
+
+scoped_refptr<SequencedTaskRunner> SequencedWorkerPool::GetSequencedTaskRunner(
+    const std::string& token_name) {
+  return inner_->GetSequencedTaskRunner(token_name);
+}
+
 bool SequencedWorkerPool::PostWorkerTask(
     const tracked_objects::Location& from_here,
     const Closure& task) {