Add WorkerPool::PostTaskAndReply and use in DHCP code.

base/threading/worker_pool_unittest.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/threading/worker_pool.h"
 
+#include "base/bind.h"
 #include "base/location.h"
+#include "base/message_loop.h"
 #include "base/task.h"
+#include "base/test/test_timeouts.h"
+#include "base/time.h"
+#include "base/threading/thread_checker_impl.h"
 #include "base/synchronization/waitable_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 typedef PlatformTest WorkerPoolTest;
 
 namespace base {
 
 namespace {
 
 class PostTaskTestTask : public Task {
  public:
   explicit PostTaskTestTask(WaitableEvent* event) : event_(event) {
   }
 
   void Run() {
     event_->Signal();
   }
 
  private:
   WaitableEvent* event_;
 };
 
+class PostTaskAndReplyTester
+    : public base::RefCountedThreadSafe<PostTaskAndReplyTester> {
+ public:
+  PostTaskAndReplyTester() : finished_(false), test_event_(false, false) {
+  }
+
+  void RunTest() {
+    ASSERT_TRUE(thread_checker_.CalledOnValidThread());
+    WorkerPool::PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(&PostTaskAndReplyTester::OnWorkerThread, this),
+      base::Bind(&PostTaskAndReplyTester::OnOriginalThread, this),
+      false);
+
+    bool signaled = test_event_.Wait();
+    EXPECT_TRUE(signaled);
+
+    const TimeDelta kMaxDuration =
+        TimeDelta::FromMilliseconds(TestTimeouts::tiny_timeout_ms());
+    TimeTicks start = TimeTicks::Now();
+    while (!finished_ && TimeTicks::Now() - start < kMaxDuration) {
+      MessageLoop::current()->RunAllPending();

[awong, 2011/10/05 17:27:01]

Feels cleaner to me to have the waiting logic out in the main test, pass the
messageloop into the test directly, and then call ml->Quit() (as opposed to
ML::current()->Quit()) inside the test instead.

Otherwise reading the top-level TEST_F, I ask "why did we just declare a
MessageLoop and not use it anywhere?  Or right...people can touch the global..".

[Jói, 2011/10/06 14:20:31]

Done.

+    }
+    EXPECT_TRUE(finished_);
+  }
+
+  void OnWorkerThread() {
+    // We're not on the original thread.
+    EXPECT_FALSE(thread_checker_.CalledOnValidThread());
+
+    test_event_.Signal();
+  }
+
+  void OnOriginalThread() {
+    EXPECT_TRUE(thread_checker_.CalledOnValidThread());
+    finished_ = true;
+  }
+
+ private:
+  bool finished_;
+  WaitableEvent test_event_;
+
+  // The Impl version performs its checks even in release builds.
+  ThreadCheckerImpl thread_checker_;
+};
+
 }  // namespace
 
 TEST_F(WorkerPoolTest, PostTask) {
   WaitableEvent test_event(false, false);
   WaitableEvent long_test_event(false, false);
   bool signaled;
 
   WorkerPool::PostTask(FROM_HERE, new PostTaskTestTask(&test_event), false);
   WorkerPool::PostTask(FROM_HERE, new PostTaskTestTask(&long_test_event), true);
 
   signaled = test_event.Wait();
   EXPECT_TRUE(signaled);
   signaled = long_test_event.Wait();
   EXPECT_TRUE(signaled);
 }
 
+TEST_F(WorkerPoolTest, PostTaskAndReply) {
+  MessageLoop message_loop;
+  scoped_refptr<PostTaskAndReplyTester> tester(new PostTaskAndReplyTester());
+  tester->RunTest();
+}
+
 }  // namespace base