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

[Sami, 2013/01/22 01:37:25]

It seems like we could get rid of the timeout argument to this function
completely. In any case this comment should be updated.

[bulach, 2013/01/22 01:55:58]

as discussed, deprecating this parameter and created crbug.com/171347 to clean
this up.

       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 41 matching lines @@
     """
     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()