Removing command_execution_timeout_ms in favor of action_max_timeout_ms.

chrome/test/pyautolib/pyauto.py

 #!/usr/bin/python
 
 # 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.
 
 """PyAuto: Python Interface to Chromium's Automation Proxy.
 
 PyAuto uses swig to expose Automation Proxy interfaces to Python.
 For complete documentation on the functionality available,
@@ skipping 404 matching lines @@
     while timeout is None or time.time() - begin <= timeout:
       retval = function(*args)
       if (expect_retval is None and retval) or expect_retval == retval:
         return True
       logging.debug('WaitUntil(%s) still waiting. '
                     'Expecting %s. Last returned %s.' % (
                     function, expect_retval, retval))
       time.sleep(retry_sleep)
     return False
 
-  class CmdExecutionTimeoutChanger(object):
-    """Facilitate temporary changes to command_execution_timeout_ms.
+
+  class ActionTimeoutChanger(object):
+    """Facilitate temporary changes to action_timeout_ms.
 
     Automatically resets to original timeout when object is destroyed.
     """
-    _saved_timeout = -1  # Saved value for command_execution_timeout_ms
+    _saved_timeout = -1  # Saved value for action_timeout_ms
 
     def __init__(self, ui_test, new_timeout):
       """Initialize.
 
       Args:
         ui_test: a PyUITest object
         new_timeout: new timeout to use (in milli secs)
       """
-      self._saved_timeout = ui_test.command_execution_timeout_ms()
+      self._saved_timeout = ui_test.action_timeout_ms()
       if new_timeout != self._saved_timeout:
-        ui_test.set_command_execution_timeout_ms(new_timeout)
+        ui_test.set_action_timeout_ms(new_timeout)
       self._ui_test = ui_test
 
     def __del__(self):
       """Reset command_execution_timeout_ms to original value."""
-      if self._ui_test.command_execution_timeout_ms() != self._saved_timeout:
-        self._ui_test.set_command_execution_timeout_ms(self._saved_timeout)
+      if self._ui_test.action_timeout_ms() != self._saved_timeout:
+        self._ui_test.set_action_timeout_ms(self._saved_timeout)
 
 
-  def _GetResultFromJSONRequest(self, cmd_dict, windex=0):
+  def _GetResultFromJSONRequest(self, cmd_dict, windex=0, timeout=-1):
     """Issue call over the JSON automation channel and fetch output.
 
     This method packages the given dictionary into a json string, sends it
     over the JSON automation channel, loads the json output string returned,
     and returns it back as a dictionary.
 
     Args:
       cmd_dict: the command dictionary. It must have a 'command' key
                 Sample:
                   {
                     'command': 'SetOmniboxText',
                     'text': text,
                   }
       windex: 0-based window index on which to work. Default: 0 (first window)
               Use -ve windex if the automation command does not apply to a
               browser window. example: chromeos login
 
+      timeout: request timeout (in milliseconds)
+
     Returns:
       a dictionary for the output returned by the automation channel.
 
     Raises:
       pyauto_errors.JSONInterfaceError if the automation call returns an error.
     """
-    result = self._SendJSONRequest(windex, json.dumps(cmd_dict))
+    if timeout == -1:  # Default
+      timeout = self.action_max_timeout_ms()
+    result = self._SendJSONRequest(windex, json.dumps(cmd_dict), timeout)
     if len(result) == 0:
       raise JSONInterfaceError('Automation call received no response.')
     ret_dict = json.loads(result)
     if ret_dict.has_key('error'):
       raise JSONInterfaceError(ret_dict['error'])
     return ret_dict
 
   def GetBookmarkModel(self):
     """Return the bookmark model as a BookmarkModel object.
 
     This is a snapshot of the bookmark model; it is not a proxy and
     does not get updated as the bookmark model changes.
     """
     return bookmark_model.BookmarkModel(self._GetBookmarksAsJSON())
 
   def GetDownloadsInfo(self, windex=0):
     """Return info about downloads.
 
     This includes all the downloads recognized by the history system.
 
     Returns:
       an instance of downloads_info.DownloadInfo
     """
     return download_info.DownloadInfo(
         self._SendJSONRequest(
-            windex, json.dumps({'command': 'GetDownloadsInfo'})))
+            windex, json.dumps({'command': 'GetDownloadsInfo'}),
+            self.action_max_timeout_ms()))
 
   def GetOmniboxInfo(self, windex=0):
     """Return info about Omnibox.
 
     This represents a snapshot of the omnibox.  If you expect changes
     you need to call this method again to get a fresh snapshot.
     Note that this DOES NOT shift focus to the omnibox; you've to ensure that
     the omnibox is in focus or else you won't get any interesting info.
 
     It's OK to call this even when the omnibox popup is not showing.  In this
     case however, there won't be any matches, but other properties (like the
     current text in the omnibox) will still be fetched.
 
     Due to the nature of the omnibox, this function is sensitive to mouse
     focus.  DO NOT HOVER MOUSE OVER OMNIBOX OR CHANGE WINDOW FOCUS WHEN USING
     THIS METHOD.
 
     Args:
       windex: the index of the browser window to work on.
               Default: 0 (first window)
 
     Returns:
       an instance of omnibox_info.OmniboxInfo
     """
     return omnibox_info.OmniboxInfo(
         self._SendJSONRequest(windex,
-                              json.dumps({'command': 'GetOmniboxInfo'})))
+                              json.dumps({'command': 'GetOmniboxInfo'}),
+                              self.action_max_timeout_ms()))
 
   def SetOmniboxText(self, text, windex=0):
     """Enter text into the omnibox. This shifts focus to the omnibox.
 
     Args:
       text: the text to be set.
       windex: the index of the browser window to work on.
               Default: 0 (first window)
     """
     # Ensure that keyword data is loaded from the profile.
