Switch to TimeDelta interfaces for process waiting functions in net and ipc.

net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 290 matching lines @@
   void PushBackAdapter(const std::string& adapter_name,
                        DhcpProxyScriptAdapterFetcher* fetcher) {
     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) {
+                                   base::TimeDelta fetch_delay) {
     scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
         new DummyDhcpProxyScriptAdapterFetcher(url_request_context()));
-    adapter_fetcher->Configure(did_finish, result, pac_script, fetch_delay_ms);
+    adapter_fetcher->Configure(
+        did_finish, result, pac_script, fetch_delay.InMilliseconds());
     PushBackAdapter(adapter_name, adapter_fetcher.release());
   }
 
   DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() OVERRIDE {
     ++num_fetchers_created_;
     return adapter_fetchers_[next_adapter_fetcher_index_++];
   }
 
   virtual AdapterQuery* ImplCreateAdapterQuery() OVERRIDE {
     DCHECK(adapter_query_);
     return adapter_query_.get();
   }
 
-  int ImplGetMaxWaitMs() OVERRIDE {
-    return max_wait_ms_;
+  base::TimeDelta ImplGetMaxWait() OVERRIDE {
+    return max_wait_;
   }
 
   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();
     adapter_query_ = new MockAdapterQuery();
-    max_wait_ms_ = TestTimeouts::tiny_timeout_ms();
+    max_wait_ = TestTimeouts::tiny_timeout();
   }
 
   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<MockAdapterQuery> adapter_query_;
 
-  int max_wait_ms_;
+  base::TimeDelta max_wait_;
   int num_fetchers_created_;
   base::WaitableEvent worker_finished_event_;
 };
 
 class FetcherClient {
 public:
   FetcherClient()
       : context_(new TestURLRequestContext),
         fetcher_(context_.get()),
         finished_(false),
@@ skipping 55 matching lines @@
   ASSERT_EQ(L"bingo", client->pac_text_);
 }
 
 TEST(DhcpProxyScriptFetcherWin, NormalCaseURLConfiguredOneAdapter) {
   FetcherClient client;
   TestNormalCaseURLConfiguredOneAdapter(&client);
 }
 
 void TestNormalCaseURLConfiguredMultipleAdapters(FetcherClient* client) {
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+      "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"",
+      base::TimeDelta::FromMilliseconds(1));
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "second", true, OK, L"bingo", 50);
+      "second", true, OK, L"bingo", base::TimeDelta::FromMilliseconds(50));
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "third", true, OK, L"rocko", 1);
+      "third", true, OK, L"rocko", base::TimeDelta::FromMilliseconds(1));
   client->RunTest();
   client->RunMessageLoopUntilComplete();
   ASSERT_EQ(OK, client->result_);
   ASSERT_EQ(L"bingo", client->pac_text_);
 }
 
 TEST(DhcpProxyScriptFetcherWin, NormalCaseURLConfiguredMultipleAdapters) {
   FetcherClient client;
   TestNormalCaseURLConfiguredMultipleAdapters(&client);
 }
 
 void TestNormalCaseURLConfiguredMultipleAdaptersWithTimeout(
     FetcherClient* client) {
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+      "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"",
+      base::TimeDelta::FromMilliseconds(1));
   // This will time out.
   client->fetcher_.ConfigureAndPushBackAdapter(
       "second", false, ERR_IO_PENDING, L"bingo",
-      TestTimeouts::action_timeout_ms());
+      TestTimeouts::action_timeout());
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "third", true, OK, L"rocko", 1);
+      "third", true, OK, L"rocko", base::TimeDelta::FromMilliseconds(1));
   client->RunTest();
   client->RunMessageLoopUntilComplete();
   ASSERT_EQ(OK, client->result_);
   ASSERT_EQ(L"rocko", client->pac_text_);
 }
 
 TEST(DhcpProxyScriptFetcherWin,
      NormalCaseURLConfiguredMultipleAdaptersWithTimeout) {
   FetcherClient client;
   TestNormalCaseURLConfiguredMultipleAdaptersWithTimeout(&client);
 }
 
 void TestFailureCaseURLConfiguredMultipleAdaptersWithTimeout(
     FetcherClient* client) {
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+      "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"",
+      base::TimeDelta::FromMilliseconds(1));
   // This will time out.
   client->fetcher_.ConfigureAndPushBackAdapter(
       "second", false, ERR_IO_PENDING, L"bingo",
-      TestTimeouts::action_timeout_ms());
+      TestTimeouts::action_timeout());
   // This is the first non-ERR_PAC_NOT_IN_DHCP error and as such
   // should be chosen.
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "third", true, ERR_PAC_STATUS_NOT_OK, L"", 1);
+      "third", true, ERR_PAC_STATUS_NOT_OK, L"",
+      base::TimeDelta::FromMilliseconds(1));
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "fourth", true, ERR_NOT_IMPLEMENTED, L"", 1);
+      "fourth", true, ERR_NOT_IMPLEMENTED, L"",
+      base::TimeDelta::FromMilliseconds(1));
   client->RunTest();
   client->RunMessageLoopUntilComplete();
   ASSERT_EQ(ERR_PAC_STATUS_NOT_OK, client->result_);
   ASSERT_EQ(L"", client->pac_text_);
 }
 
 TEST(DhcpProxyScriptFetcherWin,
      FailureCaseURLConfiguredMultipleAdaptersWithTimeout) {
   FetcherClient client;
   TestFailureCaseURLConfiguredMultipleAdaptersWithTimeout(&client);
 }
 
 void TestFailureCaseNoURLConfigured(FetcherClient* client) {
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+      "most_preferred", true, ERR_PAC_NOT_IN_DHCP, L"",
+      base::TimeDelta::FromMilliseconds(1));
   // This will time out.
   client->fetcher_.ConfigureAndPushBackAdapter(
       "second", false, ERR_IO_PENDING, L"bingo",
-      TestTimeouts::action_timeout_ms());
+      TestTimeouts::action_timeout());
   // This is the first non-ERR_PAC_NOT_IN_DHCP error and as such
   // should be chosen.
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "third", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+      "third", true, ERR_PAC_NOT_IN_DHCP, L"",
+      base::TimeDelta::FromMilliseconds(1));
   client->RunTest();
   client->RunMessageLoopUntilComplete();
   ASSERT_EQ(ERR_PAC_NOT_IN_DHCP, client->result_);
   ASSERT_EQ(L"", client->pac_text_);
 }
 
 TEST(DhcpProxyScriptFetcherWin, FailureCaseNoURLConfigured) {
   FetcherClient client;
   TestFailureCaseNoURLConfigured(&client);
 }
