Add WorkerPool::PostTaskAndReply and use in DHCP code.

base/message_loop_proxy.cc

Index: base/message_loop_proxy.cc
diff --git a/base/message_loop_proxy.cc b/base/message_loop_proxy.cc
index c8217042fe6a540c2df3309d59a3caf7c1a389a2..f9b4ad89787fd730cf3ee31b04feca13417dc10e 100644
--- a/base/message_loop_proxy.cc
+++ b/base/message_loop_proxy.cc
@@ -5,64 +5,28 @@
 #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 {
 
-// 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 {
+class PostTaskAndReplyMessageLoopProxy : public internal::PostTaskAndReplyImpl {
  public:
-  PostTaskAndReplyRelay(const tracked_objects::Location& from_here,
-                        const Closure& task, const Closure& reply)
-      : from_here_(from_here),
-        origin_loop_(MessageLoopProxy::current()) {
-    task_ = task;
-    reply_ = reply;
-  }
-
-  ~PostTaskAndReplyRelay() {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
-    task_.Reset();
-    reply_.Reset();
-  }
-
-  void Run() {
-    task_.Run();
-    origin_loop_->PostTask(
-        from_here_,
-        Bind(&PostTaskAndReplyRelay::RunReplyAndSelfDestruct,
-             base::Unretained(this)));
+  PostTaskAndReplyMessageLoopProxy(MessageLoopProxy* destination)
+     : destination_(destination) {
   }
 
  private:
-  void RunReplyAndSelfDestruct() {
-    DCHECK(origin_loop_->BelongsToCurrentThread());
-
-    // Force |task_| to be released before |reply_| is to ensure that no one
-    // accidentally depends on |task_| keeping one of its arguments alive while
-    // |reply_| is executing.
-    task_.Reset();
-
-    reply_.Run();
-
-    // Cue mission impossible theme.
-    delete this;
+  virtual bool PostTask(const tracked_objects::Location& from_here,
+                        const base::Closure& task) OVERRIDE {
+    return destination_->PostTask(from_here, task);
   }
 
-  tracked_objects::Location from_here_;
-  scoped_refptr<MessageLoopProxy> origin_loop_;
-  Closure reply_;
-  Closure task_;
+  // Non-owning.
+  MessageLoopProxy* destination_;
 };
 
 }  // namespace
@@ -77,15 +41,8 @@ bool MessageLoopProxy::PostTaskAndReply(
     const tracked_objects::Location& from_here,
     const Closure& task,
     const Closure& reply) {
-  PostTaskAndReplyRelay* relay =
-      new PostTaskAndReplyRelay(from_here, task, reply);
-  if (!PostTask(from_here, Bind(&PostTaskAndReplyRelay::Run,
-                                Unretained(relay)))) {
-    delete relay;
-    return false;
-  }
-
-  return true;
+  return PostTaskAndReplyMessageLoopProxy(this).PostTaskAndReply(
+      from_here, task, reply);
 }
 
 void MessageLoopProxy::OnDestruct() const {