[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 io
 import json
 import logging
 import os
 import pickle
@@ skipping 11 matching lines @@
 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 47 matching lines @@
     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)
 
     try:
       start_time = time.time()
+      if self._test_instance.trace_output:

[jbudorick, 2016/12/15 20:22:33]

My vote would be for a context manager.

In related news, I need to get around to writing a conditional context manager
or something like that in catapult/common/py_utils.

[jbudorick, 2016/12/15 20:22:59]

that and tempdir as a context manager.

[rnephew (Reviews Here), 2016/12/15 21:24:04]

Moved to context manager.

+        trace_event.trace_begin(test)
       exit_code, output = cmd_helper.GetCmdStatusAndOutputWithTimeout(
           cmd, timeout, cwd=cwd, shell=True)
+      if self._test_instance.trace_output:
+        trace_event.trace_end(test)
       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
@@ skipping 292 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