Add WorkerPool::PostTaskAndReply and use in DHCP code.

net/proxy/dhcp_proxy_script_adapter_fetcher_win.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/bind.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/sys_string_conversions.h"
-#include "base/task.h"
 #include "base/threading/worker_pool.h"
 #include "base/time.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/dhcpcsvc_init_win.h"
 #include "net/proxy/proxy_script_fetcher_impl.h"
 #include "net/url_request/url_request_context.h"
 
 #include <windows.h>
 #include <winsock2.h>
 #include <dhcpcsdk.h>
@@ skipping 32 matching lines @@
     const std::string& adapter_name, OldCompletionCallback* callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(state_, STATE_START);
   result_ = ERR_IO_PENDING;
   pac_script_ = string16();
   state_ = STATE_WAIT_DHCP;
   callback_ = callback;
 
   wait_timer_.Start(FROM_HERE, ImplGetTimeout(),
                     this, &DhcpProxyScriptAdapterFetcher::OnTimeout);
-  worker_thread_ = ImplCreateWorkerThread(AsWeakPtr());
-  worker_thread_->Start(adapter_name);
+  scoped_refptr<DhcpQuery> dhcp_query(ImplCreateDhcpQuery());

[awong, 2011/10/07 17:53:22]

I wonder if it would be possible to not bother with the refcount here if you
delete dhcp_query on the reply.

Might make your unittest's lifetime management slightly harder though.

[Jói, 2011/10/11 19:51:02]

I think if this way works, it seems more correct?  And yes might complicate unit
testing.

