Do GetAdaptersAddresses on a worker thread.

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 245 matching lines @@
   bool did_finish_;
   int result_;
   string16 pac_script_;
   int fetch_delay_ms_;
   CompletionCallback* client_callback_;
   base::OneShotTimer<DummyDhcpProxyScriptAdapterFetcher> timer_;
 };
 
 class MockDhcpProxyScriptFetcherWin : public DhcpProxyScriptFetcherWin {
  public:
+  class MockWorkerThread : public WorkerThread {
+   public:
+    virtual ~MockWorkerThread() {
+    }
+
+    void Init(const base::WeakPtr<DhcpProxyScriptFetcherWin>& owner) {
+      WorkerThread::Init(owner);
+    }
+
+    virtual bool ImplGetCandidateAdapterNames(
+        std::set<std::string>* adapter_names) OVERRIDE {
+      adapter_names->insert(
+          mock_adapter_names_.begin(), mock_adapter_names_.end());
+      return true;
+    }
+
+    std::vector<std::string> mock_adapter_names_;
+  };
+
   MockDhcpProxyScriptFetcherWin()
       : DhcpProxyScriptFetcherWin(new TestURLRequestContext()) {
     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) {
-    adapter_names_.push_back(adapter_name);
+    worker_thread_->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 {
     return adapter_fetchers_[next_adapter_fetcher_index_++];
   }
 
-  bool ImplGetCandidateAdapterNames(
-      std::set<std::string>* adapter_names) OVERRIDE {
-    adapter_names->insert(adapter_names_.begin(), adapter_names_.end());
-    return true;
+  virtual WorkerThread* ImplCreateWorkerThread(
+      const base::WeakPtr<DhcpProxyScriptFetcherWin>& owner) OVERRIDE {
+    DCHECK(worker_thread_);
+    worker_thread_->Init(owner);
+    return worker_thread_.get();
   }
 
   int ImplGetMaxWaitMs() OVERRIDE {
     return max_wait_ms_;
   }
 
   void ResetTestState() {
     next_adapter_fetcher_index_ = 0;
     adapter_fetchers_.clear();
-    // String pointers contained herein will have been freed during test.
-    adapter_names_.clear();
+    worker_thread_ = new MockWorkerThread();
     max_wait_ms_ = TestTimeouts::tiny_timeout_ms();
   }
 
   bool HasPendingFetchers() {
     return num_pending_fetchers() > 0;
   }
 
   int next_adapter_fetcher_index_;
 
   // Ownership is not here; it gets transferred to the implementation
   // class via ImplCreateAdapterFetcher.
   std::vector<DhcpProxyScriptAdapterFetcher*> adapter_fetchers_;
 
-  std::vector<std::string> adapter_names_;
+  scoped_refptr<MockWorkerThread> worker_thread_;
 
   int max_wait_ms_;
 };
 
 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 RunImmediateReturnTest() {
-    int result = fetcher_.Fetch(&pac_text_, &completion_callback_);
-    ASSERT_EQ(ERR_PAC_NOT_IN_DHCP, result);
-  }
-
   void RunMessageLoopUntilComplete() {
     while (!finished_) {
       MessageLoop::current()->RunAllPending();
     }
     MessageLoop::current()->RunAllPending();
   }
 
   void OnCompletion(int result) {
     finished_ = true;
     result_ = result;
@@ skipping 113 matching lines @@
   ASSERT_EQ(ERR_PAC_NOT_IN_DHCP, client->result_);
   ASSERT_EQ(L"", client->pac_text_);
 }
 
 TEST(DhcpProxyScriptFetcherWin, FailureCaseNoURLConfigured) {
   FetcherClient client;
   TestFailureCaseNoURLConfigured(&client);
 }
 
 void TestFailureCaseNoDhcpAdapters(FetcherClient* client) {
-  client->RunImmediateReturnTest();
-  // In case there are any pending messages that get us in a bad state
-  // (there shouldn't be).
-  MessageLoop::current()->RunAllPending();
+  client->RunTest();
+  client->RunMessageLoopUntilComplete();
+  ASSERT_EQ(ERR_PAC_NOT_IN_DHCP, client->result_);
+  ASSERT_EQ(L"", client->pac_text_);
 }
 
 TEST(DhcpProxyScriptFetcherWin, FailureCaseNoDhcpAdapters) {
   FetcherClient client;
   TestFailureCaseNoDhcpAdapters(&client);
 }
 
 void TestShortCircuitLessPreferredAdapters(FetcherClient* client) {
   // Here we have a bunch of adapters; the first reports no PAC in DHCP,
   // the second responds quickly with a PAC file, the rest take a long
@@ skipping 60 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