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

net/proxy/dhcp_proxy_script_adapter_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_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 17 matching lines @@
 // APIs and the network.  In this file we test only by stubbing out
 // functionality.
 
 // Version of DhcpProxyScriptAdapterFetcher that mocks out dependencies
 // to allow unit testing.
 class MockDhcpProxyScriptAdapterFetcher
     : public DhcpProxyScriptAdapterFetcher {
  public:
   explicit MockDhcpProxyScriptAdapterFetcher(URLRequestContext* context)
       : DhcpProxyScriptAdapterFetcher(context),
-        dhcp_delay_ms_(1),
-        timeout_ms_(TestTimeouts::action_timeout_ms()),
+        dhcp_delay_(base::TimeDelta::FromMilliseconds(1)),
+        timeout_(TestTimeouts::action_timeout()),
         configured_url_(kPacUrl),
         fetcher_delay_ms_(1),
         fetcher_result_(OK),
         pac_script_("bingo") {
   }
 
   void Cancel() {
     DhcpProxyScriptAdapterFetcher::Cancel();
     fetcher_ = NULL;
   }
@@ skipping 18 matching lines @@
     }
 
     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_;
+    base::TimeDelta dhcp_delay_;
     std::string configured_url_;
   };
 
   virtual DhcpQuery* ImplCreateDhcpQuery() OVERRIDE {
     dhcp_query_ = new DelayingDhcpQuery();
-    dhcp_query_->dhcp_delay_ = TimeDelta::FromMilliseconds(dhcp_delay_ms_);
+    dhcp_query_->dhcp_delay_ = dhcp_delay_;
     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_);
+    return timeout_;
   }
 
   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(dhcp_query_);
     dhcp_query_->test_finished_event_.Signal();
   }
 
-  int dhcp_delay_ms_;
-  int timeout_ms_;
+  base::TimeDelta dhcp_delay_;
+  base::TimeDelta timeout_;
   std::string configured_url_;
   int fetcher_delay_ms_;
   int fetcher_result_;
   std::string pac_script_;
   MockProxyScriptFetcher* fetcher_;
   base::OneShotTimer<MockDhcpProxyScriptAdapterFetcher> fetcher_timer_;
   scoped_refptr<DelayingDhcpQuery> dhcp_query_;
 };
 
 class FetcherClient {
@@ skipping 44 matching lines @@
 }
 
 TEST(DhcpProxyScriptAdapterFetcher, TimeoutDuringDhcp) {
   // Does a Fetch() with a long enough delay on accessing DHCP that the
   // fetcher should time out.  This is to test a case manual testing found,
   // where under certain circumstances (e.g. adapter enabled for DHCP and
   // needs to retrieve its configuration from DHCP, but no DHCP server
   // present on the network) accessing DHCP can take on the order of tens
   // of seconds.
   FetcherClient client;
-  client.fetcher_->dhcp_delay_ms_ = TestTimeouts::action_max_timeout_ms();
-  client.fetcher_->timeout_ms_ = 25;
+  client.fetcher_->dhcp_delay_ = TestTimeouts::action_max_timeout();
+  client.fetcher_->timeout_ = base::TimeDelta::FromMilliseconds(25);
 
   PerfTimer timer;
   client.RunTest();
   // An error different from this would be received if the timeout didn't
   // kick in.
   client.WaitForResult(ERR_TIMED_OUT);
 
   ASSERT_TRUE(client.fetcher_->DidFinish());
   EXPECT_EQ(ERR_TIMED_OUT, client.fetcher_->GetResult());
   EXPECT_EQ(string16(L""), client.fetcher_->GetPacScript());
@@ skipping 90 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