[tools/perf] Enable outputting trace, videos (Android only), result2.html for system health stories…

tools/perf/benchmarks/system_health_smoke_test.py

 # Copyright 2016 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.
 
 """Run all system health stories used by system health benchmarks.
 
 Only memory benchmarks are used when running these stories to make the total
 cycle time manageable. Other system health benchmarks should be using the same
 stories as memory ones, only with fewer actions (no memory dumping).
 """
 
 import unittest
+import os
 
 from core import perf_benchmark
 
 from telemetry import benchmark as benchmark_module
 from telemetry import decorators
 from telemetry.core import discover
 from telemetry.internal.browser import browser_finder
 from telemetry.testing import options_for_unittests
 from telemetry.testing import progress_reporter
 
@@ skipping 43 matching lines @@
 
   # NOTE TO SHERIFFS: DO NOT DISABLE THIS TEST.
   #
   # This smoke test dynamically tests all system health user stories. So
   # disabling it for one failing or flaky benchmark would disable a much
   # wider swath of coverage  than is usally intended. Instead, if a test is
   # failing, disable it by putting it into the _DISABLED_TESTS list above.
   @benchmark_module.Disabled('chromeos')  # crbug.com/351114
   def RunTest(self):
 
-    class SinglePageBenchmark(benchmark_class):  # pylint: disable=no-init
+    class SingleStoryBenchmark(benchmark_class):  # pylint: disable=no-init
       def CreateStorySet(self, options):
         # pylint: disable=super-on-old-class
-        story_set = super(SinglePageBenchmark, self).CreateStorySet(options)
+        story_set = super(SingleStoryBenchmark, self).CreateStorySet(options)
         assert story_to_smoke_test in story_set.stories
         story_set.stories = [story_to_smoke_test]
         return story_set
 
     options = GenerateBenchmarkOptions(benchmark_class)
     possible_browser = browser_finder.FindBrowser(options)
     if possible_browser is None:
       self.skipTest('Cannot find the browser to run the test.')
-    if (SinglePageBenchmark.ShouldDisable(possible_browser) or
+    if (SingleStoryBenchmark.ShouldDisable(possible_browser) or
         not decorators.IsEnabled(benchmark_class, possible_browser)[0]):
-      self.skipTest('Benchmark %s is disabled' % SinglePageBenchmark.Name())
+      self.skipTest('Benchmark %s is disabled' % SingleStoryBenchmark.Name())
 
     if self.id() in _DISABLED_TESTS:
       self.skipTest('Test is explictly disabled')
 
-    self.assertEqual(0, SinglePageBenchmark().Run(options),
+    # If this is run on swarming, dump all the data to ${ISOLATED_OUTDIR} to
+    # archive them.
+    if os.environ.get('ISOLATED_OUTDIR'):
+      if possible_browser.platform.GetOSName() == 'android':
+        options.profiler = 'android-screen-recorder'
+      system_health_dir = os.path.join(
+          os.path.abspath(os.environ.get('ISOLATED_OUTDIR')),
+          'system_health_smoke')
+      # Create system_health_dir if not already exists (this could be racey
+      # hence we just ignore OSError).
+      try:
+        os.mkdir(system_health_dir)
+      except OSError:
+        pass
+      options.output_dir = os.path.join(system_health_dir,
+                                        story_to_smoke_test.file_safe_name)
+      os.mkdir(options.output_dir)
+      options.output_formats = ['json', 'html2']
+    self.assertEqual(0, SingleStoryBenchmark().Run(options),
                      msg='Failed: %s' % benchmark_class)
 
   # We attach the test method to SystemHealthBenchmarkSmokeTest dynamically
   # so that we can set the test method name to include
   # '<benchmark class name>.<story display name>'.
   test_method_name = '%s.%s' % (
       benchmark_class.Name(), story_to_smoke_test.display_name)
 
   class SystemHealthBenchmarkSmokeTest(unittest.TestCase):
     pass
@@ skipping 41 matching lines @@
     # parsed during test time which happens after load_tests are called.
     # Since none of our system health benchmarks creates stories based on
     # command line options, it should be ok to pass options=None to
     # CreateStorySet.
     for story_to_smoke_test in (
         benchmark_class().CreateStorySet(options=None).stories):
       suite.addTest(
           _GenerateSmokeTestCase(benchmark_class, story_to_smoke_test))
 
   return suite