Add WorkerPool::PostTaskAndReply and use in DHCP code.

net/proxy/dhcp_proxy_script_fetcher_win_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 "net/proxy/dhcp_proxy_script_fetcher_win.h"
 
 #include <vector>
 
 #include "base/message_loop.h"
 #include "base/perftimer.h"
@@ skipping 142 matching lines @@
 
 // For RealFetchWithDeferredCancel, below.
 class DelayingDhcpProxyScriptAdapterFetcher
     : public DhcpProxyScriptAdapterFetcher {
  public:
   explicit DelayingDhcpProxyScriptAdapterFetcher(
       URLRequestContext* url_request_context)
       : DhcpProxyScriptAdapterFetcher(url_request_context) {
   }
 
-  class DelayingWorkerThread : public WorkerThread {
+  class DelayingDhcpQuery : public DhcpQuery {
    public:
-    explicit DelayingWorkerThread(
-        const base::WeakPtr<DhcpProxyScriptAdapterFetcher>& owner)
-        : WorkerThread(owner) {
+    explicit DelayingDhcpQuery()
+        : DhcpQuery() {
     }
 
     std::string ImplGetPacURLFromDhcp(
         const std::string& adapter_name) OVERRIDE {
       base::PlatformThread::Sleep(20);
-      return WorkerThread::ImplGetPacURLFromDhcp(adapter_name);
+      return DhcpQuery::ImplGetPacURLFromDhcp(adapter_name);
     }
   };
 
-  WorkerThread* ImplCreateWorkerThread(
-      const base::WeakPtr<DhcpProxyScriptAdapterFetcher>& owner) OVERRIDE {
-    return new DelayingWorkerThread(owner);
+  DhcpQuery* ImplCreateDhcpQuery() OVERRIDE {
+    return new DelayingDhcpQuery();
   }
 };
 
 // For RealFetchWithDeferredCancel, below.
 class DelayingDhcpProxyScriptFetcherWin
     : public DhcpProxyScriptFetcherWin {
  public:
   explicit DelayingDhcpProxyScriptFetcherWin(
       URLRequestContext* context)
       : DhcpProxyScriptFetcherWin(context) {
@@ skipping 71 matching lines @@
   bool did_finish_;
   int result_;
   string16 pac_script_;
   int fetch_delay_ms_;
   OldCompletionCallback* client_callback_;
   base::OneShotTimer<DummyDhcpProxyScriptAdapterFetcher> timer_;
 };
 
 class MockDhcpProxyScriptFetcherWin : public DhcpProxyScriptFetcherWin {
  public:
-  class MockWorkerThread : public WorkerThread {
+  class MockAdapterQuery : public AdapterQuery {
    public:
-    MockWorkerThread() : worker_finished_event_(true, false) {
+    MockAdapterQuery() {
     }
 
-    virtual ~MockWorkerThread() {
-    }
-
-    void Init(const base::WeakPtr<DhcpProxyScriptFetcherWin>& owner) {
-      WorkerThread::Init(owner);
+    virtual ~MockAdapterQuery() {
     }
 
     virtual bool ImplGetCandidateAdapterNames(
         std::set<std::string>* adapter_names) OVERRIDE {
       adapter_names->insert(
           mock_adapter_names_.begin(), mock_adapter_names_.end());
       return true;
     }
 
-    virtual void OnThreadDone() OVERRIDE {
-      WorkerThread::OnThreadDone();
-      worker_finished_event_.Signal();
-    }
-
     std::vector<std::string> mock_adapter_names_;
-    base::WaitableEvent worker_finished_event_;
   };
 
   MockDhcpProxyScriptFetcherWin()
       : DhcpProxyScriptFetcherWin(new TestURLRequestContext()),
-        num_fetchers_created_(0) {
+        num_fetchers_created_(0),
+        worker_finished_event_(true, false) {
     ResetTestState();
   }
 
   virtual ~MockDhcpProxyScriptFetcherWin() {
     ResetTestState();
   }
 
   // Adds a fetcher object to the queue of fetchers used by
   // |ImplCreateAdapterFetcher()|, and its name to the list of adapters
   // returned by ImplGetCandidateAdapterNames.
   void PushBackAdapter(const std::string& adapter_name,
                        DhcpProxyScriptAdapterFetcher* fetcher) {
-    worker_thread_->mock_adapter_names_.push_back(adapter_name);
+    adapter_query_->mock_adapter_names_.push_back(adapter_name);
     adapter_fetchers_.push_back(fetcher);
   }
 
   void ConfigureAndPushBackAdapter(const std::string& adapter_name,
                                    bool did_finish,
                                    int result,
                                    string16 pac_script,
                                    int fetch_delay_ms) {
     scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
         new DummyDhcpProxyScriptAdapterFetcher());
     adapter_fetcher->Configure(did_finish, result, pac_script, fetch_delay_ms);
     PushBackAdapter(adapter_name, adapter_fetcher.release());
   }
 
   DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() OVERRIDE {
     ++num_fetchers_created_;
     return adapter_fetchers_[next_adapter_fetcher_index_++];
   }
 
-  virtual WorkerThread* ImplCreateWorkerThread(
-      const base::WeakPtr<DhcpProxyScriptFetcherWin>& owner) OVERRIDE {
-    DCHECK(worker_thread_);
-    worker_thread_->Init(owner);
-    return worker_thread_.get();
+  virtual AdapterQuery* ImplCreateAdapterQuery() OVERRIDE {
+    DCHECK(adapter_query_);
+    return adapter_query_.get();
   }
 
   int ImplGetMaxWaitMs() OVERRIDE {
     return max_wait_ms_;
   }
 
+  void ImplOnGetCandidateAdapterNamesDone() OVERRIDE {
+    worker_finished_event_.Signal();
+  }
+
   void ResetTestState() {
     // Delete any adapter fetcher objects we didn't hand out.
     std::vector<DhcpProxyScriptAdapterFetcher*>::const_iterator it
         = adapter_fetchers_.begin();
     for (; it != adapter_fetchers_.end(); ++it) {
       if (num_fetchers_created_-- <= 0) {
         delete (*it);
       }
     }
 
     next_adapter_fetcher_index_ = 0;
     num_fetchers_created_ = 0;
     adapter_fetchers_.clear();
-    worker_thread_ = new MockWorkerThread();
+    adapter_query_ = new MockAdapterQuery();
     max_wait_ms_ = TestTimeouts::tiny_timeout_ms();
   }
 
   bool HasPendingFetchers() {
     return num_pending_fetchers() > 0;
   }
 
   int next_adapter_fetcher_index_;
 
   // Ownership gets transferred to the implementation class via
   // ImplCreateAdapterFetcher, but any objects not handed out are
   // deleted on destruction.
   std::vector<DhcpProxyScriptAdapterFetcher*> adapter_fetchers_;
 
-  scoped_refptr<MockWorkerThread> worker_thread_;
+  scoped_refptr<MockAdapterQuery> adapter_query_;
 
   int max_wait_ms_;
   int num_fetchers_created_;
+  base::WaitableEvent worker_finished_event_;
 };
 
 class FetcherClient {
 public:
   FetcherClient()
       : finished_(false),
         result_(ERR_UNEXPECTED),
         ALLOW_THIS_IN_INITIALIZER_LIST(
             completion_callback_(this, &FetcherClient::OnCompletion)) {
   }
 
   void RunTest() {
     int result = fetcher_.Fetch(&pac_text_, &completion_callback_);
     ASSERT_EQ(ERR_IO_PENDING, result);
   }
 
   void RunMessageLoopUntilComplete() {
     while (!finished_) {
       MessageLoop::current()->RunAllPending();
     }
     MessageLoop::current()->RunAllPending();
   }
 
   void RunMessageLoopUntilWorkerDone() {
-    DCHECK(fetcher_.worker_thread_.get());
-    while (!fetcher_.worker_thread_->worker_finished_event_.TimedWait(
+    DCHECK(fetcher_.adapter_query_.get());
+    while (!fetcher_.worker_finished_event_.TimedWait(
         base::TimeDelta::FromMilliseconds(10))) {
       MessageLoop::current()->RunAllPending();
     }
   }
 
   void OnCompletion(int result) {
     finished_ = true;
     result_ = result;
   }
 
@@ skipping 215 matching lines @@
   }
 
   // Re-do the first test to make sure the last test that was run did
   // not leave things in a bad state.
   (*test_functions.begin())(&client);
 }
 
 }  // namespace
 
 }  // namespace net