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:
+    MockWorkerThread() : worker_finished_event_(true, false) {
+    }
+
+    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;
+    }
+
+    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()) {
+      : DhcpProxyScriptFetcherWin(new TestURLRequestContext()),
+        num_fetchers_created_(0) {
     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 {
+    ++num_fetchers_created_;
     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;
+    num_fetchers_created_ = 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_;
+  int num_fetchers_created_;
 };
 
 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 RunMessageLoopUntilWorkerDone() {
+    DCHECK(fetcher_.worker_thread_.get());
+    while (!fetcher_.worker_thread_->worker_finished_event_.TimedWait(
+        base::TimeDelta::FromMilliseconds(10))) {
+      MessageLoop::current()->RunAllPending();
+    }
+  }
+
   void OnCompletion(int result) {
     finished_ = true;
     result_ = result;
   }
 
   void ResetTestState() {
     finished_ = false;
     result_ = ERR_UNEXPECTED;
     pac_text_ = L"";
     fetcher_.ResetTestState();
@@ skipping 106 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_);
+  ASSERT_EQ(0, client->fetcher_.num_fetchers_created_);
 }
 
 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 21 matching lines @@
   ASSERT_GT(base::TimeDelta::FromMilliseconds(
       client->fetcher_.max_wait_ms_ - (client->fetcher_.max_wait_ms_ / 10)),
       timer.Elapsed());
 }
 
 TEST(DhcpProxyScriptFetcherWin, ShortCircuitLessPreferredAdapters) {
   FetcherClient client;
   TestShortCircuitLessPreferredAdapters(&client);
 }
 
+void TestImmediateCancel(FetcherClient* client) {
+  scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
+      new DummyDhcpProxyScriptAdapterFetcher());
+  adapter_fetcher->Configure(true, OK, L"bingo", 1);
+  client->fetcher_.PushBackAdapter("a", adapter_fetcher.release());
+  client->RunTest();
+  client->fetcher_.Cancel();
+  client->RunMessageLoopUntilWorkerDone();
+  ASSERT_EQ(0, client->fetcher_.num_fetchers_created_);
+}
+
+// Regression test to check that when we cancel immediately, no
+// adapter fetchers get created.
+TEST(DhcpProxyScriptFetcherWin, ImmediateCancel) {
+  FetcherClient client;
+  TestImmediateCancel(&client);
+}
+
 TEST(DhcpProxyScriptFetcherWin, ReuseFetcher) {
   FetcherClient client;
 
   // The ProxyScriptFetcher interface stipulates that only a single
   // |Fetch()| may be in flight at once, but allows reuse, so test
   // that the state transitions correctly from done to start in all
   // cases we're testing.
 
   typedef void (*FetcherClientTestFunction)(FetcherClient*);
   typedef std::vector<FetcherClientTestFunction> TestVector;
   TestVector test_functions;
   test_functions.push_back(TestNormalCaseURLConfiguredOneAdapter);
   test_functions.push_back(TestNormalCaseURLConfiguredMultipleAdapters);
   test_functions.push_back(
       TestNormalCaseURLConfiguredMultipleAdaptersWithTimeout);
   test_functions.push_back(
       TestFailureCaseURLConfiguredMultipleAdaptersWithTimeout);
   test_functions.push_back(TestFailureCaseNoURLConfigured);
   test_functions.push_back(TestFailureCaseNoDhcpAdapters);
   test_functions.push_back(TestShortCircuitLessPreferredAdapters);
+  test_functions.push_back(TestImmediateCancel);
 
   std::random_shuffle(test_functions.begin(),
                       test_functions.end(),
                       base::RandGenerator);
   for (TestVector::const_iterator it = test_functions.begin();
        it != test_functions.end();
        ++it) {
     (*it)(&client);
     client.ResetTestState();
   }
 
   // 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