CL for perf tryjob on android

tools/perf/measurements/page_cycler.py

 # Copyright 2012 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.
 
 """The page cycler measurement.
 
 This measurement registers a window load handler in which is forces a layout and
 then records the value of performance.now(). This call to now() measures the
 time from navigationStart (immediately after the previous page's beforeunload
 event) until after the layout in the page's load event. In addition, two garbage
@@ skipping 10 matching lines @@
 from telemetry.core import util
 from telemetry.page import page_test
 from telemetry.value import scalar
 
 from metrics import cpu
 from metrics import keychain_metric
 from metrics import memory
 from metrics import power
 from metrics import speedindex
 
+from telemetry.timeline import tracing_config
+from telemetry.timeline import tracing_category_filter
+
 
 class PageCycler(page_test.PageTest):
 
   def __init__(self, page_repeat, pageset_repeat, cold_load_percent=50,
                report_speed_index=False, clear_cache_before_each_run=False):
     super(PageCycler, self).__init__(
         clear_cache_before_each_run=clear_cache_before_each_run)
 
     with open(os.path.join(os.path.dirname(__file__),
                            'page_cycler.js'), 'r') as f:
@@ skipping 27 matching lines @@
   def WillStartBrowser(self, platform):
     """Initialize metrics once right before the browser has been launched."""
     self._power_metric = power.PowerMetric(platform)
 
   def DidStartBrowser(self, browser):
     """Initialize metrics once right after the browser has been launched."""
     self._memory_metric = memory.MemoryMetric(browser)
     self._cpu_metric = cpu.CpuMetric(browser)
 
   def WillNavigateToPage(self, page, tab):
+    category_filter = tracing_category_filter.TracingCategoryFilter(
+        'blink.user_timing')
+    config = tracing_config.TracingConfig()
+    config.SetTracingCategoryFilter(category_filter)
+    tab.browser.platform.tracing_controller.StartTracing(config)
     if page.is_file:
       # For legacy page cyclers which use the filesystem, do an initial
       # navigate to avoid paying for a cross-renderer navigation.
       initial_url = tab.browser.platform.http_server.UrlOf('nonexistent.html')
       if self._initial_renderer_url != initial_url:
         self._initial_renderer_url = initial_url
         tab.Navigate(self._initial_renderer_url)
 
     page.script_to_evaluate_on_commit = self._page_cycler_js
     if self.ShouldRunCold(page.url):
@@ skipping 27 matching lines @@
         'ms', tab.EvaluateJavaScript('__pc_load_time'),
         description='Average page load time. Measured from '
                     'performance.timing.navigationStart until the completion '
                     'time of a layout after the window.load event. Cold times '
                     'are the times when the page is loaded cold, i.e. without '
                     'loading it before, and warm times are times when the '
                     'page is loaded after being loaded previously.'))
 
     self._has_loaded_page[page.url] += 1
 
+    tab.browser.platform.tracing_controller.StopTracing()
     self._power_metric.Stop(page, tab)
     self._memory_metric.Stop(page, tab)
     self._memory_metric.AddResults(tab, results)
     self._power_metric.AddResults(tab, results)
 
     self._cpu_metric.Stop(page, tab)
     self._cpu_metric.AddResults(tab, results)
 
     if self._report_speed_index:
       def SpeedIndexIsFinished():
@@ skipping 12 matching lines @@
     # preserve any initial profile cache for as long as possible.
     # The second is that, if we did cold runs first, we'd have a transition
     # page set during which we wanted the run for each URL to both
     # contribute to the cold data and warm the catch for the following
     # warm run, and clearing the cache before the load of the following
     # URL would eliminate the intended warmup for the previous URL.
     return self._has_loaded_page[url] >= self._cold_run_start_index
 
   def DidRunPage(self, platform):
     self._power_metric.Close()