Use Systrace tracing controller in profile_chrome

systrace/profile_chrome/perf_tracing_agent.py

 # Copyright 2014 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 py_utils
 import signal
 import subprocess
@@ skipping 109 matching lines @@
   def GetCategories(cls, device):
     perf_binary = cls._PrepareDevice(device)
     return device.RunShellCommand('%s list' % perf_binary)
 
   @py_utils.Timeout(tracing_agents.START_STOP_TIMEOUT)
   def StartAgentTracing(self, config, timeout=None):
     self._categories = _ComputePerfCategories(config)
     self._perf_instance = _PerfProfiler(self._device,
                                         self._perf_binary,
                                         self._categories)
+    return True
 
   @py_utils.Timeout(tracing_agents.START_STOP_TIMEOUT)
   def StopAgentTracing(self, timeout=None):
     if not self._perf_instance:
       return
     self._perf_instance.SignalAndWait()
+    return True
 
   @py_utils.Timeout(tracing_agents.GET_RESULTS_TIMEOUT)
   def GetResults(self, timeout=None):
     with open(self._PullTrace(), 'r') as f:
       trace_data = f.read()
     return trace_result.TraceResult('perf', trace_data)
 
   @staticmethod
   def _GetInteractivePerfCommand(perfhost_path, perf_profile, symfs_dir,
                                  required_libs, kallsyms):
@@ skipping 51 matching lines @@
                         'not contain any perf samples. You can still view the '
                         'perf data manually as shown above.')
         return None
 
     return json_file_name
 
   def SupportsExplicitClockSync(self):
     return False
 
   def RecordClockSyncMarker(self, sync_id, did_record_sync_marker_callback):
+    # pylint: disable=unused-argument
     assert self.SupportsExplicitClockSync(), ('Clock sync marker cannot be '
         'recorded since explicit clock sync is not supported.')
 
 def _OptionalValueCallback(default_value):
   def callback(option, _, __, parser):  # pylint: disable=unused-argument
     value = default_value
     if parser.rargs and not parser.rargs[0].startswith('-'):
       value = parser.rargs.pop(0)
     setattr(parser.values, option.dest, value)
   return callback
 
 
 class PerfConfig(tracing_agents.TracingConfig):
-  def __init__(self, perf_categories):
+  def __init__(self, perf_categories, device):
     tracing_agents.TracingConfig.__init__(self)
     self.perf_categories = perf_categories
+    self.device = device
 
 
+def try_create_agent(config):
+  if config.perf_categories:
+    return PerfProfilerAgent(config.device)
+  return False
+
 def add_options(parser):
   options = optparse.OptionGroup(parser, 'Perf profiling options')
   options.add_option('-p', '--perf', help='Capture a perf profile with '
                      'the chosen comma-delimited event categories. '
                      'Samples CPU cycles by default. Use "list" to see '
                      'the available sample types.', action='callback',
                      default='', callback=_OptionalValueCallback('cycles'),
                      metavar='PERF_CATEGORIES', dest='perf_categories')
   parser.add_option_group(options)
   return options
 
 def get_config(options):
-  return PerfConfig(options.perf_categories)
+  return PerfConfig(options.perf_categories, options.device)
 
 def _ComputePerfCategories(config):
   if not PerfProfilerAgent.IsSupported():
     return []
   if not config.perf_categories:
     return []
   return config.perf_categories.split(',')