Android: fixes timeout for WaitForLogMatch.

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 760 matching lines @@
     assert build_type
     return build_type
 
   def StartMonitoringLogcat(self, clear=True, timeout=10, 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
+      timeout: Deprecated, will be removed soon.
       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)
@@ skipping 24 matching lines @@
 
   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.
       clear: If True the existing logcat output will be cleared, defaults to
           false.
+      timeout: Timeout in seconds to wait for a log match.
 
     Raises:
-      pexpect.TIMEOUT upon the timeout specified by StartMonitoringLogcat().
+      pexpect.TIMEOUT after |timeout| seconds without a match for |success_re|
+      or |error_re|.
 
     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)
       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()
+          time_remaining = t0 + 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
@@ skipping 292 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()