Switch to TimeDelta interfaces in chrome automation test infrastructure.

chrome/test/automation/proxy_launcher.h

 // 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.
 
 #ifndef CHROME_TEST_AUTOMATION_PROXY_LAUNCHER_H_
 #define CHROME_TEST_AUTOMATION_PROXY_LAUNCHER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 87 matching lines @@
   // Terminates the browser, simulates end of session.
   void TerminateBrowser();
 
   // Check that no processes related to Chrome exist, displaying
   // the given message if any do.
   void AssertAppNotRunning(const std::string& error_message);
 
   // Wait for the browser process to shut down on its own (i.e. as a result of
   // some action that your test has taken). If it has exited within |timeout|,
   // puts the exit code in |exit_code| and returns true.
-  bool WaitForBrowserProcessToQuit(int timeout, int* exit_code);
+  bool WaitForBrowserProcessToQuit(base::TimeDelta timeout, int* exit_code);
 
   AutomationProxy* automation() const;
 
   // Return the user data directory being used by the browser instance.
   FilePath user_data_dir() const;
 
   // Get the handle of browser process connected to the automation. This
   // function only returns a reference to the handle so the caller does not
   // own the handle returned.
   base::ProcessHandle process() const;
 
   // Return the process id of the browser process (-1 on error).
   base::ProcessId process_id() const;
 
   // Return the time when the browser was run.
   base::TimeTicks browser_launch_time() const;
 
   // Return how long the shutdown took.
   base::TimeDelta browser_quit_time() const;
 
   // Sets the shutdown type, which defaults to WINDOW_CLOSE.
   void set_shutdown_type(ShutdownType value) {
     shutdown_type_ = value;
   }
 
  protected:
   // Creates an automation proxy.
   virtual AutomationProxy* CreateAutomationProxy(
-      int execution_timeout) = 0;
+      base::TimeDelta execution_timeout) = 0;
 
   // Returns the automation proxy's channel with any prefixes prepended,
   // for passing as a command line parameter over to the browser.
   virtual std::string PrefixedChannelID() const = 0;
 
   // Paired with ConnectToRunningBrowser().
   // Disconnects the testing IPC from the browser.
   void DisconnectFromRunningBrowser();
 
  private:
@@ skipping 63 matching lines @@
 // This is used if you want to connect an AutomationProxy
 // to a browser process that is already running.
 // The channel id of the proxy is a constant specified by kInterfacePath.
 class NamedProxyLauncher : public ProxyLauncher {
  public:
   // If launch_browser is true, launches Chrome with named interface enabled.
   // Otherwise, there should be an existing instance the proxy can connect to.
   NamedProxyLauncher(const std::string& channel_id,
                      bool launch_browser, bool disconnect_on_failure);
 
-  virtual AutomationProxy* CreateAutomationProxy(int execution_timeout);
+  virtual AutomationProxy* CreateAutomationProxy(
+      base::TimeDelta execution_timeout);
   virtual bool InitializeConnection(
       const LaunchState& state,
       bool wait_for_initial_loads) OVERRIDE WARN_UNUSED_RESULT;
   virtual void TerminateConnection();
   virtual std::string PrefixedChannelID() const;
 
  protected:
   std::string channel_id_;      // Channel id of automation proxy.
   bool launch_browser_;         // True if we should launch the browser too.
   bool disconnect_on_failure_;  // True if we disconnect on IPC channel failure.
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NamedProxyLauncher);
 };
 
 // Uses an automation proxy that communicates over an anonymous socket.
 class AnonymousProxyLauncher : public ProxyLauncher {
  public:
   explicit AnonymousProxyLauncher(bool disconnect_on_failure);
-  virtual AutomationProxy* CreateAutomationProxy(int execution_timeout);
+  virtual AutomationProxy* CreateAutomationProxy(
+      base::TimeDelta execution_timeout);
   virtual bool InitializeConnection(
       const LaunchState& state,
       bool wait_for_initial_loads) OVERRIDE WARN_UNUSED_RESULT;
   virtual void TerminateConnection();
   virtual std::string PrefixedChannelID() const;
 
  protected:
   std::string channel_id_;      // Channel id of automation proxy.
   bool disconnect_on_failure_;  // True if we disconnect on IPC channel failure.
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AnonymousProxyLauncher);
 };
 
 #endif  // CHROME_TEST_AUTOMATION_PROXY_LAUNCHER_H_