@@ skipping 10 matching lines @@
   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
   // time.  Verify that we complete quickly and do not wait for the slow
   // adapters, i.e. we finish before timeout.
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "1", true, ERR_PAC_NOT_IN_DHCP, L"", 1);
+      "1", true, ERR_PAC_NOT_IN_DHCP, L"",
+      base::TimeDelta::FromMilliseconds(1));
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "2", true, OK, L"bingo", 1);
+      "2", true, OK, L"bingo",
+      base::TimeDelta::FromMilliseconds(1));
   client->fetcher_.ConfigureAndPushBackAdapter(
-      "3", true, OK, L"wrongo", TestTimeouts::action_max_timeout_ms());
+      "3", true, OK, L"wrongo", TestTimeouts::action_max_timeout());
 
   // Increase the timeout to ensure the short circuit mechanism has
   // time to kick in before the timeout waiting for more adapters kicks in.
-  client->fetcher_.max_wait_ms_ = TestTimeouts::action_timeout_ms();
+  client->fetcher_.max_wait_ = TestTimeouts::action_timeout();
 
   PerfTimer timer;
   client->RunTest();
   client->RunMessageLoopUntilComplete();
   ASSERT_TRUE(client->fetcher_.HasPendingFetchers());
   // Assert that the time passed is definitely less than the wait timer
   // timeout, to get a second signal that it was the shortcut mechanism
   // (in OnFetcherDone) that kicked in, and not the timeout waiting for
   // more adapters.
-  ASSERT_GT(base::TimeDelta::FromMilliseconds(
-      client->fetcher_.max_wait_ms_ - (client->fetcher_.max_wait_ms_ / 10)),
-      timer.Elapsed());
+  ASSERT_GT(client->fetcher_.max_wait_ - (client->fetcher_.max_wait_ / 10),
+            timer.Elapsed());
 }
 
 TEST(DhcpProxyScriptFetcherWin, ShortCircuitLessPreferredAdapters) {
   FetcherClient client;
   TestShortCircuitLessPreferredAdapters(&client);
 }
 
 void TestImmediateCancel(FetcherClient* client) {
   TestURLRequestContext context;
   scoped_ptr<DummyDhcpProxyScriptAdapterFetcher> adapter_fetcher(
@@ skipping 46 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