@@ skipping 181 matching lines @@
     """Return info about preferences.
 
     This represents a snapshot of the preferences. If you expect preferences
     to have changed, you need to call this method again to get a fresh
     snapshot.
 
     Returns:
       an instance of prefs_info.PrefsInfo
     """
     return prefs_info.PrefsInfo(
-        self._SendJSONRequest(0, json.dumps({'command': 'GetPrefsInfo'})))
+        self._SendJSONRequest(0, json.dumps({'command': 'GetPrefsInfo'}),
+                              self.action_max_timeout_ms()))
 
   def SetPrefs(self, path, value):
     """Set preference for the given path.
 
     Preferences are stored by Chromium as a hierarchical dictionary.
     dot-separated paths can be used to refer to a particular preference.
     example: "session.restore_on_startup"
 
     Some preferences are managed, that is, they cannot be changed by the
     user. It's upto the user to know which ones can be changed. Typically,
@@ skipping 37 matching lines @@
       'windowsKeyCode': key_code,
       'modifiers': 0,
       'windex': windex,
       'tab_index': tab_index,
     }
     # Sending two requests, one each for "key down" and "key up".
     self._GetResultFromJSONRequest(cmd_dict)
     cmd_dict['type'] = 3  # kKeyUpType
     self._GetResultFromJSONRequest(cmd_dict)
 
-  def WaitForAllDownloadsToComplete(self, windex=0):
+  def WaitForAllDownloadsToComplete(self, windex=0, timeout=-1):
     """Wait for all downloads to complete.
 
     Note: This method does not work for dangerous downloads. Use
     WaitForGivenDownloadsToComplete (below) instead.
     """
     cmd_dict = {'command': 'WaitForAllDownloadsToComplete'}
-    self._GetResultFromJSONRequest(cmd_dict, windex=windex)
+    self._GetResultFromJSONRequest(cmd_dict, windex=windex, timeout=timeout)
 
   def WaitForDownloadToComplete(self, download_path, timeout=-1):
     """Wait for the given downloads to complete.
 
     This method works for dangerous downloads as well as regular downloads.
 
     Args:
       download_path: The path to the final download. This is only necessary for
                      the workaround described in the comments below and should
                      be removed when downloads are re-implemented.
@@ skipping 274 matching lines @@
                    the chrome://history/ UI.
 
     Returns:
       an instance of history_info.HistoryInfo
     """
     cmd_dict = {  # Prepare command for the json interface
       'command': 'GetHistoryInfo',
       'search_text': search_text,
     }
     return history_info.HistoryInfo(
-        self._SendJSONRequest(0, json.dumps(cmd_dict)))
+        self._SendJSONRequest(0, json.dumps(cmd_dict),
+                              self.action_max_timeout_ms()))
 
   def GetTranslateInfo(self, tab_index=0, window_index=0):
     """Returns info about translate for the given page.
 
     If the translate bar is showing, also returns information about the bar.
 
     Args:
       tab_index: The tab index, default is 0.
       window_index: The window index, default is 0.
 
@@ skipping 316 matching lines @@
 
   def GetPluginsInfo(self):
     """Return info about plugins.
 
     This is the info available from about:plugins
 
     Returns:
       an instance of plugins_info.PluginsInfo
     """
     return plugins_info.PluginsInfo(
-        self._SendJSONRequest(0, json.dumps({'command': 'GetPluginsInfo'})))
+        self._SendJSONRequest(0, json.dumps({'command': 'GetPluginsInfo'}),
+                              self.action_max_timeout_ms()))
 
   def EnablePlugin(self, path):
     """Enable the plugin at the given path.
 
     Use GetPluginsInfo() to fetch path info about a plugin.
 
     Raises:
       pyauto_errors.JSONInterfaceError if the automation call returns an error.
     """
     cmd_dict = {
@@ skipping 1609 matching lines @@
     if self._options.verbose:
       verbosity = 2
     result = PyAutoTextTestRuner(verbosity=verbosity).run(pyauto_suite)
     del loaded_tests  # Need to destroy test cases before the suite
     del pyauto_suite
     sys.exit(not result.wasSuccessful())
 
 
 if __name__ == '__main__':
   Main()