Implementation of PostTaskAndReply() in MessageLoopProxy and BrowserThread.

base/task.cc

 // Copyright (c) 2011 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.h"
 
 #include "base/bind.h"
+#include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 
 Task::Task() {
 }
 
 Task::~Task() {
 }
 
 CancelableTask::CancelableTask() {
 }
 
 CancelableTask::~CancelableTask() {
 }
 
 namespace base {
 
+namespace internal {
+
+PostTaskAndReplyRelay::PostTaskAndReplyRelay(
+    const tracked_objects::Location& from_here,
+    const Closure& task,
+    const Closure& reply)
+    : from_here_(from_here),
+      origin_loop_(MessageLoopProxy::CreateForCurrentThread()) {
+  task_ = task;
+  reply_ = reply;
+}
+
+PostTaskAndReplyRelay::~PostTaskAndReplyRelay() {
+  DCHECK(origin_loop_->BelongsToCurrentThread());
+}
+
+void PostTaskAndReplyRelay::Run() {
+  task_.Run();
+  origin_loop_->PostTask(
+      from_here_,
+      Bind(&PostTaskAndReplyRelay::RunReplyAndSelfDestruct, this));
+}
+
+void PostTaskAndReplyRelay::RunReplyAndSelfDestruct() {
+  DCHECK(origin_loop_->BelongsToCurrentThread());
+  reply_.Run();
+
+  // Cue mission impossible theme.
+  //
+  // Even though PostTaskAndReplyRelay is refcounted, dropping the references
+  // here is preferable because it eliminates the chance that other tasks can
+  // interceed between the execution of reply_ and the destruction of the
+  // Closures.
+  task_.Reset();
+  reply_.Reset();
+}
+
+void PostTaskAndReplyRelay::DoManualDestruction(
+    const PostTaskAndReplyRelay* obj) {
+  obj->origin_loop_->DeleteSoon(obj->from_here_, obj);
+}
+
+}  // namespace internal
+
 ScopedTaskRunner::ScopedTaskRunner(Task* task) : task_(task) {
 }
 
 ScopedTaskRunner::~ScopedTaskRunner() {
   if (task_) {
     task_->Run();
     delete task_;
   }
 }
 
 Task* ScopedTaskRunner::Release() {
   Task* tmp = task_;
   task_ = NULL;
   return tmp;
 }
 
-namespace internal {
-
-PostTaskAndReplyRelay::PostTaskAndReplyRelay(const Closure& task,
-                                             const Closure& reply)
-    : task_(task),
-      reply_(reply),
-      origin_loop_(MessageLoop::Current()) {
+void PostTaskAndReply(MessageLoop* loop,

[willchan no longer on Chromium, 2011/07/06 22:10:26]

We should use MessageLoopProxy here.

[awong, 2011/08/15 22:07:55]

New CL side-steps this issue.

+                      const tracked_objects::Location& from_here,
+                      const Closure& task,
+                      const Closure& reply) {
+  internal::PostTaskAndReplyRelay* relay =
+      new internal::PostTaskAndReplyRelay(from_here, task, reply);
+  loop->PostTask(from_here,
+                 Bind(&internal::PostTaskAndReplyRelay::Run, relay));
 }
 
-PostTaskAndReplyRelay::~PostTaskAndReplyRelay() {
-  DCHECK(origin_loop_ == MessageLoop::Current());
-}
-
-void PostTaskAndReplyRelay::Run() {
-  task_.Run();
-  origin_loop_->PostTask(
-      base::Bind(&PostTaskAndReplyRelay::RunReplyAndSelfDestruct,
-                 base::Unretained(this)));
-}
-
-void PostTaskAndReplyRelay::RunReplyAndSelfDestruct() {
-  reply_.Run();
-  delete this;
-}
-}  // namespace internal
-
-
 }  // namespace base