Add WorkerPool::PostTaskAndReply and use in DHCP code.

net/proxy/dhcp_proxy_script_adapter_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_adapter_fetcher_win.h"
 
 #include "base/perftimer.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/timer.h"
@@ skipping 42 matching lines @@
     // the caller.
     fetcher_ = new MockProxyScriptFetcher();
     if (fetcher_delay_ms_ != -1) {
       fetcher_timer_.Start(FROM_HERE,
           base::TimeDelta::FromMilliseconds(fetcher_delay_ms_),
           this, &MockDhcpProxyScriptAdapterFetcher::OnFetcherTimer);
     }
     return fetcher_;
   }
 
-  class DelayingWorkerThread : public WorkerThread {
+  class DelayingDhcpQuery : public DhcpQuery {
    public:
-    explicit DelayingWorkerThread(
-        const base::WeakPtr<DhcpProxyScriptAdapterFetcher>& owner)
-        : WorkerThread(owner),
+    explicit DelayingDhcpQuery()
+        : DhcpQuery(),
           test_finished_event_(true, false) {
     }
 
     std::string ImplGetPacURLFromDhcp(
         const std::string& adapter_name) OVERRIDE {
       PerfTimer timer;
       test_finished_event_.TimedWait(dhcp_delay_);
       return configured_url_;
     }
 
     base::WaitableEvent test_finished_event_;
     TimeDelta dhcp_delay_;
     std::string configured_url_;
   };
 
-  virtual WorkerThread* ImplCreateWorkerThread(
-      const base::WeakPtr<DhcpProxyScriptAdapterFetcher>& owner) OVERRIDE {
-    worker_thread_ = new DelayingWorkerThread(owner);
-    worker_thread_->dhcp_delay_ = TimeDelta::FromMilliseconds(dhcp_delay_ms_);
-    worker_thread_->configured_url_ = configured_url_;
-    return worker_thread_;
+  virtual DhcpQuery* ImplCreateDhcpQuery() OVERRIDE {
+    dhcp_query_ = new DelayingDhcpQuery();
+    dhcp_query_->dhcp_delay_ = TimeDelta::FromMilliseconds(dhcp_delay_ms_);
+    dhcp_query_->configured_url_ = configured_url_;
+    return dhcp_query_;
   }
 
   // Use a shorter timeout so tests can finish more quickly.
   virtual base::TimeDelta ImplGetTimeout() const OVERRIDE {
     return base::TimeDelta::FromMilliseconds(timeout_ms_);
   }
 
   void OnFetcherTimer() {
     // Note that there is an assumption by this mock implementation that
     // DhcpProxyScriptAdapterFetcher::Fetch will call ImplCreateScriptFetcher
     // and call Fetch on the fetcher before the message loop is re-entered.
     // This holds true today, but if you hit this DCHECK the problem can
     // possibly be resolved by having a separate subclass of
     // MockProxyScriptFetcher that adds the delay internally (instead of
     // the simple approach currently used in ImplCreateScriptFetcher above).
     DCHECK(fetcher_ && fetcher_->has_pending_request());
     fetcher_->NotifyFetchCompletion(fetcher_result_, pac_script_);
     fetcher_ = NULL;
   }
 
   bool IsWaitingForFetcher() const {
     return state() == STATE_WAIT_URL;
   }
 
   bool WasCancelled() const {
     return state() == STATE_CANCEL;
   }
 
   void FinishTest() {
-    DCHECK(worker_thread_);
-    worker_thread_->test_finished_event_.Signal();
+    DCHECK(dhcp_query_);
+    dhcp_query_->test_finished_event_.Signal();
   }
 
   int dhcp_delay_ms_;
   int timeout_ms_;
   std::string configured_url_;
   int fetcher_delay_ms_;
   int fetcher_result_;
   std::string pac_script_;
   MockProxyScriptFetcher* fetcher_;
   base::OneShotTimer<MockDhcpProxyScriptAdapterFetcher> fetcher_timer_;
-  scoped_refptr<DelayingWorkerThread> worker_thread_;
+  scoped_refptr<DelayingDhcpQuery> dhcp_query_;
 };
 
 class FetcherClient {
  public:
   FetcherClient()
       : url_request_context_(new TestURLRequestContext()),
         fetcher_(
             new MockDhcpProxyScriptAdapterFetcher(url_request_context_.get())) {
   }
 
@@ skipping 149 matching lines @@
   ASSERT_TRUE(client.fetcher_->DidFinish());
   EXPECT_EQ(OK, client.fetcher_->GetResult());
   EXPECT_EQ(string16(L"-downloadable.pac-\n"), client.fetcher_->GetPacScript());
   EXPECT_EQ(configured_url,
             client.fetcher_->GetPacURL());
 }
 
 }  // namespace
 
 }  // namespace net