[Android] Add LogcatMonitor.

build/android/pylib/linker/test_case.py

 # Copyright 2013 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.
 
 """Base class for linker-specific test cases.
 
    The custom dynamic linker can only be tested through a custom test case
    for various technical reasons:
 
      - It's an 'invisible feature', i.e. it doesn't expose a new API or
@@ skipping 24 matching lines @@
 """
 # pylint: disable=R0201
 
 import logging
 import os
 import re
 import time
 
 from pylib import constants
 from pylib.base import base_test_result
+from pylib.device import device_errors
 from pylib.device import intent
 
 
 ResultType = base_test_result.ResultType
 
 _PACKAGE_NAME = 'org.chromium.chromium_linker_test_apk'
 _ACTIVITY_NAME = '.ChromiumLinkerTestActivity'
 _COMMAND_LINE_FILE = '/data/local/tmp/chromium-linker-test-command-line'
 
 # Path to the Linker.java source file.
 _LINKER_JAVA_SOURCE_PATH = (
     'base/android/java/src/org/chromium/base/library_loader/Linker.java')
 
 # A regular expression used to extract the browser shared RELRO configuration
 # from the Java source file above.
 _RE_LINKER_BROWSER_CONFIG = re.compile(
     r'.*BROWSER_SHARED_RELRO_CONFIG\s+=\s+' +
         r'BROWSER_SHARED_RELRO_CONFIG_(\S+)\s*;.*',
     re.MULTILINE | re.DOTALL)
 
 # Logcat filters used during each test. Only the 'chromium' one is really
 # needed, but the logs are added to the TestResult in case of error, and
 # it is handy to have the 'chromium_android_linker' ones as well when
 # troubleshooting.
 _LOGCAT_FILTERS = ['*:s', 'chromium:v', 'chromium_android_linker:v']
 #_LOGCAT_FILTERS = ['*:v']  ## DEBUG
 
 # Regular expression used to match status lines in logcat.
-re_status_line = re.compile(r'(BROWSER|RENDERER)_LINKER_TEST: (FAIL|SUCCESS)')
+RE_BROWSER_STATUS_LINE = re.compile(r' BROWSER_LINKER_TEST: (FAIL|SUCCESS)$')
+RE_RENDERER_STATUS_LINE = re.compile(r' RENDERER_LINKER_TEST: (FAIL|SUCCESS)$')
 
 # Regular expression used to mach library load addresses in logcat.
