Add more diagnostic tracing when a JSON call doesn't return.

chrome/test/pyautolib/pyauto.py

 #!/usr/bin/env python
 # 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.
 
 """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,
 run pydoc on this file.
@@ skipping 917 matching lines @@
       """
       self._ui_test = ui_test
       self.view = view
       self.frame_xpath = frame_xpath
 
     def Execute(self, script):
       """Execute script in the render view."""
       return self._ui_test.ExecuteJavascriptInRenderView(script,
                                                          self.view,
                                                          self.frame_xpath)
+  def _GetResultFromJSONRequestDiagnostics(self, cmd_dict, windex=0,
+                                           timeout=-1):
+    """Same as _GetResultFromJSONRequest without throwing a timeout exception.
+
+    This method is used to diagnose if a command returns without causing a
+    timout exception to be thrown.  This should be used for debugging purposes
+    only.
+
+    Returns:
+      True if the request returned; False if it timed out.
+    """
+    if timeout == -1:  # Default
+      timeout = self.action_max_timeout_ms()
+    if windex is None:  # Do not target any window
+      windex = -1
+    result = self._SendJSONRequest(windex, json.dumps(cmd_dict), timeout)
+    if not result:
+      # The diagnostic command did not complete, Chrome is probably in a bad
+      # state
+      return False
+    return True
 
   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
@@ skipping 16 matching lines @@
     """
     if timeout == -1:  # Default
       timeout = self.action_max_timeout_ms()
     if windex is None:  # Do not target any window
       windex = -1
     result = self._SendJSONRequest(windex, json.dumps(cmd_dict), timeout)
     if not result:
       additional_info = 'No information available.'
       # Windows does not support os.kill until Python 2.7.
       if not self.IsWin() and _BROWSER_PID:
-        additional_info = ('The browser process ID %d still exists. '
-                           'It is possible that it is hung.' % _BROWSER_PID)
+        browser_pid_exists = True
+        # Does the browser PID exist?
         try:
           # Does not actually kill the process
           os.kill(int(_BROWSER_PID), 0)
         except OSError:
-          additional_info = ('The browser process ID %d no longer exists.' %
-                             _BROWSER_PID)
+          browser_pid_exists = False
+        if browser_pid_exists:
+          info = GetBrowserInfo(self, performing_diagnostics=True)
+          if info:
+            # Browser info, worked, that means this hook had a problem
+            additional_info = ('The browser process ID %d still exists. '
+                               'PyAuto was able to get obtain browser info. It '
+                               'is possible this hook is broken.'

[Nirnimesh, 2012/04/12 23:04:07]

add a name to the hook: cmd_dict.get('command')

+                               % _BROWSER_PID)
+          else:
+            additional_info = ('The browser process ID %d still exists. '
+                               'PyAuto was not able to obtain browser info. '
+                               'It is possible the browser is hung.'
+                               % _BROWSER_PID)
+        else:
+          additional_info = ('The browser process ID %d no longer exists. '
+                             'Perhaps the browser crashed.' % _BROWSER_PID)
       elif not _BROWSER_PID:
         additional_info = ('The browser PID was not obtained. Does this test '
                            'have a unique startup configuration?')
       # Mask private data if it is in the JSON dictionary
       cmd_dict_copy = copy.copy(cmd_dict)
       if 'password' in cmd_dict_copy.keys():
         cmd_dict_copy['password'] = '**********'
       if 'username' in cmd_dict_copy.keys():
         cmd_dict_copy['username'] = 'removed_username'
       raise JSONInterfaceError('Automation call %s received empty response.  '
@@ skipping 595 matching lines @@
     cmd_dict = {
       'command': 'PerformActionOnInfobar',
       'action': action,
       'infobar_index': infobar_index,
       'tab_index': tab_index,
     }
     if action not in ('dismiss', 'accept', 'cancel'):
       raise JSONInterfaceError('Invalid action %s' % action)
     self._GetResultFromJSONRequest(cmd_dict, windex=windex)
 
-  def GetBrowserInfo(self):
+  def GetBrowserInfo(self, performing_diagnostics=False):

[Nirnimesh, 2012/04/12 23:04:07]

I don't like that you're picking between the 2 methods, based on this flag. I
think you should leave this as-is, and..
1. Make your new diagnostic function be a wrapper around
_GetResultFromJSONRequest() and force it to call with cmd_dict {'command':
'GetBrowserInfo', 'windex': 0}

     """Return info about the browser.
 
     This includes things like the version number, the executable name,
     executable path, pid info about the renderer/plugin/extension processes,
     window dimensions. (See sample below)
 
     For notification pid info, see 'GetActiveNotifications'.
 
+    Args:
+      performing_diagnostics: This is only used when we are trying to debug why
+                              the previous hook failed to return.
+
     Returns:
       a dictionary
 
       Sample:
       { u'browser_pid': 93737,
         # Child processes are the processes for plugins and other workers.
         u'child_process_path': u'.../Chromium.app/Contents/'
                                 'Versions/6.0.412.0/Chromium Helper.app/'
                                 'Contents/MacOS/Chromium Helper',
         u'child_processes': [ { u'name': u'Shockwave Flash',
@@ skipping 58 matching lines @@
                         u'width': 925,
                         u'x': 26,
                         u'y': 44}]}
 
     Raises:
       pyauto_errors.JSONInterfaceError if the automation call returns an error.
     """
     cmd_dict = {  # Prepare command for the json interface
       'command': 'GetBrowserInfo',
     }
+    if performing_diagnostics:
+      self._GetResultFromJSONRequestDiagnostics(cmd_dict, windex=None)

[Nirnimesh, 2012/04/12 23:04:07]

return the output of this call

+      return
+
     return self._GetResultFromJSONRequest(cmd_dict, windex=None)
 
   def IsAura(self):
     """Is this Aura?"""
     return self.GetBrowserInfo()['properties']['aura']
 
   def GetProcessInfo(self):
     """Returns information about browser-related processes that currently exist.
 
     This will also return information about other currently-running browsers
@@ skipping 3654 matching lines @@
     successful = result.wasSuccessful()
     if not successful:
       pyauto_tests_file = os.path.join(self.TestsDir(), self._tests_filename)
       print >>sys.stderr, 'Tests can be disabled by editing %s. ' \
                           'Ref: %s' % (pyauto_tests_file, _PYAUTO_DOC_URL)
     sys.exit(not successful)
 
 
 if __name__ == '__main__':
   Main()