(Reland) Add failure screenshots and images to results detail.

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 logging
 import os
 import posixpath
 import re
 import time
 
 from devil.android import device_errors
 from devil.android import flag_changer
 from devil.android.sdk import shared_prefs
 from devil.utils import reraiser_thread
 from pylib import valgrind_tools
 from pylib.android import logdog_logcat_monitor
 from pylib.base import base_test_result
 from pylib.instrumentation import instrumentation_test_instance
 from pylib.local.device import local_device_environment
 from pylib.local.device import local_device_test_run
+from pylib.utils import google_storage_helper
 from pylib.utils import logdog_helper
 from py_trace_event import trace_event
 from py_utils import contextlib_ext
+from py_utils import tempfile_ext
 import tombstones
 
 _TAG = 'test_runner_py'
 
 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']
 
+
 # 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 259 matching lines @@
 
     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()
 
       stream_name = 'logcat_%s_%s_%s' % (
           test_name.replace('#', '.'),
-          time.strftime('%Y%m%dT%H%M%S', time.localtime()),
+          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(
             trace_event.trace(test_name),
             self._env.trace_output):
           output = device.StartInstrumentation(
@@ skipping 40 matching lines @@
         if r.GetType() == base_test_result.ResultType.UNKNOWN:
           r.SetType(base_test_result.ResultType.CRASH)
 
     # Handle failures by:
     #   - optionally taking a screenshot
     #   - logging the raw output at INFO level
     #   - clearing the application state while persisting permissions
     if any(r.GetType() not in (base_test_result.ResultType.PASS,
                                base_test_result.ResultType.SKIP)
            for r in results):
-      if self._test_instance.screenshot_dir:
-        file_name = '%s-%s.png' % (
-            test_display_name,
-            time.strftime('%Y%m%dT%H%M%S', time.localtime()))
-        saved_dir = device.TakeScreenshot(
-            os.path.join(self._test_instance.screenshot_dir, file_name))
-        logging.info(
-            'Saved screenshot for %s to %s.',
-            test_display_name, saved_dir)
+      with contextlib_ext.Optional(
+          tempfile_ext.NamedTemporaryDirectory(),
+          self._test_instance.screenshot_dir is None and
+              self._test_instance.gs_results_bucket) as screenshot_host_dir:
+        screenshot_host_dir = (
+            self._test_instance.screenshot_dir or screenshot_host_dir)
+        if screenshot_host_dir:
+          file_name = '%s-%s.png' % (
+              test_display_name,
+              time.strftime('%Y%m%dT%H%M%S-UTC', time.gmtime()))
+          screenshot_file = device.TakeScreenshot(
+              os.path.join(screenshot_host_dir, file_name))
+          logging.info(
+              'Saved screenshot for %s to %s.',
+              test_display_name, screenshot_file)
+          if self._test_instance.gs_results_bucket:
+            link = google_storage_helper.upload(
+                google_storage_helper.unique_name('screenshot', device=device),
+                screenshot_file,
+                bucket=self._test_instance.gs_results_bucket + '/screenshots')
+            for result in results:
+              result.SetLink('post_test_screenshot', link)
+
       logging.info('detected failure in %s. raw output:', test_display_name)
       for l in output:
         logging.info('  %s', l)
       if (not self._env.skip_clear_data
           and self._test_instance.package_info):
         permissions = (
             self._test_instance.apk_under_test.GetPermissions()
             if self._test_instance.apk_under_test
             else None)
         device.ClearApplicationState(self._test_instance.package_info.package,
                                      permissions=permissions)
-
     else:
       logging.debug('raw output from %s:', test_display_name)
       for l in output:
         logging.debug('  %s', l)
     if self._test_instance.coverage_directory:
       device.PullFile(coverage_directory,
           self._test_instance.coverage_directory)
       device.RunShellCommand(
           'rm -f %s' % posixpath.join(coverage_directory, '*'),
           check_return=True, shell=True)
     if self._test_instance.store_tombstones:
       tombstones_url = None
       for result in results:
         if result.GetType() == base_test_result.ResultType.CRASH:
           if not tombstones_url:
             resolved_tombstones = tombstones.ResolveTombstones(
                 device,
                 resolve_all_tombstones=True,
                 include_stack_symbols=False,
                 wipe_tombstones=True)
             stream_name = 'tombstones_%s_%s' % (
-                time.strftime('%Y%m%dT%H%M%S', time.localtime()),
+                time.strftime('%Y%m%dT%H%M%S-UTC', time.gmtime()),
                 device.serial)
             tombstones_url = logdog_helper.text(
                 stream_name, '\n'.join(resolved_tombstones))
           result.SetLink('tombstones', tombstones_url)
     return results, None
 
   #override
   def _ShouldRetry(self, test):
     if 'RetryOnFailure' in test.get('annotations', {}):
       return True
@@ skipping 21 matching lines @@
       if k in annotations:
         timeout = v
         break
     else:
       logging.warning('Using default 1 minute timeout for %s', test_name)
       timeout = 60
 
     timeout *= cls._GetTimeoutScaleFromAnnotations(annotations)
 
     return timeout