Add a --startup option to generate combined traces for startup.

tools/profile_chrome/chrome_controller.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 json
 import os
 import re
 import time
 
 from profile_chrome import controllers
 
+from pylib import android_commands
+from pylib import flag_changer
 from pylib import pexpect
 from pylib.device import intent
 
 
 _HEAP_PROFILE_MMAP_PROPERTY = 'heapprof.mmap'
 
 class ChromeTracingController(controllers.BaseController):
   def __init__(self, device, package_info,
-               categories, ring_buffer, trace_memory=False):
+               categories, ring_buffer, trace_memory=False,
+               startup=False):

[Sami, 2015/01/27 13:15:47]

Could you call this something like startup_tracing_mode and make it take either
None or one of the predefined strings. I think mixing bools and strings looks
weird.

[Benoit L, 2015/01/27 13:50:25]

Oops, forgot to update this. You are right, sorry.
Done.

[Benoit L, 2015/01/27 13:50:25]

Oh, I missed this one. Sorry about that.
Done.

     controllers.BaseController.__init__(self)
     self._device = device
     self._package_info = package_info
     self._categories = categories
     self._ring_buffer = ring_buffer
     self._trace_file = None
     self._trace_interval = None
     self._trace_memory = trace_memory
+    self._startup = startup
     self._is_tracing = False
     self._trace_start_re = \
        re.compile(r'Logging performance trace to file')
-    self._trace_finish_re = \
+    if self._startup:
+      self._trace_finish_re = re.compile(
+          r' Completed startup tracing to (.*)')
+    else:
+      self._trace_finish_re = \
        re.compile(r'Profiler finished[.] Results are in (.*)[.]')
     self._device.old_interface.StartMonitoringLogcat(clear=False)
 
   def __repr__(self):
     return 'chrome trace'
 
   @staticmethod
   def GetCategories(device, package_info):
     device.BroadcastIntent(intent.Intent(
         action='%s.GPU_PROFILER_LIST_CATEGORIES' % package_info.package))
     try:
       json_category_list = device.old_interface.WaitForLogMatch(
           re.compile(r'{"traceCategoriesList(.*)'), None, timeout=5).group(0)
     except pexpect.TIMEOUT:
       raise RuntimeError('Performance trace category list marker not found. '
                          'Is the correct version of the browser running?')
 
     record_categories = set()
     disabled_by_default_categories = set()
     json_data = json.loads(json_category_list)['traceCategoriesList']
     for item in json_data:
       for category in item.split(','):
         if category.startswith('disabled-by-default'):
           disabled_by_default_categories.add(category)
         else:
           record_categories.add(category)
 
     return list(record_categories), list(disabled_by_default_categories)
 
+  def _SetupStartupTracing(self):
+    changer = flag_changer.FlagChanger(
+        self._device, self._package_info.cmdline_file)
+    changer.AddFlags(['--trace-startup'])
+    self._device.old_interface.CloseApplication(self._package_info.package)
+    if self._startup == 'cold':
+      self._device.old_interface.EnableAdbRoot()
+      adb = android_commands.AndroidCommands()
+      adb.RunShellCommand('echo 1 > /proc/vm/drop_caches')
+    self._device.old_interface.StartActivity(
+        package=self._package_info.package,
+        activity=self._package_info.activity,
+        data='http://www.google.com/',

[pasko, 2015/01/27 12:59:00]

so we are starting chrome right after we drop caches? why? will it only be able
to trace the startup of only this page?

[Benoit L, 2015/01/27 16:31:33]

Acknowledged.

+        extras={'create_new_tab' : True})
+
   def StartTracing(self, interval):
+    if self._startup:
+      self._SetupStartupTracing()
     self._trace_interval = interval
     self._device.old_interface.SyncLogCat()
     start_extras = {'categories': ','.join(self._categories)}
     if self._ring_buffer:
       start_extras['continuous'] = None
     self._device.BroadcastIntent(intent.Intent(
         action='%s.GPU_PROFILER_START' % self._package_info.package,
         extras=start_extras))
 
     if self._trace_memory:
       self._device.old_interface.EnableAdbRoot()
       self._device.SetProp(_HEAP_PROFILE_MMAP_PROPERTY, 1)
 
     # Chrome logs two different messages related to tracing:
     #
     # 1. "Logging performance trace to file"
     # 2. "Profiler finished. Results are in [...]"
     #
     # The first one is printed when tracing starts and the second one indicates
     # that the trace file is ready to be pulled.
-    try:
-      self._device.old_interface.WaitForLogMatch(
-          self._trace_start_re, None, timeout=5)
-      self._is_tracing = True
-    except pexpect.TIMEOUT:
-      raise RuntimeError('Trace start marker not found. Is the correct version '
-                         'of the browser running?')
+    if not self._startup:
+      try:
+        self._device.old_interface.WaitForLogMatch(
+            self._trace_start_re, None, timeout=5)
+      except pexpect.TIMEOUT:
+        raise RuntimeError('Trace start marker not found. Is the correct '
+                           'version of the browser running?')
+    self._is_tracing = True

[Sami, 2015/01/27 13:15:46]

This should still be set depending on whether we saw the log match or not.
Otherwise StopTracing will end up sitting around for 120 seconds of the user
told us to use a wrong browser.

[Benoit L, 2015/01/27 13:50:25]

If I understand the code correctly, when we don't have a match in 5s, an
exception is raised, and _is_tracing will not be set.
For startup tracing, there is no startup marker.

[Sami, 2015/01/27 14:19:55]

Ah, sorry, you're right.

 
   def StopTracing(self):
     if self._is_tracing:
       self._device.BroadcastIntent(intent.Intent(
           action='%s.GPU_PROFILER_STOP' % self._package_info.package))
       self._trace_file = self._device.old_interface.WaitForLogMatch(
           self._trace_finish_re, None, timeout=120).group(1)
       self._is_tracing = False
     if self._trace_memory:
       self._device.SetProp(_HEAP_PROFILE_MMAP_PROPERTY, 0)
 
   def PullTrace(self):
     # Wait a bit for the browser to finish writing the trace file.
     time.sleep(self._trace_interval / 4 + 1)
-
     trace_file = self._trace_file.replace('/storage/emulated/0/', '/sdcard/')
     host_file = os.path.join(os.path.curdir, os.path.basename(trace_file))
     self._device.PullFile(trace_file, host_file)
     return host_file