Make new TaskRunner, SequencedTaskRunner, and SingleThreadTaskRunner interfaces
TaskRunner just has Post{,Delayed}Task(), SequencedTaskRunner
extends Executor to have ordering guarantees and PostNonNestable{,Delayed}Task(), and SingleThreadTaskRunner extends SequencedTaskRunner and guarantees execution on a single thread.
Move a bunch of methods from MessageLoopProxy into the TaskRunner classes and make it inherit from SingleThreadTaskRunner.
BUG=110973
TEST=
Review URL: https://chromiumcodereview.appspot.com/9169037
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@121999 0039d316-1c4b-4281-b951-d872f2087c98
CrOS-Libchrome-Original-Commit: 6b28d9469f63df13c9918d5f2d8d24ba8b9893a5
diff --git a/base/base.gypi b/base/base.gypi
index 36400ed..693f393 100644
--- a/base/base.gypi
+++ b/base/base.gypi
@@ -187,6 +187,7 @@
'memory/weak_ptr.h',
'message_loop.cc',
'message_loop.h',
+ 'message_loop_helpers.h',
'message_loop_proxy.cc',
'message_loop_proxy.h',
'message_loop_proxy_impl.cc',
@@ -252,6 +253,9 @@
'scoped_native_library.h',
'scoped_temp_dir.cc',
'scoped_temp_dir.h',
+ 'sequenced_task_runner.cc',
+ 'sequenced_task_runner.h',
+ 'sequenced_task_runner_helpers.h',
'sha1.h',
'sha1_portable.cc',
'sha1_win.cc',
@@ -259,6 +263,7 @@
'shared_memory_android.cc',
'shared_memory_posix.cc',
'shared_memory_win.cc',
+ 'single_thread_task_runner.h',
'spin_wait.h',
'stack_container.h',
'stl_util.h',
@@ -311,6 +316,8 @@
'sys_string_conversions_mac.mm',
'sys_string_conversions_posix.cc',
'sys_string_conversions_win.cc',
+ 'task_runner.cc',
+ 'task_runner.h',
'template_util.h',
'threading/non_thread_safe.h',
'threading/non_thread_safe_impl.cc',
diff --git a/base/message_loop.h b/base/message_loop.h
index f940502..355d58b 100644
--- a/base/message_loop.h
+++ b/base/message_loop.h
@@ -14,11 +14,11 @@
#include "base/callback_forward.h"
#include "base/location.h"
#include "base/memory/ref_counted.h"
-#include "base/message_loop_helpers.h"
#include "base/message_loop_proxy.h"
#include "base/message_pump.h"
#include "base/observer_list.h"
#include "base/pending_task.h"
+#include "base/sequenced_task_runner_helpers.h"
#include "base/synchronization/lock.h"
#include "base/tracking_info.h"
#include "base/time.h"
@@ -199,7 +199,7 @@
// from RefCountedThreadSafe<T>!
template <class T>
void DeleteSoon(const tracked_objects::Location& from_here, const T* object) {
- base::subtle::DeleteHelperInternal<T, void>::DeleteOnMessageLoop(
+ base::subtle::DeleteHelperInternal<T, void>::DeleteViaSequencedTaskRunner(
this, from_here, object);
}
@@ -216,7 +216,7 @@
template <class T>
void ReleaseSoon(const tracked_objects::Location& from_here,
const T* object) {
- base::subtle::ReleaseHelperInternal<T, void>::ReleaseOnMessageLoop(
+ base::subtle::ReleaseHelperInternal<T, void>::ReleaseViaSequencedTaskRunner(
this, from_here, object);
}
diff --git a/base/message_loop_helpers.h b/base/message_loop_helpers.h
index 9aeaad7..931f02d 100644
--- a/base/message_loop_helpers.h
+++ b/base/message_loop_helpers.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
@@ -6,99 +6,8 @@
#define BASE_MESSAGE_LOOP_HELPERS_H_
#pragma once
-#include "base/basictypes.h"
-
-namespace tracked_objects {
-class Location;
-}
-
-namespace base {
-
-namespace subtle {
-template <class T, class R> class DeleteHelperInternal;
-template <class T, class R> class ReleaseHelperInternal;
-}
-
-// Template helpers which use a function indirection to erase T from the
-// function signature while still remembering it so we can call the correct
-// destructor/release function.
-// We use this trick so we don't need to include bind.h in a header file like
-// message_loop.h. We also wrap the helpers in a templated class to make it
-// easier for users of DeleteSoon to declare the helper as a friend.
-template <class T>
-class DeleteHelper {
- private:
- template <class T2, class R> friend class subtle::DeleteHelperInternal;
-
- static void DoDelete(const void* object) {
- delete reinterpret_cast<const T*>(object);
- }
-
- DISALLOW_COPY_AND_ASSIGN(DeleteHelper);
-};
-
-template <class T>
-class ReleaseHelper {
- private:
- template <class T2, class R> friend class subtle::ReleaseHelperInternal;
-
- static void DoRelease(const void* object) {
- reinterpret_cast<const T*>(object)->Release();
- }
-
- DISALLOW_COPY_AND_ASSIGN(ReleaseHelper);
-};
-
-namespace subtle {
-
-// An internal MessageLoop-like class helper for DeleteHelper and ReleaseHelper.
-// We don't want to expose the Do*() functions directly directly since the void*
-// argument makes it possible to pass/ an object of the wrong type to delete.
-// Instead, we force callers to go through these internal helpers for type
-// safety. MessageLoop-like classes which expose DeleteSoon or ReleaseSoon
-// methods should friend the appropriate helper and implement a corresponding
-// *Internal method with the following signature:
-// bool(const tracked_objects::Location&,
-// void(*function)(const void*),
-// void* object)
-// An implementation of this function should simply create a base::Closure
-// from (function, object) and return the result of posting the task.
-template <class T, class ReturnType>
-class DeleteHelperInternal {
- public:
- template <class MessageLoopType>
- static ReturnType DeleteOnMessageLoop(
- MessageLoopType* message_loop,
- const tracked_objects::Location& from_here,
- const T* object) {
- return message_loop->DeleteSoonInternal(from_here,
- &DeleteHelper<T>::DoDelete,
- object);
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(DeleteHelperInternal);
-};
-
-template <class T, class ReturnType>
-class ReleaseHelperInternal {
- public:
- template <class MessageLoopType>
- static ReturnType ReleaseOnMessageLoop(
- MessageLoopType* message_loop,
- const tracked_objects::Location& from_here,
- const T* object) {
- return message_loop->ReleaseSoonInternal(from_here,
- &ReleaseHelper<T>::DoRelease,
- object);
- }
-
- private:
- DISALLOW_COPY_AND_ASSIGN(ReleaseHelperInternal);
-};
-
-} // namespace subtle
-
-} // namespace base
+// TODO(akalin): Change all includers of message_loop_helpers.h to
+// include sequenced_task_runner_helpers.h instead.
+#include "base/sequenced_task_runner_helpers.h"
#endif // BASE_MESSAGE_LOOP_HELPERS_H_
diff --git a/base/message_loop_proxy.cc b/base/message_loop_proxy.cc
index b815bb1..755564b 100644
--- a/base/message_loop_proxy.cc
+++ b/base/message_loop_proxy.cc
@@ -1,66 +1,17 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
#include "base/message_loop_proxy.h"
#include "base/bind.h"
-#include "base/compiler_specific.h"
-#include "base/location.h"
-#include "base/threading/post_task_and_reply_impl.h"
namespace base {
-namespace {
-
-class PostTaskAndReplyMessageLoopProxy : public internal::PostTaskAndReplyImpl {
- public:
- PostTaskAndReplyMessageLoopProxy(MessageLoopProxy* destination)
- : destination_(destination) {
- }
-
- private:
- virtual bool PostTask(const tracked_objects::Location& from_here,
- const base::Closure& task) OVERRIDE {
- return destination_->PostTask(from_here, task);
- }
-
- // Non-owning.
- MessageLoopProxy* destination_;
-};
-
-} // namespace
-
MessageLoopProxy::MessageLoopProxy() {
}
MessageLoopProxy::~MessageLoopProxy() {
}
-bool MessageLoopProxy::PostTaskAndReply(
- const tracked_objects::Location& from_here,
- const Closure& task,
- const Closure& reply) {
- return PostTaskAndReplyMessageLoopProxy(this).PostTaskAndReply(
- from_here, task, reply);
-}
-
-void MessageLoopProxy::OnDestruct() const {
- delete this;
-}
-
-bool MessageLoopProxy::DeleteSoonInternal(
- const tracked_objects::Location& from_here,
- void(*deleter)(const void*),
- const void* object) {
- return PostNonNestableTask(from_here, base::Bind(deleter, object));
-}
-
-bool MessageLoopProxy::ReleaseSoonInternal(
- const tracked_objects::Location& from_here,
- void(*releaser)(const void*),
- const void* object) {
- return PostNonNestableTask(from_here, base::Bind(releaser, object));
-}
-
} // namespace base
diff --git a/base/message_loop_proxy.h b/base/message_loop_proxy.h
index 4487775..320ccfb 100644
--- a/base/message_loop_proxy.h
+++ b/base/message_loop_proxy.h
@@ -7,19 +7,12 @@
#pragma once
#include "base/base_export.h"
-#include "base/basictypes.h"
-#include "base/callback_forward.h"
+#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
-#include "base/message_loop_helpers.h"
-
-namespace tracked_objects {
-class Location;
-} // namespace tracked_objects
+#include "base/single_thread_task_runner.h"
namespace base {
-struct MessageLoopProxyTraits;
-
// This class provides a thread-safe refcounted interface to the Post* methods
// of a message loop. This class can outlive the target message loop.
// MessageLoopProxy objects are constructed automatically for all MessageLoops.
@@ -27,122 +20,18 @@
// Thread::message_loop_proxy()
// MessageLoop::current()->message_loop_proxy()
// MessageLoopProxy::current()
-class BASE_EXPORT MessageLoopProxy
- : public base::RefCountedThreadSafe<MessageLoopProxy,
- MessageLoopProxyTraits> {
+//
+// TODO(akalin): Now that we have the *TaskRunner interfaces, we can
+// merge this with MessageLoopProxyImpl.
+class BASE_EXPORT MessageLoopProxy : public SingleThreadTaskRunner {
public:
- // These methods are the same as in message_loop.h, but are guaranteed to
- // either post the Task to the MessageLoop (if it's still alive), or the task
- // is discarded.
- // They return true iff the thread existed and the task was posted. Note that
- // even if the task is posted, there's no guarantee that it will run; for
- // example the target loop may already be quitting, or in the case of a
- // delayed task a Quit message may preempt it in the message loop queue.
- // Conversely, a return value of false is a guarantee the task will not run.
- virtual bool PostTask(const tracked_objects::Location& from_here,
- const base::Closure& task) = 0;
- virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
- const base::Closure& task,
- int64 delay_ms) = 0;
- virtual bool PostNonNestableTask(const tracked_objects::Location& from_here,
- const base::Closure& task) = 0;
- virtual bool PostNonNestableDelayedTask(
- const tracked_objects::Location& from_here,
- const base::Closure& task,
- int64 delay_ms) = 0;
-
- // A method which checks if the caller is currently running in the thread that
- // this proxy represents.
- virtual bool BelongsToCurrentThread() = 0;
-
- // Executes |task| on the given MessageLoopProxy. On completion, |reply|
- // is passed back to the MessageLoopProxy for the thread that called
- // PostTaskAndReply(). Both |task| and |reply| are guaranteed to be deleted
- // on the thread from which PostTaskAndReply() is invoked. This allows
- // objects that must be deleted on the originating thread to be bound into the
- // |task| and |reply| Closures. In particular, it can be useful to use
- // WeakPtr<> in the |reply| Closure so that the reply operation can be
- // canceled. See the following pseudo-code:
- //
- // class DataBuffer : public RefCountedThreadSafe<DataBuffer> {
- // public:
- // // Called to add data into a buffer.
- // void AddData(void* buf, size_t length);
- // ...
- // };
- //
- //
- // class DataLoader : public SupportsWeakPtr<DataLoader> {
- // public:
- // void GetData() {
- // scoped_refptr<DataBuffer> buffer = new DataBuffer();
- // target_thread_.message_loop_proxy()->PostTaskAndReply(
- // FROM_HERE,
- // base::Bind(&DataBuffer::AddData, buffer),
- // base::Bind(&DataLoader::OnDataReceived, AsWeakPtr(), buffer));
- // }
- //
- // private:
- // void OnDataReceived(scoped_refptr<DataBuffer> buffer) {
- // // Do something with buffer.
- // }
- // };
- //
- //
- // Things to notice:
- // * Results of |task| are shared with |reply| by binding a shared argument
- // (a DataBuffer instance).
- // * The DataLoader object has no special thread safety.
- // * The DataLoader object can be deleted while |task| is still running,
- // and the reply will cancel itself safely because it is bound to a
- // WeakPtr<>.
- bool PostTaskAndReply(const tracked_objects::Location& from_here,
- const Closure& task,
- const Closure& reply);
-
- template <class T>
- bool DeleteSoon(const tracked_objects::Location& from_here,
- const T* object) {
- return subtle::DeleteHelperInternal<T, bool>::DeleteOnMessageLoop(
- this, from_here, object);
- }
- template <class T>
- bool ReleaseSoon(const tracked_objects::Location& from_here,
- T* object) {
- return subtle::ReleaseHelperInternal<T, bool>::ReleaseOnMessageLoop(
- this, from_here, object);
- }
-
// Gets the MessageLoopProxy for the current message loop, creating one if
// needed.
static scoped_refptr<MessageLoopProxy> current();
protected:
- friend class RefCountedThreadSafe<MessageLoopProxy, MessageLoopProxyTraits>;
- friend struct MessageLoopProxyTraits;
-
MessageLoopProxy();
virtual ~MessageLoopProxy();
-
- // Called when the proxy is about to be deleted. Subclasses can override this
- // to provide deletion on specific threads.
- virtual void OnDestruct() const;
-
- private:
- template <class T, class R> friend class subtle::DeleteHelperInternal;
- template <class T, class R> friend class subtle::ReleaseHelperInternal;
- bool DeleteSoonInternal(const tracked_objects::Location& from_here,
- void(*deleter)(const void*),
- const void* object);
- bool ReleaseSoonInternal(const tracked_objects::Location& from_here,
- void(*releaser)(const void*),
- const void* object);
-};
-
-struct MessageLoopProxyTraits {
- static void Destruct(const MessageLoopProxy* proxy) {
- proxy->OnDestruct();
- }
};
} // namespace base
diff --git a/base/message_loop_proxy_impl.cc b/base/message_loop_proxy_impl.cc
index dd20b39..eeeb1db 100644
--- a/base/message_loop_proxy_impl.cc
+++ b/base/message_loop_proxy_impl.cc
@@ -12,11 +12,6 @@
MessageLoopProxyImpl::~MessageLoopProxyImpl() {
}
-bool MessageLoopProxyImpl::PostTask(const tracked_objects::Location& from_here,
- const base::Closure& task) {
- return PostTaskHelper(from_here, task, 0, true);
-}
-
bool MessageLoopProxyImpl::PostDelayedTask(
const tracked_objects::Location& from_here,
const base::Closure& task,
@@ -24,11 +19,6 @@
return PostTaskHelper(from_here, task, delay_ms, true);
}
-bool MessageLoopProxyImpl::PostNonNestableTask(
- const tracked_objects::Location& from_here, const base::Closure& task) {
- return PostTaskHelper(from_here, task, 0, false);
-}
-
bool MessageLoopProxyImpl::PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
const base::Closure& task,
@@ -36,7 +26,7 @@
return PostTaskHelper(from_here, task, delay_ms, false);
}
-bool MessageLoopProxyImpl::BelongsToCurrentThread() {
+bool MessageLoopProxyImpl::RunsTasksOnCurrentThread() const {
// We shouldn't use MessageLoop::current() since it uses LazyInstance which
// may be deleted by ~AtExitManager when a WorkerPool thread calls this
// function.
diff --git a/base/message_loop_proxy_impl.h b/base/message_loop_proxy_impl.h
index bb1fc0b..847ee4c 100644
--- a/base/message_loop_proxy_impl.h
+++ b/base/message_loop_proxy_impl.h
@@ -22,18 +22,14 @@
virtual ~MessageLoopProxyImpl();
// MessageLoopProxy implementation
- virtual bool PostTask(const tracked_objects::Location& from_here,
- const base::Closure& task) OVERRIDE;
virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
const base::Closure& task,
int64 delay_ms) OVERRIDE;
- virtual bool PostNonNestableTask(const tracked_objects::Location& from_here,
- const base::Closure& task) OVERRIDE;
virtual bool PostNonNestableDelayedTask(
const tracked_objects::Location& from_here,
const base::Closure& task,
int64 delay_ms) OVERRIDE;
- virtual bool BelongsToCurrentThread() OVERRIDE;
+ virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
protected:
// Override OnDestruct so that we can delete the object on the target message
diff --git a/base/sequenced_task_runner.cc b/base/sequenced_task_runner.cc
new file mode 100644
index 0000000..bab7d1c
--- /dev/null
+++ b/base/sequenced_task_runner.cc
@@ -0,0 +1,31 @@
+// 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.
+
+#include "base/sequenced_task_runner.h"
+
+#include "base/bind.h"
+
+namespace base {
+
+bool SequencedTaskRunner::PostNonNestableTask(
+ const tracked_objects::Location& from_here,
+ const Closure& task) {
+ return PostNonNestableDelayedTask(from_here, task, 0);
+}
+
+bool SequencedTaskRunner::DeleteSoonInternal(
+ const tracked_objects::Location& from_here,
+ void(*deleter)(const void*),
+ const void* object) {
+ return PostNonNestableTask(from_here, Bind(deleter, object));
+}
+
+bool SequencedTaskRunner::ReleaseSoonInternal(
+ const tracked_objects::Location& from_here,
+ void(*releaser)(const void*),
+ const void* object) {
+ return PostNonNestableTask(from_here, Bind(releaser, object));
+}
+
+} // namespace base
diff --git a/base/sequenced_task_runner.h b/base/sequenced_task_runner.h
new file mode 100644
index 0000000..a280522
--- /dev/null
+++ b/base/sequenced_task_runner.h
@@ -0,0 +1,156 @@
+// 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_SEQUENCED_TASKRUNNER_H_
+#define BASE_SEQUENCED_TASKRUNNER_H_
+#pragma once
+
+#include "base/base_export.h"
+#include "base/sequenced_task_runner_helpers.h"
+#include "base/task_runner.h"
+
+namespace base {
+
+// A SequencedTaskRunner is a subclass of TaskRunner that provides
+// additional guarantees on the order that tasks are started, as well
+// as guarantees on when tasks are in sequence, i.e. one task finishes
+// before the other one starts.
+//
+// Summary
+// -------
+// Barring delayed/non-nestable tasks, tasks posted will run one by
+// one in FIFO order.
+//
+// Detailed guarantees
+// -------------------
+//
+// SequencedTaskRunner also adds additional methods for posting
+// non-nestable tasks. In general, an implementation of TaskRunner
+// may expose task-running methods which are themselves callable from
+// within tasks. A non-nestable task is one that is guaranteed to not
+// be run from within an already-running task. Conversely, a nestable
+// task (the default) is a task that can be run from within an
+// already-running task.
+//
+// The guarantees of SequencedTaskRunner are as follows:
+//
+// - Given two tasks T2 and T1, T2 will start after T1 starts if:
+//
+// * T2 is posted after T1;
+// * T2 has equal or higher delay than T1; and
+// * T2 is non-nestable or T1 is nestable.
+//
+// - If T2 will start after T1 starts by the above guarantee, then
+// T2 will start after T1 finishes if:
+//
+// * T2 is non-nestable, or
+// * T1 doesn't call any task-running methods.
+//
+// - If T2 will start after T1 finishes by the above guarantee, then
+// all memory changes in T1 will be visible to T2.
+//
+// - If T2 runs nested within T1 via a call to the task-running
+// method M, then all memory changes in T1 up to the call to M
+// will be visible to T2, and all memory changes in T2 will be
+// visible to T1 from the return from M.
+//
+// Note that SequencedTaskRunner does not guarantee that tasks are run
+// on a single dedicated thread, although the above guarantees provide
+// most (but not all) of the same guarantees. If you do need to
+// guarantee that tasks are run on a single dedicated thread, see
+// SingleThreadTaskRunner (in single_thread_task_runner.h).
+//
+// Some corollaries to the above guarantees, assuming the tasks in
+// question don't call any task-running methods:
+//
+// - Tasks posted via PostTask are run in FIFO order.
+//
+// - Tasks posted via PostNonNestableTask are run in FIFO order.
+//
+// - Tasks posted with the same delay and the same nestable state
+// are run in FIFO order.
+//
+// - A list of tasks with the same nestable state posted in order of
+// non-decreasing delay is run in FIFO order.
+//
+// - A list of tasks posted in order of non-decreasing delay with at
+// most a single change in nestable state from nestable to
+// non-nestable is run in FIFO order. (This is equivalent to the
+// statement of the first guarantee above.)
+//
+// Some theoretical implementations of SequencedTaskRunner:
+//
+// - A SequencedTaskRunner that wraps a regular TaskRunner but makes
+// sure that only one task at a time is posted to the TaskRunner,
+// with appropriate memory barriers in between tasks.
+//
+// - A SequencedTaskRunner that, for each task, spawns a joinable
+// thread to run that task and immediately quit, and then
+// immediately joins that thread.
+//
+// - A SequencedTaskRunner that stores the list of posted tasks and
+// has a method Run() that runs each runnable task in FIFO order
+// that can be called from any thread, but only if another
+// (non-nested) Run() call isn't already happening.
+class BASE_EXPORT SequencedTaskRunner : public TaskRunner {
+ public:
+ // The two PostNonNestable*Task methods below are like their
+ // nestable equivalents in TaskRunner, but they guarantee that the
+ // posted task will not run nested within an already-running task.
+ //
+ // A simple corollary is that posting a task as non-nestable can
+ // only delay when the task gets run. That is, posting a task as
+ // non-nestable may not affect when the task gets run, or it could
+ // make it run later than it normally would, but it won't make it
+ // run earlier than it normally would.
+
+ // TODO(akalin): Get rid of the boolean return value for the methods
+ // below.
+
+ bool PostNonNestableTask(const tracked_objects::Location& from_here,
+ const Closure& task);
+
+ virtual bool PostNonNestableDelayedTask(
+ const tracked_objects::Location& from_here,
+ const Closure& task,
+ int64 delay_ms) = 0;
+
+ // Submits a non-nestable task to delete the given object. Returns
+ // true if the object may be deleted at some point in the future,
+ // and false if the object definitely will not be deleted.
+ template <class T>
+ bool DeleteSoon(const tracked_objects::Location& from_here,
+ const T* object) {
+ return
+ subtle::DeleteHelperInternal<T, bool>::DeleteViaSequencedTaskRunner(
+ this, from_here, object);
+ }
+
+ // Submits a non-nestable task to release the given object. Returns
+ // true if the object may be released at some point in the future,
+ // and false if the object definitely will not be released.
+ template <class T>
+ bool ReleaseSoon(const tracked_objects::Location& from_here,
+ T* object) {
+ return
+ subtle::ReleaseHelperInternal<T, bool>::ReleaseViaSequencedTaskRunner(
+ this, from_here, object);
+ }
+
+private:
+ template <class T, class R> friend class subtle::DeleteHelperInternal;
+ template <class T, class R> friend class subtle::ReleaseHelperInternal;
+
+ bool DeleteSoonInternal(const tracked_objects::Location& from_here,
+ void(*deleter)(const void*),
+ const void* object);
+
+ bool ReleaseSoonInternal(const tracked_objects::Location& from_here,
+ void(*releaser)(const void*),
+ const void* object);
+};
+
+} // namespace base
+
+#endif // BASE_SEQUENCED_TASKRUNNER_H_
diff --git a/base/sequenced_task_runner_helpers.h b/base/sequenced_task_runner_helpers.h
new file mode 100644
index 0000000..f03ca9e
--- /dev/null
+++ b/base/sequenced_task_runner_helpers.h
@@ -0,0 +1,113 @@
+// 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_SEQUENCED_TASK_RUNNER_HELPERS_H_
+#define BASE_SEQUENCED_TASK_RUNNER_HELPERS_H_
+#pragma once
+
+#include "base/basictypes.h"
+
+// TODO(akalin): Investigate whether it's possible to just have
+// SequencedTaskRunner use these helpers (instead of MessageLoop).
+// Then we can just move these to sequenced_task_runner.h.
+
+namespace tracked_objects {
+class Location;
+}
+
+namespace base {
+
+namespace subtle {
+template <class T, class R> class DeleteHelperInternal;
+template <class T, class R> class ReleaseHelperInternal;
+}
+
+// Template helpers which use function indirection to erase T from the
+// function signature while still remembering it so we can call the
+// correct destructor/release function.
+//
+// We use this trick so we don't need to include bind.h in a header
+// file like sequenced_task_runner.h. We also wrap the helpers in a
+// templated class to make it easier for users of DeleteSoon to
+// declare the helper as a friend.
+template <class T>
+class DeleteHelper {
+ private:
+ template <class T2, class R> friend class subtle::DeleteHelperInternal;
+
+ static void DoDelete(const void* object) {
+ delete reinterpret_cast<const T*>(object);
+ }
+
+ DISALLOW_COPY_AND_ASSIGN(DeleteHelper);
+};
+
+template <class T>
+class ReleaseHelper {
+ private:
+ template <class T2, class R> friend class subtle::ReleaseHelperInternal;
+
+ static void DoRelease(const void* object) {
+ reinterpret_cast<const T*>(object)->Release();
+ }
+
+ DISALLOW_COPY_AND_ASSIGN(ReleaseHelper);
+};
+
+namespace subtle {
+
+// An internal SequencedTaskRunner-like class helper for DeleteHelper
+// and ReleaseHelper. We don't want to expose the Do*() functions
+// directly directly since the void* argument makes it possible to
+// pass/ an object of the wrong type to delete. Instead, we force
+// callers to go through these internal helpers for type
+// safety. SequencedTaskRunner-like classes which expose DeleteSoon or
+// ReleaseSoon methods should friend the appropriate helper and
+// implement a corresponding *Internal method with the following
+// signature:
+//
+// bool(const tracked_objects::Location&,
+// void(*function)(const void*),
+// void* object)
+//
+// An implementation of this function should simply create a
+// base::Closure from (function, object) and return the result of
+// posting the task.
+template <class T, class ReturnType>
+class DeleteHelperInternal {
+ public:
+ template <class SequencedTaskRunnerType>
+ static ReturnType DeleteViaSequencedTaskRunner(
+ SequencedTaskRunnerType* sequenced_task_runner,
+ const tracked_objects::Location& from_here,
+ const T* object) {
+ return sequenced_task_runner->DeleteSoonInternal(
+ from_here, &DeleteHelper<T>::DoDelete, object);
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(DeleteHelperInternal);
+};
+
+template <class T, class ReturnType>
+class ReleaseHelperInternal {
+ public:
+ template <class SequencedTaskRunnerType>
+ static ReturnType ReleaseViaSequencedTaskRunner(
+ SequencedTaskRunnerType* sequenced_task_runner,
+ const tracked_objects::Location& from_here,
+ const T* object) {
+ return sequenced_task_runner->ReleaseSoonInternal(
+ from_here, &ReleaseHelper<T>::DoRelease, object);
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ReleaseHelperInternal);
+};
+
+} // namespace subtle
+
+} // namespace base
+
+#endif // BASE_SEQUENCED_TASK_RUNNER_HELPERS_H_
diff --git a/base/single_thread_task_runner.h b/base/single_thread_task_runner.h
new file mode 100644
index 0000000..93f694e
--- /dev/null
+++ b/base/single_thread_task_runner.h
@@ -0,0 +1,38 @@
+// 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_SINGLE_THREAD_TASK_RUNNER_H_
+#define BASE_SINGLE_THREAD_TASK_RUNNER_H_
+#pragma once
+
+#include "base/base_export.h"
+#include "base/sequenced_task_runner.h"
+
+namespace base {
+
+// A SingleThreadTaskRunner is a SequencedTaskRunner with one more
+// guarantee; namely, that all tasks are run on a single dedicated
+// thread. Most use cases require only a SequencedTaskRunner, unless
+// there is a specific need to run tasks on only a single dedicated.
+//
+// Some theoretical implementations of SingleThreadTaskRunner:
+//
+// - A SingleThreadTaskRunner that uses a single worker thread to
+// run posted tasks (i.e., a message loop).
+//
+// - A SingleThreadTaskRunner that stores the list of posted tasks
+// and has a method Run() that runs each runnable task in FIFO
+// order that must be run only from the thread the
+// SingleThreadTaskRunner was created on.
+class BASE_EXPORT SingleThreadTaskRunner : public SequencedTaskRunner {
+public:
+ // A more explicit alias to RunsTasksOnCurrentThread().
+ bool BelongsToCurrentThread() const {
+ return RunsTasksOnCurrentThread();
+ }
+};
+
+} // namespace base
+
+#endif // BASE_SERIAL_TASK_RUNNER_H_
diff --git a/base/task_runner.cc b/base/task_runner.cc
new file mode 100644
index 0000000..734674f
--- /dev/null
+++ b/base/task_runner.cc
@@ -0,0 +1,68 @@
+// 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.
+
+#include "base/task_runner.h"
+
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/threading/post_task_and_reply_impl.h"
+
+namespace base {
+
+namespace {
+
+// TODO(akalin): There's only one other implementation of
+// PostTaskAndReplyImpl in WorkerPool. Investigate whether it'll be
+// possible to merge the two.
+class PostTaskAndReplyTaskRunner : public internal::PostTaskAndReplyImpl {
+ public:
+ PostTaskAndReplyTaskRunner(TaskRunner* destination);
+
+ private:
+ virtual bool PostTask(const tracked_objects::Location& from_here,
+ const Closure& task) OVERRIDE;
+
+ // Non-owning.
+ TaskRunner* destination_;
+};
+
+PostTaskAndReplyTaskRunner::PostTaskAndReplyTaskRunner(
+ TaskRunner* destination) : destination_(destination) {
+ DCHECK(destination_);
+}
+
+bool PostTaskAndReplyTaskRunner::PostTask(
+ const tracked_objects::Location& from_here,
+ const Closure& task) {
+ return destination_->PostTask(from_here, task);
+}
+
+} // namespace
+
+bool TaskRunner::PostTask(const tracked_objects::Location& from_here,
+ const Closure& task) {
+ return PostDelayedTask(from_here, task, 0);
+}
+
+bool TaskRunner::PostTaskAndReply(
+ const tracked_objects::Location& from_here,
+ const Closure& task,
+ const Closure& reply) {
+ return PostTaskAndReplyTaskRunner(this).PostTaskAndReply(
+ from_here, task, reply);
+}
+
+TaskRunner::TaskRunner() {}
+
+TaskRunner::~TaskRunner() {}
+
+void TaskRunner::OnDestruct() const {
+ delete this;
+}
+
+void TaskRunnerTraits::Destruct(const TaskRunner* task_runner) {
+ task_runner->OnDestruct();
+}
+
+} // namespace base
diff --git a/base/task_runner.h b/base/task_runner.h
new file mode 100644
index 0000000..7527031
--- /dev/null
+++ b/base/task_runner.h
@@ -0,0 +1,155 @@
+// 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_TASK_RUNNER_H_
+#define BASE_TASK_RUNNER_H_
+#pragma once
+
+#include "base/base_export.h"
+#include "base/basictypes.h"
+#include "base/callback_forward.h"
+#include "base/memory/ref_counted.h"
+
+namespace tracked_objects {
+class Location;
+} // namespace tracked_objects
+
+namespace base {
+
+struct TaskRunnerTraits;
+
+// A TaskRunner is an object that runs posted tasks (in the form of
+// Closure objects). The TaskRunner interface provides a way of
+// decoupling task posting from the mechanics of how each task will be
+// run. TaskRunner provides very weak guarantees as to how posted
+// tasks are run (or if they're run at all). In particular, it only
+// guarantees:
+//
+// - Posting a task will not run it synchronously. That is, no
+// Post*Task method will call task.Run() directly.
+//
+// - Increasing the delay can only delay when the task gets run.
+// That is, increasing the delay may not affect when the task gets
+// run, or it could make it run later than it normally would, but
+// it won't make it run earlier than it normally would.
+//
+// TaskRunner does not guarantee the order in which posted tasks are
+// run, whether tasks overlap, or whether they're run on a particular
+// thread. Also it does not guarantee a memory model for shared data
+// between tasks. (In other words, you should use your own
+// synchronization/locking primitives if you need to share data
+// between tasks.)
+//
+// Implementations of TaskRunner should be thread-safe in that all
+// methods must be safe to call on any thread. Ownership semantics
+// for TaskRunners are in general not clear, which is why the
+// interface itself is RefCountedThreadSafe.
+//
+// Some theoretical implementations of TaskRunner:
+//
+// - A TaskRunner that uses a thread pool to run posted tasks.
+//
+// - A TaskRunner that, for each task, spawns a non-joinable thread
+// to run that task and immediately quit.
+//
+// - A TaskRunner that stores the list of posted tasks and has a
+// method Run() that runs each runnable task in random order.
+class BASE_EXPORT TaskRunner
+ : public RefCountedThreadSafe<TaskRunner, TaskRunnerTraits> {
+ public:
+ // Posts the given task to be run. Returns true if the task may be
+ // run at some point in the future, and false if the task definitely
+ // will not be run.
+ //
+ // Equivalent to PostDelayedTask(from_here, task, 0).
+ bool PostTask(const tracked_objects::Location& from_here,
+ const Closure& task);
+
+ // Like PostTask, but tries to run the posted task only after
+ // |delay_ms| has passed.
+ //
+ // It is valid for an implementation to ignore |delay_ms|; that is,
+ // to have PostDelayedTask behave the same as PostTask.
+ //
+ // TODO(akalin): Make PostDelayedTask use TimeDelta instead.
+ virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
+ const Closure& task,
+ int64 delay_ms) = 0;
+
+ // Returns true if the current thread is a thread on which a task
+ // may be run, and false if no task will be run on the current
+ // thread.
+ //
+ // It is valid for an implementation to always return true, or in
+ // general to use 'true' as a default value.
+ virtual bool RunsTasksOnCurrentThread() const = 0;
+
+ // Posts |task| on the current TaskRunner. On completion, |reply|
+ // is posted to the thread that called PostTaskAndReply(). Both
+ // |task| and |reply| are guaranteed to be deleted on the thread
+ // from which PostTaskAndReply() is invoked. This allows objects
+ // that must be deleted on the originating thread to be bound into
+ // the |task| and |reply| Closures. In particular, it can be useful
+ // to use WeakPtr<> in the |reply| Closure so that the reply
+ // operation can be canceled. See the following pseudo-code:
+ //
+ // class DataBuffer : public RefCountedThreadSafe<DataBuffer> {
+ // public:
+ // // Called to add data into a buffer.
+ // void AddData(void* buf, size_t length);
+ // ...
+ // };
+ //
+ //
+ // class DataLoader : public SupportsWeakPtr<DataLoader> {
+ // public:
+ // void GetData() {
+ // scoped_refptr<DataBuffer> buffer = new DataBuffer();
+ // target_thread_.message_loop_proxy()->PostTaskAndReply(
+ // FROM_HERE,
+ // base::Bind(&DataBuffer::AddData, buffer),
+ // base::Bind(&DataLoader::OnDataReceived, AsWeakPtr(), buffer));
+ // }
+ //
+ // private:
+ // void OnDataReceived(scoped_refptr<DataBuffer> buffer) {
+ // // Do something with buffer.
+ // }
+ // };
+ //
+ //
+ // Things to notice:
+ // * Results of |task| are shared with |reply| by binding a shared argument
+ // (a DataBuffer instance).
+ // * The DataLoader object has no special thread safety.
+ // * The DataLoader object can be deleted while |task| is still running,
+ // and the reply will cancel itself safely because it is bound to a
+ // WeakPtr<>.
+ bool PostTaskAndReply(const tracked_objects::Location& from_here,
+ const Closure& task,
+ const Closure& reply);
+
+ protected:
+ friend struct TaskRunnerTraits;
+
+ // Only the Windows debug build seems to need this: see
+ // http://crbug.com/112250.
+ friend class RefCountedThreadSafe<TaskRunner, TaskRunnerTraits>;
+
+ TaskRunner();
+ virtual ~TaskRunner();
+
+ // Called when this object should be destroyed. By default simply
+ // deletes |this|, but can be overridden to do something else, like
+ // delete on a certain thread.
+ virtual void OnDestruct() const;
+};
+
+struct BASE_EXPORT TaskRunnerTraits {
+ static void Destruct(const TaskRunner* task_runner);
+};
+
+} // namespace base
+
+#endif // BASE_TASK_RUNNER_H_