[Android] Add ability to generate test trace json for perf tests runs.

build/android/pylib/local/device/local_device_perf_test_run.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.
 
 import collections
+import contextlib
 import io
 import json
 import logging
 import os
 import pickle
 import shutil
 import tempfile
 import threading
 import time
 import zipfile
 
 from devil.android import battery_utils
 from devil.android import device_errors
 from devil.android import device_list
 from devil.android import device_utils
 from devil.android import forwarder
 from devil.android.tools import device_recovery
 from devil.android.tools import device_status
 from devil.utils import cmd_helper
 from devil.utils import parallelizer
 from devil.utils import reraiser_thread
 from pylib import constants
 from pylib.base import base_test_result
 from pylib.constants import host_paths
 from pylib.local.device import local_device_environment
 from pylib.local.device import local_device_test_run
+from py_trace_event import trace_event
 
 
 class HeartBeat(object):
 
   def __init__(self, shard, wait_time=60*10):
     """ HeartBeat Logger constructor.
 
     Args:
       shard: A perf test runner device shard.
       wait_time: time to wait between heartbeat messages.
@@ skipping 45 matching lines @@
 
   def _RunSingleTest(self, test):
     self._test_instance.WriteBuildBotJson(self._output_dir)
 
     timeout = self._tests[test].get('timeout', self._timeout)
     cmd = self._CreateCmd(test)
     cwd = os.path.abspath(host_paths.DIR_SOURCE_ROOT)
 
     self._LogTest(test, cmd, timeout)
 
+    @contextlib.contextmanager
+    def trace_if_enabled(test):
+      try:
+        if self._test_instance.trace_output:
+          trace_event.trace_begin(test)
+        yield
+      finally:
+        if self._test_instance.trace_output:
+          trace_event.trace_end(test)
+
     try:
       start_time = time.time()
-      exit_code, output = cmd_helper.GetCmdStatusAndOutputWithTimeout(
-          cmd, timeout, cwd=cwd, shell=True)
+
+      with trace_if_enabled(test):
+        exit_code, output = cmd_helper.GetCmdStatusAndOutputWithTimeout(
+            cmd, timeout, cwd=cwd, shell=True)
       end_time = time.time()
       json_output = self._test_instance.ReadChartjsonOutput(self._output_dir)
       if exit_code == 0:
         result_type = base_test_result.ResultType.PASS
       else:
         result_type = base_test_result.ResultType.FAIL
     except cmd_helper.TimeoutError as e:
       end_time = time.time()
       exit_code = -1
       output = e.output
       json_output = ''
       result_type = base_test_result.ResultType.TIMEOUT
-
     return self._ProcessTestResult(test, cmd, start_time, end_time, exit_code,
                                    output, json_output, result_type)
 
   def _CreateCmd(self, test):
     cmd = []
     if self._test_instance.dry_run:
       cmd.append('echo')
     cmd.append(self._tests[test]['cmd'])
     if self._output_dir:
       cmd.append('--output-dir=%s' % self._output_dir)
@@ skipping 279 matching lines @@
                         'affinity to work properly, it must be passed.')
         devices = active_devices
     except IOError as e:
       logging.error('Unable to find %s [%s]', devices_path, e)
       devices = active_devices
     return sorted(devices)
 
   #override
   def RunTests(self):
     # Affinitize the tests.
+    if self._test_instance.trace_output:
+      assert not trace_event.trace_is_enabled(), 'Tracing already running.'
+      trace_event.trace_enable(self._test_instance.trace_output)
     self._SplitTestsByAffinity()
     if not self._test_buckets and not self._no_device_tests:
       raise local_device_test_run.NoTestsError()
 
     def run_no_devices_tests():
       if not self._no_device_tests:
         return []
       s = HostTestShard(self._env, self._test_instance, self._no_device_tests,
                         retries=3, timeout=self._timeout)
       return [s.RunTestsOnShard()]
@@ skipping 17 matching lines @@
         self._devices = self._GetAllDevices(
             self._env.devices, self._test_instance.known_devices_file)
 
       device_indices = range(min(len(self._devices), len(self._test_buckets)))
       shards = parallelizer.Parallelizer(device_indices).pMap(
           device_shard_helper)
       return [x for x in shards.pGet(self._timeout) if x is not None]
 
     host_test_results, device_test_results = reraiser_thread.RunAsync(
         [run_no_devices_tests, run_devices_tests])
+    if self._test_instance.trace_output:
+      assert trace_event.trace_is_enabled(), 'Tracing not running.'
+      trace_event.trace_disable()
     return host_test_results + device_test_results
 
   # override
   def TestPackage(self):
     return 'perf'
 
   # override
   def _CreateShards(self, _tests):
     raise NotImplementedError
 
@@ skipping 52 matching lines @@
   # override
   def _RunTest(self, _device, _test):
     raise NotImplementedError
 
 
 class TestDictVersionError(Exception):
   pass
 
 class PerfTestRunGetStepsError(Exception):
   pass