Create base::WorkerPoolJob. Use it for HostResolverImpl and DirectoryLister.

base/worker_pool_job_unittest.cc

+// Copyright (c) 2010 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/worker_pool_job.h"
+
+#include "base/callback.h"
+#include "base/message_loop.h"
+#include "base/waitable_event.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+
+namespace {
+
+class TestCallback : public CallbackRunner<Tuple0> {
+ public:
+  TestCallback()
+      : have_run_(false),
+        waiting_for_run_(false) {
+  }
+
+  void Wait() {
+    DCHECK(!waiting_for_run_);

[Paweł Hajdan Jr., 2010/12/11 10:40:19]

This is a test, and DCHECK can make it crashy. How about using
ASSERT_FALSE(waiting_for_run_) instead?

[willchan no longer on Chromium, 2010/12/11 22:44:26]

Normally I'd agree.  In this case, this means we've made a pretty fundamental
error in use of the callback.  We're already waiting and we called Wait again. 
That means we're nesting the MessageLoop.  I'd be worried about causing crashes
elsewhere or worse, hanging the test (which would cause long timeouts).  So I'd
rather just crash here.

+    while (!have_run_) {
+      waiting_for_run_ = true;
+      MessageLoop::current()->Run();
+      waiting_for_run_ = false;
+    }
+    have_run_ = false;  // auto-reset for next callback
+  }
+
+  virtual void RunWithParams(const Tuple0& params) {
+    if (waiting_for_run_)
+      MessageLoop::current()->Quit();
+    have_run_ = true;
+  }
+
+ private:
+  bool have_run_;
+  bool waiting_for_run_;
+};
+
+class TestJob : public WorkerPoolJob {
+ public:
+  explicit TestJob(Callback0::Type* callback)
+      : WorkerPoolJob(false),
+        callback_(callback),
+        run_on_worker_pool_event_(true /* manual reset */,
+                                  false /* not initially signalled */) {}
+
+  void SignalOnWorkerPool() {
+    run_on_worker_pool_event_.Signal();
+  }
+
+  using WorkerPoolJob::StartJob;
+  using WorkerPoolJob::CancelJob;
+  using WorkerPoolJob::canceled;
+  using WorkerPoolJob::is_running;
+
+ protected:
+  ~TestJob() {}
+
+ private:
+  virtual void RunJob() {
+    run_on_worker_pool_event_.Wait();
+  }
+
+  virtual void CompleteJob() {
+    callback_->Run();
+  }
+
+  virtual void OnCanceled() {
+    scoped_refptr<MessageLoopProxy> loop = origin_loop();
+    if (loop->BelongsToCurrentThread()) {
+      callback_->Run();
+    } else {
+      loop->PostTask(
+          FROM_HERE,
+          NewRunnableMethod(this, &TestJob::OnCanceledOnOriginLoop));
+    }
+  }
+
+  void OnCanceledOnOriginLoop() {
+    callback_->Run();
+  }
+
+  Callback0::Type* const callback_;
+  WaitableEvent run_on_worker_pool_event_;
+};
+
+TEST(WorkerPoolJobTest, Simple) {
+  MessageLoop loop;
+  TestCallback callback;
+  scoped_refptr<TestJob> job(new TestJob(&callback));
+  job->StartJob();
+  EXPECT_TRUE(job->is_running());
+  job->SignalOnWorkerPool();
+  callback.Wait();
+  EXPECT_FALSE(job->canceled());
+  EXPECT_FALSE(job->is_running());
+}
+
+TEST(WorkerPoolJobTest, CancelOnWorker) {
+  MessageLoop loop;
+  TestCallback callback;
+  scoped_refptr<TestJob> job(new TestJob(&callback));
+  job->StartJob();
+  job->CancelJob();
+  EXPECT_TRUE(job->is_running());
+  job->SignalOnWorkerPool();
+  callback.Wait();
+  EXPECT_TRUE(job->canceled());
+  EXPECT_FALSE(job->is_running());
+}
+
+TEST(WorkerPoolJobTest, CancelOnOrigin) {
+  MessageLoop loop;
+  TestCallback callback;
+  scoped_refptr<TestJob> job(new TestJob(&callback));
+  job->StartJob();
+  EXPECT_TRUE(job->is_running());
+  job->SignalOnWorkerPool();
+  job->CancelJob();
+  callback.Wait();
+  EXPECT_TRUE(job->canceled());
+  EXPECT_FALSE(job->is_running());
+}
+
+}  // namespace
+
+}  // namespace base