Include logcat created by StrictMode and test_runner_py.

build/android/pylib/local/device/local_device_instrumentation_test_run.py

 # Copyright 2015 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.
 
+import contextlib
 import logging
 import os
 import posixpath
 import re
 import tempfile
 import time
 
 from devil.android import device_errors
 from devil.android import device_temp_file
 from devil.android import flag_changer
@@ skipping 28 matching lines @@
 TIMEOUT_ANNOTATIONS = [
   ('Manual', 10 * 60 * 60),
   ('IntegrationTest', 30 * 60),
   ('External', 10 * 60),
   ('EnormousTest', 10 * 60),
   ('LargeTest', 5 * 60),
   ('MediumTest', 3 * 60),
   ('SmallTest', 1 * 60),
 ]
 
-LOGCAT_FILTERS = ['*:e', 'chromium:v', 'cr_*:v', 'DEBUG:I']
+LOGCAT_FILTERS = ['*:e', 'chromium:v', 'cr_*:v', 'DEBUG:I',
+                  'StrictMode:D', '%s:I' % _TAG]
 
 EXTRA_SCREENSHOT_FILE = (
     'org.chromium.base.test.ScreenshotOnFailureStatement.ScreenshotFile')
 
 FEATURE_ANNOTATION = 'Feature'
 RENDER_TEST_FEATURE_ANNOTATION = 'RenderTest'
 
 # This needs to be kept in sync with formatting in |RenderUtils.imageName|
 RE_RENDER_IMAGE_NAME = re.compile(
       r'(?P<test_class>\w+)\.'
       r'(?P<description>\w+)\.'
       r'(?P<device_model>\w+)\.'
       r'(?P<orientation>port|land)\.png')
 
+@contextlib.contextmanager
+def _LogTestEndpoints(device, test_name):
+  device.RunShellCommand(
+      ['log', '-p', 'i', '-t', _TAG, 'START %s' % test_name],
+      check_return=True)
+  try:
+    yield
+  finally:
+    device.RunShellCommand(
+        ['log', '-p', 'i', '-t', _TAG, 'END %s' % test_name],
+        check_return=True)
+
 # TODO(jbudorick): Make this private once the instrumentation test_runner is
 # deprecated.
 def DidPackageCrashOnDevice(package_name, device):
   # Dismiss any error dialogs. Limit the number in case we have an error
   # loop or we are failing to dismiss.
   try:
     for _ in xrange(10):
       package = device.DismissCrashDialogIfNeeded()
       if not package:
         return False
@@ skipping 269 matching lines @@
           device.GetExternalStoragePath(),
           'render_test_output_dir')
       flags_to_add.append('--render-test-output-dir=%s' %
                           render_tests_device_output_dir)
 
     if flags_to_add or flags_to_remove:
       self._CreateFlagChangerIfNeeded(device)
       self._flag_changers[str(device)].PushFlags(
         add=flags_to_add, remove=flags_to_remove)
 
-    try:
-      device.RunShellCommand(
-          ['log', '-p', 'i', '-t', _TAG, 'START %s' % test_name],
-          check_return=True)
-      time_ms = lambda: int(time.time() * 1e3)
-      start_ms = time_ms()
+    time_ms = lambda: int(time.time() * 1e3)
+    start_ms = time_ms()
 
-      stream_name = 'logcat_%s_%s_%s' % (
-          test_name.replace('#', '.'),
-          time.strftime('%Y%m%dT%H%M%S-UTC', time.gmtime()),
-          device.serial)
-      logmon = logdog_logcat_monitor.LogdogLogcatMonitor(
-          device.adb, stream_name, filter_specs=LOGCAT_FILTERS)
+    stream_name = 'logcat_%s_%s_%s' % (
+        test_name.replace('#', '.'),
+        time.strftime('%Y%m%dT%H%M%S-UTC', time.gmtime()),
+        device.serial)
+    logmon = logdog_logcat_monitor.LogdogLogcatMonitor(
+        device.adb, stream_name, filter_specs=LOGCAT_FILTERS)
 
-      with contextlib_ext.Optional(
-          logmon, self._test_instance.should_save_logcat):
+    with contextlib_ext.Optional(
+        logmon, self._test_instance.should_save_logcat):
+      with _LogTestEndpoints(device, test_name):
         with contextlib_ext.Optional(
             trace_event.trace(test_name),
             self._env.trace_output):
           output = device.StartInstrumentation(
               target, raw=True, extras=extras, timeout=timeout, retries=0)
-      logcat_url = logmon.GetLogcatURL()
-    finally:
-      device.RunShellCommand(
-          ['log', '-p', 'i', '-t', _TAG, 'END %s' % test_name],
-          check_return=True)
-      duration_ms = time_ms() - start_ms
-      if flags_to_add or flags_to_remove:
-        self._flag_changers[str(device)].Restore()
-      if test_timeout_scale:
-        valgrind_tools.SetChromeTimeoutScale(
-            device, self._test_instance.timeout_scale)
+
+    logcat_url = logmon.GetLogcatURL()
+    duration_ms = time_ms() - start_ms
+    if flags_to_add or flags_to_remove:
+      self._flag_changers[str(device)].Restore()
+    if test_timeout_scale:
+      valgrind_tools.SetChromeTimeoutScale(
+          device, self._test_instance.timeout_scale)
 
     # TODO(jbudorick): Make instrumentation tests output a JSON so this
     # doesn't have to parse the output.
     result_code, result_bundle, statuses = (
         self._test_instance.ParseAmInstrumentRawOutput(output))
     results = self._test_instance.GenerateTestResults(
         result_code, result_bundle, statuses, start_ms, duration_ms)
     for result in results:
       if logcat_url:
         result.SetLink('logcat', logcat_url)
@@ skipping 247 matching lines @@
     timeout *= cls._GetTimeoutScaleFromAnnotations(annotations)
 
     return timeout
 
 def _IsRenderTest(test):
   """Determines if a test or list of tests has a RenderTest amongst them."""
   if not isinstance(test, list):
     test = [test]
   return any([RENDER_TEST_FEATURE_ANNOTATION in t['annotations'].get(
               FEATURE_ANNOTATION, {}).get('value', ()) for t in test])