-re_library_address = re.compile(
+RE_LIBRARY_ADDRESS = re.compile(
     r'(BROWSER|RENDERER)_LIBRARY_ADDRESS: (\S+) ([0-9A-Fa-f]+)')
 
 
 def _GetBrowserSharedRelroConfig():
   """Returns a string corresponding to the Linker's configuration of shared
      RELRO sections in the browser process. This parses the Java linker source
      file to get the appropriate information.
   Return:
       None in case of error (e.g. could not locate the source file).
      'NEVER' if the browser process shall never use shared RELROs.
@@ skipping 15 matching lines @@
       return None
 
     if configs[0] not in ['NEVER', 'LOW_RAM_ONLY', 'ALWAYS']:
       logging.error('Unexpected browser config value: ' + configs[0])
       return None
 
     logging.info('Found linker browser shared RELRO config: ' + configs[0])
     return configs[0]
 
 
-def _WriteCommandLineFile(device, command_line, command_line_file):
-  """Create a command-line file on the device. This does not use FlagChanger
-     because its implementation assumes the device has 'su', and thus does
-     not work at all with production devices."""
-  device.RunShellCommand(
-      'echo "%s" > %s' % (command_line, command_line_file))
-
-
-def _CheckLinkerTestStatus(logcat):
-  """Parse the content of |logcat| and checks for both a browser and
-     renderer status line.
-
-  Args:
-    logcat: A string to parse. Can include line separators.
-
-  Returns:
-    A tuple, result[0] is True if there is a complete match, then
-    result[1] and result[2] will be True or False to reflect the
-    test status for the browser and renderer processes, respectively.
-  """
-  browser_found = False
-  renderer_found = False
-  for m in re_status_line.finditer(logcat):
-    process_type, status = m.groups()
-    if process_type == 'BROWSER':
-      browser_found = True
-      browser_success = (status == 'SUCCESS')
-    elif process_type == 'RENDERER':
-      renderer_found = True
-      renderer_success = (status == 'SUCCESS')
-    else:
-      assert False, 'Invalid process type ' + process_type
-
-  if browser_found and renderer_found:
-    return (True, browser_success, renderer_success)
-
-  # Didn't find anything.
-  return (False, None, None)
-
-
 def _StartActivityAndWaitForLinkerTestStatus(device, timeout):
   """Force-start an activity and wait up to |timeout| seconds until the full
      linker test status lines appear in the logcat, recorded through |device|.
   Args:
     device: A DeviceUtils instance.
     timeout: Timeout in seconds
   Returns:
     A (status, logs) tuple, where status is a ResultType constant, and logs
     if the final logcat output as a string.
   """
+
   # 1. Start recording logcat with appropriate filters.
-  device.old_interface.StartRecordingLogcat(
-      clear=True, filters=_LOGCAT_FILTERS)
+  with device.GetLogcatMonitor(filters=_LOGCAT_FILTERS) as logmon:
 
-  try:
     # 2. Force-start activity.
     device.StartActivity(
         intent.Intent(package=_PACKAGE_NAME, activity=_ACTIVITY_NAME),
         force_stop=True)
 
     # 3. Wait up to |timeout| seconds until the test status is in the logcat.
-    num_tries = 0
-    max_tries = timeout
-    found = False
-    while num_tries < max_tries:
-      time.sleep(1)
-      num_tries += 1
-      found, browser_ok, renderer_ok = _CheckLinkerTestStatus(
-          device.old_interface.GetCurrentRecordedLogcat())
-      if found:
-        break
+    result = ResultType.PASS
+    try:
+      browser_match = logmon.WaitFor(RE_BROWSER_STATUS_LINE, None,
+                                     timeout=timeout)
+      logging.debug('Found browser match: %s', browser_match.group(0))
+      renderer_match = logmon.WaitFor(RE_RENDERER_STATUS_LINE, None,
+                                      timeout=timeout)
+      logging.debug('Found renderer match: %s', renderer_match.group(0))
+      if (browser_match.group(1) != 'SUCCESS'
+          or renderer_match.group(1) != 'SUCCESS'):
+        result = ResultType.FAIL
+    except device_errors.CommandTimeoutError:
+      result = ResultType.TIMEOUT
 
-  finally:
-    logs = device.old_interface.StopRecordingLogcat()
-
-  if num_tries >= max_tries:
-    return ResultType.TIMEOUT, logs
-
-  if browser_ok and renderer_ok:
-    return ResultType.PASS, logs
-
-  return ResultType.FAIL, logs
+    return result, '\n'.join(device.adb.Logcat(dump=True))
 
 
 class LibraryLoadMap(dict):
   """A helper class to pretty-print a map of library names to load addresses."""
   def __str__(self):
     items = ['\'%s\': 0x%x' % (name, address) for \
         (name, address) in self.iteritems()]
     return '{%s}' % (', '.join(items))
 
   def __repr__(self):
@@ skipping 15 matching lines @@
      browser and renderer processes.
   Args:
     logs: A string containing logcat output.
   Returns:
     A tuple (browser_libs, renderer_libs), where each item is a map of
     library names (strings) to library load addresses (ints), for the
     browser and renderer processes, respectively.
   """
   browser_libs = LibraryLoadMap()
   renderer_libs = LibraryLoadMap()
-  for m in re_library_address.finditer(logs):
+  for m in RE_LIBRARY_ADDRESS.finditer(logs):
     process_type, lib_name, lib_address = m.groups()
     lib_address = int(lib_address, 16)
     if process_type == 'BROWSER':
       browser_libs[lib_name] = lib_address
     elif process_type == 'RENDERER':
       renderer_libs[lib_name] = lib_address
     else:
       assert False, 'Invalid process type'
 
   return browser_libs, renderer_libs
@@ skipping 76 matching lines @@
       A base_test_result.TestRunResult() instance.
     """
     margin = 8
     print '[ %-*s ] %s' % (margin, 'RUN', self.tagged_name)
     logging.info('Running linker test: %s', self.tagged_name)
 
     # Create command-line file on device.
     command_line_flags = ''
     if self.is_low_memory:
       command_line_flags = '--low-memory-device'
-    _WriteCommandLineFile(device, command_line_flags, _COMMAND_LINE_FILE)
+    device.WriteFile(_COMMAND_LINE_FILE, command_line_flags)
 
     # Run the test.
     status, logs = self._RunTest(device)
 
     result_text = 'OK'
     if status == ResultType.FAIL:
       result_text = 'FAILED'
     elif status == ResultType.TIMEOUT:
       result_text = 'TIMEOUT'
     print '[ %*s ] %s' % (margin, result_text, self.tagged_name)
@@ skipping 196 matching lines @@
       # Note that this behaviour doesn't seem to happen when starting an
       # application 'normally', i.e. when using the application launcher to
       # start the activity.
       logging.info('Ignoring system\'s low randomization of browser libraries' +
                    ' for regular devices')
 
     if not renderer_status:
       return ResultType.FAIL, renderer_logs
 
     return ResultType.PASS, logs