Implementation of PostTaskAndReply() in MessageLoopProxy and BrowserThread.

base/message_loop_proxy.h

 // 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.
 
 #ifndef BASE_MESSAGE_LOOP_PROXY_H_
 #define BASE_MESSAGE_LOOP_PROXY_H_
 #pragma once
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
@@ skipping 52 matching lines @@
                                    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 simplifies logic when an operation needs to be executed on another
+  // thread, but processing of the result needs to occur on the current thread.
+  //
+  // Note that because of the lifetime guarantees on the |reply| Closure, it is
+  // perfectly valid to use a WeakPtr<> in the bound parameters for |reply|.
+  // This is useful if |reply| needs to be canceled on the originating thread
+  // while |task| may still be executing.
+  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,
                   T* object) {
     return PostNonNestableTask(from_here, new DeleteTask<T>(object));
   }
   template <class T>
   bool ReleaseSoon(const tracked_objects::Location& from_here,
                    T* object) {
     return PostNonNestableTask(from_here, new ReleaseTask<T>(object));
   }
@@ skipping 13 matching lines @@
   // to provide deletion on specific threads.
   virtual void OnDestruct() const;
 };
 
 struct MessageLoopProxyTraits {
   static void Destruct(const MessageLoopProxy* proxy) {
     proxy->OnDestruct();
   }
 };
 
+namespace internal {
+
+// This relay class remembers the MessageLoop that it was created on, and
+// ensures that both the |task| and |reply| Closures are deleted on this same
+// thread. Also, |task| is guaranteed to be deleted before |reply| is run or
+// deleted.
+//
+// If this is not possible because the originating MessageLoop is no longer
+// available, the the |task| and |reply| Closures are leaked.  Leaking is
+// considered preferable to having a thread-safetey violations caused by
+// invoking the Closure destructor on the wrong thread.
+class PostTaskAndReplyRelay {
+ public:
+  PostTaskAndReplyRelay(const tracked_objects::Location& from_here,
+                        const Closure& task, const Closure& reply);
+
+  ~PostTaskAndReplyRelay();
+
+  void Run();
+
+ private:
+  void RunReplyAndSelfDestruct();
+
+  tracked_objects::Location from_here_;
+  scoped_refptr<MessageLoopProxy> origin_loop_;
+  Closure reply_;
+  Closure task_;
+};
+
+}  // namespace internal
+
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_PROXY_H_