[Instrumentation Test Speed] Add trace event to the setup logic

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
 
@@ skipping 58 matching lines @@
   def TestPackage(self):
     return self._test_instance.suite
 
   #override
   def SetUp(self):
     @local_device_environment.handle_shard_failures_with(
         self._env.BlacklistDevice)
     @trace_event.traced
     def individual_device_set_up(dev, host_device_tuples):
       steps = []
+
       def install_helper(apk, permissions):
-        return lambda: dev.Install(apk, permissions=permissions)
+        @trace_event.traced("apk_path")
+        def install_helper_internal(apk_path=apk.path):

[shenghuazhang, 2017/04/21 19:17:22]

Add the internal function with apk.path argument so that the install process for
each apk can be traced. 
The trace output example:
https://drive.google.com/a/google.com/file/d/0BwXSjqIEYMIkV09DOFBBVE4zbGM/vie...

Could use contextlib_ext in the internal function as well, like:
  def install_helper_internal():
    with contextlib_ext.Optional(
            trace_event.trace(apk.path),
            self._env.trace_output):
      dev.Install(apk, permissions=permissions)

But I think the @trace_event way is much clear.

[jbudorick, 2017/04/21 20:41:08]

Why am I not surprised that ChromePublic.apk takes an eternity to install...
Agreed.

+          # pylint: disable=unused-argument
+          dev.Install(apk, permissions=permissions)
+        return install_helper_internal
+
       def incremental_install_helper(dev, apk, script):
-        return lambda: local_device_test_run.IncrementalInstall(
-                           dev, apk, script)
+        @trace_event.traced("apk_path")
+        def incremental_install_helper_internal(apk_path=apk.path):
+          # pylint: disable=unused-argument
+          local_device_test_run.IncrementalInstall(
+              dev, apk, script)
+        return incremental_install_helper_internal
 
       if self._test_instance.apk_under_test:
         if self._test_instance.apk_under_test_incremental_install_script:
           steps.append(incremental_install_helper(
                            dev,
                            self._test_instance.apk_under_test,
                            self._test_instance.
                                apk_under_test_incremental_install_script))
         else:
           permissions = self._test_instance.apk_under_test.GetPermissions()
           steps.append(install_helper(self._test_instance.apk_under_test,
                                       permissions))
 
       if self._test_instance.test_apk_incremental_install_script:
         steps.append(incremental_install_helper(
                          dev,
                          self._test_instance.test_apk,
                          self._test_instance.
                              test_apk_incremental_install_script))
       else:
         permissions = self._test_instance.test_apk.GetPermissions()
         steps.append(install_helper(self._test_instance.test_apk,
                                     permissions))
 
       steps.extend(install_helper(apk, None)
                    for apk in self._test_instance.additional_apks)
 
+      @trace_event.traced
       def set_debug_app():
         # Set debug app in order to enable reading command line flags on user
         # builds
         if self._test_instance.flags:
           if not self._test_instance.package_info:
             logging.error("Couldn't set debug app: no package info")
           elif not self._test_instance.package_info.package:
             logging.error("Couldn't set debug app: no package defined")
           else:
             dev.RunShellCommand(['am', 'set-debug-app', '--persistent',
                                   self._test_instance.package_info.package],
                                 check_return=True)
-
+      @trace_event.traced
       def edit_shared_prefs():
         for pref in self._test_instance.edit_shared_prefs:
           prefs = shared_prefs.SharedPrefs(dev, pref['package'],
                                            pref['filename'])
           prefs.Load()
           for key in pref.get('remove', []):
             try:
               prefs.Remove(key)
             except KeyError:
               logging.warning("Attempted to remove non-existent key %s", key)
           for key, value in pref.get('set', {}).iteritems():
             if isinstance(value, bool):
               prefs.SetBoolean(key, value)
             elif isinstance(value, basestring):
               prefs.SetString(key, value)
             elif isinstance(value, long) or isinstance(value, int):
               prefs.SetLong(key, value)
             elif isinstance(value, list):
               prefs.SetStringSet(key, value)
             else:
               raise ValueError("Given invalid value type %s for key %s" % (
                   str(type(value)), key))
           prefs.Commit()
 
+      @trace_event.traced
       def push_test_data():
         device_root = posixpath.join(dev.GetExternalStoragePath(),
                                      'chromium_tests_root')
         host_device_tuples_substituted = [
             (h, local_device_test_run.SubstituteDeviceRoot(d, device_root))
             for h, d in host_device_tuples]
         logging.info('instrumentation data deps:')
         for h, d in host_device_tuples_substituted:
           logging.info('%r -> %r', h, d)
         dev.PushChangedFiles(host_device_tuples_substituted,
                              delete_device_stale=True)
         if not host_device_tuples_substituted:
           dev.RunShellCommand(['rm', '-rf', device_root], check_return=True)
           dev.RunShellCommand(['mkdir', '-p', device_root], check_return=True)
 
+      @trace_event.traced
       def create_flag_changer():
         if self._test_instance.flags:
           if not self._test_instance.package_info:
             logging.error("Couldn't set flags: no package info")
           elif not self._test_instance.package_info.cmdline_file:
             logging.error("Couldn't set flags: no cmdline_file")
           else:
             self._CreateFlagChangerIfNeeded(dev)
             logging.debug('Attempting to set flags: %r',
                           self._test_instance.flags)
@@ skipping 268 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