Add TaskRunner wrapper for WorkerPool.

base/threading/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_WORKER_POOL_H_
 #define BASE_THREADING_WORKER_POOL_H_
 #pragma once
 
 #include "base/base_export.h"
 #include "base/callback_forward.h"
+#include "base/memory/ref_counted.h"
 
 class Task;
 
 namespace tracked_objects {
 class Location;
 }  // namespace tracked_objects
 
 namespace base {
 
+class TaskRunner;
+
 // This is a facility that runs tasks that don't require a specific thread or
 // a message loop.
 //
 // WARNING: This shouldn't be used unless absolutely necessary. We don't wait
 // for the worker pool threads to finish on shutdown, so the tasks running
 // inside the pool must be extremely careful about other objects they access
 // (MessageLoops, Singletons, etc). During shutdown these object may no longer
 // exist.
 class BASE_EXPORT WorkerPool {
  public:
   // This function posts |task| to run on a worker thread.  |task_is_slow|
   // should be used for tasks that will take a long time to execute.  Returns
   // false if |task| could not be posted to a worker thread.  Regardless of
   // return value, ownership of |task| is transferred to the worker pool.
   static bool PostTask(const tracked_objects::Location& from_here,
                        const base::Closure& task, bool task_is_slow);
 
   // Just like MessageLoopProxy::PostTaskAndReply, except the destination
   // for |task| is a worker thread and you can specify |task_is_slow| just
   // like you can for PostTask above.
   static bool PostTaskAndReply(const tracked_objects::Location& from_here,
                                const Closure& task,
                                const Closure& reply,
                                bool task_is_slow);
+
+  // Return true if the current thread is one that this WorkerPool runs tasks
+  // on.  (Note that if the Windows worker pool is used without going through
+  // this WorkerPool interface, RunsTasksOnCurrentThread would return false on
+  // those threads.)
+  static bool RunsTasksOnCurrentThread();
+
+  // Get a TaskRunner wrapper which posts to the WorkerPool using the given
+  // |task_is_slow| behavior.
+  static scoped_refptr<TaskRunner> GetTaskRunner(bool task_is_slow);

[willchan no longer on Chromium, 2012/04/24 23:41:50]

How about you also store a leaky LazyInstance for a scoped_refptr for the
TaskRunner? I worry that people will do dumb things like TaskRunner* task_runner
= base::WorkerPool::GetTaskRunner(), which will cause the TaskRunner to get
immediately deleted due to the implicit T* operator.

[mattm, 2012/04/25 00:57:35]

Done.  Had to make a holder class to initialize the scoped_refptr

 };
 
 }  // namespace base
 
 #endif  // BASE_THREADING_WORKER_POOL_H_