Use Systrace tracing controller in profile_chrome

systrace/bin/adb_profile_chrome_startup

 #!/usr/bin/env python
 #
 # 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 optparse
 import os
 import sys
 import webbrowser
 
 _SYSTRACE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
 sys.path.append(_SYSTRACE_DIR)
 
 from profile_chrome import atrace_tracing_agent
 from profile_chrome import chrome_startup_tracing_agent
 from profile_chrome import flags
 from profile_chrome import profiler
 from profile_chrome import ui
 
 _CATAPULT_DIR = os.path.join(
     os.path.dirname(os.path.abspath(__file__)), '..', '..')
 sys.path.append(os.path.join(_CATAPULT_DIR, 'devil'))
 
 from devil.android import device_utils
 
 
+_DEFAULT_CHROME_CATEGORIES = '_DEFAULT_CHROME_CATEGORIES'
+
+
 def _CreateOptionParser():
   parser = optparse.OptionParser(description='Record about://tracing profiles '
                                  'from Android browsers startup, combined with '
                                  'Android systrace. See http://dev.chromium.org'
                                  '/developers/how-tos/trace-event-profiling-'
                                  'tool for detailed instructions for '
                                  'profiling.')
 
   browsers = sorted(profiler.GetSupportedBrowsers().keys())
   parser.add_option('-b', '--browser', help='Select among installed browsers. '
                     'One of ' + ', '.join(browsers) + ', "stable" is used by '
                     'default.', type='choice', choices=browsers,
                     default='stable')
   parser.add_option('-v', '--verbose', help='Verbose logging.',
                     action='store_true')
   parser.add_option('-z', '--compress', help='Compress the resulting trace '
                     'with gzip. ', action='store_true')
   parser.add_option('-t', '--time', help='Stops tracing after N seconds, 0 to '
                     'manually stop (startup trace ends after at most 5s).',
-                    default=5, metavar='N', type='int')
+                    default=5, metavar='N', type='int', dest='trace_time')
 
   parser.add_option_group(chrome_startup_tracing_agent.add_options(parser))
   parser.add_option_group(atrace_tracing_agent.add_options(parser))
   parser.add_option_group(flags.OutputOptions(parser))
 
   return parser
 
 
 def main():
   parser = _CreateOptionParser()
   options, _ = parser.parse_args()
 
   if options.verbose:
     logging.getLogger().setLevel(logging.DEBUG)
 
   devices = device_utils.DeviceUtils.HealthyDevices()
   if len(devices) != 1:
     logging.error('Exactly 1 device must be attached.')
     return 1
   device = devices[0]
   package_info = profiler.GetSupportedBrowsers()[options.browser]
 
+  options.chrome_startup = True

[Sami, 2016/09/01 12:15:59]

Why are we overriding the options set by the user here?

[washingtonp, 2016/09/01 17:44:41]

adb_profile_chrome_startup does not provide the user with all of the
command line options that adb_profile_chrome and systrace provide.
However, these 3 clients share the same underlying tracing controller,
which expects some value (even if it is None) in the options
object it is passed. There are two solutions here:

1) Set these options that do not appear to the user when running
adb_profile_chrome_startup to None / another default value here
(what is currently being done)

or 

2) In each Get*Config() function in the agents, check if each
option in the option object exists, and if not, create it and set
it to None.

Would you like me to move to this second design? I can see the benefits
of this small design change, as it takes the burden away from the client
(for example adb_profile_chrome_startup) that does not care about
irrelevant options. I am actually leaning towards this but wondering
what others think.

[Sami, 2016/09/02 12:57:42]

My worry is that in 1) the list will quickly get out of date and in 2) we need
to add lots of boilerplate that can have typos.

I wonder if we could do something where the list of agents can be configured
dynamically instead of being static? adb_profile_chrome_startup would then
override the list of agents to the ones it supports and all others would just
use the default set minus the startup agent. WDYT?

[washingtonp, 2016/09/02 20:10:27]

I like that idea, and have implemented it in the most recent
code patch. LMK if this is what you had in mind.

+  options.device = device
+  options.package_info = package_info
+  options.ring_buffer = False
+  options.trace_memory = False
+  options.trace_cc = None
+  options.trace_frame_viewer = None
+  options.trace_ubercompositor = None
+  options.trace_gpu = None
+  options.trace_flow = None
+  options.trace_scheduler = None
+  options.ddms = None
+  options.perf_categories = None
+  options.list_categories = None
+  options.link_assets = None
+  options.asset_dir = None
+  options.timeout = None
+  options.collection_timeout = None
+  options.device_serial_number = device
+  options.target = None
+  options.chrome_categories = _DEFAULT_CHROME_CATEGORIES
+  if options.output_file:
+    options.output_file = os.path.expanduser(options.output_file)
+
   if options.atrace_categories in ['list', 'help']:
     ui.PrintMessage('\n'.join(
         atrace_tracing_agent.AtraceAgent.GetCategories(device)))
     return 0
-  atrace_categories = (options.atrace_categories.split(',')
-                         if options.atrace_categories else [])
-  enabled_agents = []
-  # Enable the atrace and chrome agents. The atrace agent should go
-  # first because otherwise the resulting traces miss early atrace data.
-  if atrace_categories:
-    enabled_agents.append(atrace_tracing_agent.AtraceAgent(
-        device, atrace_categories, False))
-  enabled_agents.append(
-      chrome_startup_tracing_agent.ChromeStartupTracingAgent(
-          device, package_info, options.cold, options.url))
-  if options.output:
-    options.output = os.path.expanduser(options.output)
   result = profiler.CaptureProfile(options,
-                                   enabled_agents,
-                                   options.time,
-                                   output=options.output,
+                                   options.trace_time,
+                                   output=options.output_file,
                                    compress=options.compress,
-                                   write_json=options.json)
+                                   write_json=options.write_json)
   if options.view:
     if sys.platform == 'darwin':
       os.system('/usr/bin/open %s' % os.path.abspath(result))
     else:
       webbrowser.open(result)
 
 
 if __name__ == '__main__':
   sys.exit(main())