Android: removes deprecated |timeout| param from StartMonitoringLogcat.

build/android/pylib/android_commands.py

 # 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.
 
 """Provides an interface to communicate with the device via the adb command.
 
 Assumes adb binary is currently on system path.
 """
 
 import collections
@@ skipping 753 matching lines @@
     build_id = self.RunShellCommand('getprop ro.build.id')[0]
     assert build_id
     return build_id
 
   def GetBuildType(self):
     """Returns the build type of the system (e.g. eng)."""
     build_type = self.RunShellCommand('getprop ro.build.type')[0]
     assert build_type
     return build_type
 
-  def StartMonitoringLogcat(self, clear=True, timeout=10, logfile=None,
-                            filters=None):
+  def StartMonitoringLogcat(self, clear=True, logfile=None, filters=None):
     """Starts monitoring the output of logcat, for use with WaitForLogMatch.
 
     Args:
       clear: If True the existing logcat output will be cleared, to avoiding
              matching historical output lurking in the log.
-      timeout: How long WaitForLogMatch will wait for the given match
       filters: A list of logcat filters to be used.
     """
     if clear:
       self.RunShellCommand('logcat -c')
     args = []
     if self._adb._target_arg:
       args += shlex.split(self._adb._target_arg)
     args += ['logcat', '-v', 'threadtime']
     if filters:
       args.extend(filters)
     else:
       args.append('*:v')
 
     if logfile:
       logfile = NewLineNormalizer(logfile)
 
     # Spawn logcat and syncronize with it.
     for _ in range(4):
-      self._logcat = pexpect.spawn('adb', args, timeout=timeout,
-                                   logfile=logfile)
+      self._logcat = pexpect.spawn('adb', args, timeout=10, logfile=logfile)
       self.RunShellCommand('log startup_sync')
       if self._logcat.expect(['startup_sync', pexpect.EOF,
                               pexpect.TIMEOUT]) == 0:
         break
       self._logcat.close(force=True)
     else:
       logging.critical('Error reading from logcat: ' + str(self._logcat.match))
       sys.exit(1)
 
   def GetMonitoredLogCat(self):
     """Returns an "adb logcat" command as created by pexpected.spawn."""
     if not self._logcat:
       self.StartMonitoringLogcat(clear=False)
     return self._logcat
 
   def WaitForLogMatch(self, success_re, error_re, clear=False, timeout=10):
     """Blocks until a matching line is logged or a timeout occurs.
 
     Args:
       success_re: A compiled re to search each line for.
       error_re: A compiled re which, if found, terminates the search for
           |success_re|. If None is given, no error condition will be detected.

[frankf, 2013/01/22 18:34:22]

Make this an optional param?

[bulach, 2013/02/04 11:21:24]

hmm, making an optional param in the middle is kind of tricky, they should only
be added at the end.. ok to leave as it is?
(tbh, without proper static analysis tools, it'd be safer to  have fewer
optional params rather than more :) we've been bitten a few times by the wrong
params being passed when the optional params aren't properly named / when they
become optional..)

       clear: If True the existing logcat output will be cleared, defaults to
           false.
 
     Raises:
       pexpect.TIMEOUT upon the timeout specified by StartMonitoringLogcat().

[Sami, 2013/01/22 02:36:37]

Also here :)

[bulach, 2013/01/22 02:40:58]

the other one took care of it :)
as soon as that one lands, I'll rebase with this and mark this comment as done.
https://codereview.chromium.org/12035016/diff/6002/build/android/pylib/androi...

 
     Returns:
       The re match object if |success_re| is matched first or None if |error_re|
       is matched first.
     """
     logging.info('<<< Waiting for logcat:' + str(success_re.pattern))
     t0 = time.time()
     while True:
       if not self._logcat:
-        self.StartMonitoringLogcat(clear, timeout=timeout)
+        self.StartMonitoringLogcat(clear)
       try:
         while True:
           # Note this will block for upto the timeout _per log line_, so we need
           # to calculate the overall timeout remaining since t0.
           time_remaining = t0 + self._logcat.timeout - time.time()
           if time_remaining < 0: raise pexpect.TIMEOUT(self._logcat)
           self._logcat.expect(PEXPECT_LINE_RE, timeout=time_remaining)
           line = self._logcat.match.group(1)
           if error_re:
             error_match = error_re.search(line)
             if error_match:
               return None
           success_match = success_re.search(line)
           if success_match:
             return success_match
           logging.info('<<< Skipped Logcat Line:' + str(line))
       except pexpect.TIMEOUT:
         raise pexpect.TIMEOUT(
             'Timeout (%ds) exceeded waiting for pattern "%s" (tip: use -vv '
             'to debug)' %
             (self._logcat.timeout, success_re.pattern))

[aberent, 2013/01/29 13:25:08]

I think the timeout here should be "timeout", not "self._logcat.timeout". I have
actually fixed this in parallel in a patch I have submitted for review.

[bulach, 2013/02/04 11:21:24]

thanks! your patch took care of it.. :)

       except pexpect.EOF:
         # It seems that sometimes logcat can end unexpectedly. This seems
         # to happen during Chrome startup after a reboot followed by a cache
         # clean. I don't understand why this happens, but this code deals with
         # getting EOF in logcat.
         logging.critical('Found EOF in adb logcat. Restarting...')
         # Rerun spawn with original arguments. Note that self._logcat.args[0] is
         # the path of adb, so we don't want it in the arguments.
         self._logcat = pexpect.spawn('adb',
                                      self._logcat.args[1:],
@@ skipping 276 matching lines @@
   """
   def __init__(self, output):
     self._output = output
 
   def write(self, data):
     data = data.replace('\r\r\n', '\n')
     self._output.write(data)
 
   def flush(self):
     self._output.flush()