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 49 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 16 matching lines @@
 
 struct MessageLoopProxyTraits {
   static void Destruct(const MessageLoopProxy* proxy) {
     proxy->OnDestruct();
   }
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_PROXY_H_