+  base::WorkerPool::PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(
+          &DhcpProxyScriptAdapterFetcher::DhcpQuery::GetPacURLForAdapter,
+          dhcp_query.get(),

[awong, 2011/10/07 17:53:22]

FYI, You no longer need the .get().  Submitted CL yesterday to fix.

[Jói, 2011/10/11 19:51:02]

Done.

+          adapter_name),
+      base::Bind(
+          &DhcpProxyScriptAdapterFetcher::OnDhcpQueryDone,
+          AsWeakPtr(),
+          dhcp_query),
+      true);
 }
 
 void DhcpProxyScriptAdapterFetcher::Cancel() {
   DCHECK(CalledOnValidThread());
   callback_ = NULL;
   wait_timer_.Stop();
   script_fetcher_.reset();
 
   switch (state_) {
     case STATE_WAIT_DHCP:
@@ skipping 27 matching lines @@
 string16 DhcpProxyScriptAdapterFetcher::GetPacScript() const {
   DCHECK(CalledOnValidThread());
   return pac_script_;
 }
 
 GURL DhcpProxyScriptAdapterFetcher::GetPacURL() const {
   DCHECK(CalledOnValidThread());
   return pac_url_;
 }
 
-DhcpProxyScriptAdapterFetcher::WorkerThread::WorkerThread(
-    const base::WeakPtr<DhcpProxyScriptAdapterFetcher>& owner)
-        : owner_(owner),
-          origin_loop_(base::MessageLoopProxy::current()) {
+DhcpProxyScriptAdapterFetcher::DhcpQuery::DhcpQuery() {
 }
 
-DhcpProxyScriptAdapterFetcher::WorkerThread::~WorkerThread() {
+DhcpProxyScriptAdapterFetcher::DhcpQuery::~DhcpQuery() {
 }
 
-void DhcpProxyScriptAdapterFetcher::WorkerThread::Start(
+void DhcpProxyScriptAdapterFetcher::DhcpQuery::GetPacURLForAdapter(
     const std::string& adapter_name) {
-  bool succeeded = base::WorkerPool::PostTask(
-      FROM_HERE,
-      NewRunnableMethod(
-          this,
-          &DhcpProxyScriptAdapterFetcher::WorkerThread::ThreadFunc,
-          adapter_name),
-      true);
-  DCHECK(succeeded);
+  url_ = ImplGetPacURLFromDhcp(adapter_name);
 }
 
-void DhcpProxyScriptAdapterFetcher::WorkerThread::ThreadFunc(
-    const std::string& adapter_name) {
-  std::string url = ImplGetPacURLFromDhcp(adapter_name);
-
-  bool succeeded = origin_loop_->PostTask(
-      FROM_HERE,
-      NewRunnableMethod(
-          this,
-          &DhcpProxyScriptAdapterFetcher::WorkerThread::OnThreadDone,
-          url));
-  DCHECK(succeeded);
-}
-
-void DhcpProxyScriptAdapterFetcher::WorkerThread::OnThreadDone(
-    const std::string& url) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (owner_)
-    owner_->OnQueryDhcpDone(url);
+std::string DhcpProxyScriptAdapterFetcher::DhcpQuery::url() const {
+  return url_;
 }
 
 std::string
-    DhcpProxyScriptAdapterFetcher::WorkerThread::ImplGetPacURLFromDhcp(
+    DhcpProxyScriptAdapterFetcher::DhcpQuery::ImplGetPacURLFromDhcp(
         const std::string& adapter_name) {
   return DhcpProxyScriptAdapterFetcher::GetPacURLFromDhcp(adapter_name);
 }
 
-void DhcpProxyScriptAdapterFetcher::OnQueryDhcpDone(
-    const std::string& url) {
+void DhcpProxyScriptAdapterFetcher::OnDhcpQueryDone(
+    scoped_refptr<DhcpQuery> dhcp_query) {
   DCHECK(CalledOnValidThread());
   // Because we can't cancel the call to the Win32 API, we can expect
   // it to finish while we are in a few different states.  The expected
   // one is WAIT_DHCP, but it could be in CANCEL if Cancel() was called,
   // or FINISH if timeout occurred.
   DCHECK(state_ == STATE_WAIT_DHCP || state_ == STATE_CANCEL ||
          state_ == STATE_FINISH);
   if (state_ != STATE_WAIT_DHCP)
     return;
 
   wait_timer_.Stop();
 
-  pac_url_ = GURL(url);
+  pac_url_ = GURL(dhcp_query->url());
   if (pac_url_.is_empty() || !pac_url_.is_valid()) {
     result_ = ERR_PAC_NOT_IN_DHCP;
     TransitionToFinish();
   } else {
     state_ = STATE_WAIT_URL;
     script_fetcher_.reset(ImplCreateScriptFetcher());
     script_fetcher_->Fetch(pac_url_, &pac_script_, &script_fetcher_callback_);
   }
 }
 
@@ skipping 28 matching lines @@
 
 DhcpProxyScriptAdapterFetcher::State
     DhcpProxyScriptAdapterFetcher::state() const {
   return state_;
 }
 
 ProxyScriptFetcher* DhcpProxyScriptAdapterFetcher::ImplCreateScriptFetcher() {
   return new ProxyScriptFetcherImpl(url_request_context_);
 }
 
-DhcpProxyScriptAdapterFetcher::WorkerThread*
-    DhcpProxyScriptAdapterFetcher::ImplCreateWorkerThread(
-        const base::WeakPtr<DhcpProxyScriptAdapterFetcher>& owner) {
-  return new WorkerThread(owner);
+DhcpProxyScriptAdapterFetcher::DhcpQuery*
+    DhcpProxyScriptAdapterFetcher::ImplCreateDhcpQuery() {
+  return new DhcpQuery();
 }
 
 base::TimeDelta DhcpProxyScriptAdapterFetcher::ImplGetTimeout() const {
   return base::TimeDelta::FromMilliseconds(kTimeoutMs);
 }
 
 // static
 std::string DhcpProxyScriptAdapterFetcher::GetPacURLFromDhcp(
     const std::string& adapter_name) {
   EnsureDhcpcsvcInit();
@@ skipping 52 matching lines @@
     // Return only up to the first null in case of embedded NULLs; if the
     // server is giving us back a buffer with embedded NULLs, something is
     // broken anyway.
     return std::string(reinterpret_cast<const char *>(wpad_params.Data));
   }
 
   return "";
 }
 
 }  // namespace net