Implementation of SequencedTaskRunner based on SequencedWorkerPool.

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_
 #pragma once
 
 #include <cstddef>
 #include <string>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/task_runner.h"
 
 namespace tracked_objects {
 class Location;
 }  // namespace tracked_objects
 
 namespace base {
 
 class MessageLoopProxy;
 
 template <class T> class DeleteHelper;
 
+class SequencedTaskRunner;
+
 // A worker thread pool that enforces ordering between sets of tasks. It also
 // allows you to specify what should happen to your tasks on shutdown.
 //
 // To enforce ordering, get a unique sequence token from the pool and post all
 // tasks you want to order with the token. All tasks with the same token are
-// guaranteed to execute serially, though not necessarily on the same thread.
+// guaranteed to execute serially (i.e. there is no execution overlap
+// whatsoever), though not necessarily on the same thread.
 //
 // Example:
 //   SequencedWorkerPool::SequenceToken token = pool.GetSequenceToken();
 //   pool.PostSequencedWorkerTask(token, SequencedWorkerPool::SKIP_ON_SHUTDOWN,
 //                                FROM_HERE, base::Bind(...));
 //   pool.PostSequencedWorkerTask(token, SequencedWorkerPool::SKIP_ON_SHUTDOWN,
 //                                FROM_HERE, base::Bind(...));
 //
 // You can make named sequence tokens to make it easier to share a token
 // across different components.
@@ skipping 80 matching lines @@
     virtual void WillWaitForShutdown() = 0;
     virtual void OnDestruct() = 0;
   };
 
   // Pass the maximum number of threads (they will be lazily created as needed)
   // and a prefix for the thread name to ad in debugging.
   SequencedWorkerPool(size_t max_threads,
                       const std::string& thread_name_prefix);
 
   // 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);
 
+  // Returns a SequencedTaskRunner wrapper for this SequencedWorkerPool.
+  scoped_refptr<SequencedTaskRunner> GetSequencedTaskRunner();
+  scoped_refptr<SequencedTaskRunner> GetSequencedTaskRunner(
+      SequenceToken token);
+  scoped_refptr<SequencedTaskRunner> GetSequencedTaskRunner(
+      const std::string& token_name);
+
   // Posts the given task for execution in the worker pool. Tasks posted with
   // this function will execute in an unspecified order on a background thread.
   // Returns true if the task was posted. If your tasks have ordering
   // requirements, see PostSequencedWorkerTask().
   //
   // This class will attempt to delete tasks that aren't run
   // (non-block-shutdown semantics) but can't guarantee that this happens. If
   // all worker threads are busy running CONTINUE_ON_SHUTDOWN tasks, there
   // will be no workers available to delete these tasks. And there may be
   // tasks with the same sequence token behind those CONTINUE_ON_SHUTDOWN
@@ skipping 98 matching lines @@
   // 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_