Record the time to requestStart from the javascript timings API as part of the startup benchmark.

tools/perf/metrics/startup_metric.py

 # Copyright 2013 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 collections
 import json
 import logging
 
 from metrics import Metric
 from metrics import histogram_util
 
@@ skipping 29 matching lines @@
         tab)
     if high_bytes == 0 and low_bytes == 0:
       return None
     return (int(high_bytes) << 32) | (int(low_bytes) << 1)
 
   def _RecordTabLoadTimes(self, tab, browser_main_entry_time_ms, results):
     """Records the tab load times for the browser. """
     tab_load_times = []
     TabLoadTime = collections.namedtuple(
         'TabLoadTime',
-        ['load_start_ms', 'load_duration_ms'])
+        ['load_start_ms', 'load_duration_ms', 'request_start_ms'])
 
     def RecordTabLoadTime(t):
       try:
         t.WaitForDocumentReadyStateToBeComplete()
 
         result = t.EvaluateJavaScript(
             'statsCollectionController.tabLoadTiming()')
         result = json.loads(result)
 
         if 'load_start_ms' not in result or 'load_duration_ms' not in result:
           raise Exception("Outdated Chrome version, "
               "statsCollectionController.tabLoadTiming() not present")
         if result['load_duration_ms'] is None:
           tab_title = t.EvaluateJavaScript('document.title')
           print "Page: ", tab_title, " didn't finish loading."
           return
 
+        perf_timing = t.EvaluateJavaScript('window.performance.timing')
+        if 'requestStart' not in perf_timing:
+          raise Exception("requestStart not in window performance timings")

[pasko, 2014/09/17 13:25:08]

this would abort execution of all tests. Even if all browsers able to run with
telemetry have requestStart, still scary.

[azarchs, 2014/09/17 13:57:16]

Done.

+
         tab_load_times.append(TabLoadTime(
             int(result['load_start_ms']),
-            int(result['load_duration_ms'])))
+            int(result['load_duration_ms']),
+            int(perf_timing['requestStart'])))
       except util.TimeoutException:
         # Low memory Android devices may not be able to load more than
         # one tab at a time, so may timeout when the test attempts to
         # access a background tab. Ignore these tabs.
         logging.error("Tab timed out on JavaScript access")
 
     # Only measure the foreground tab. We can't measure all tabs on Android
     # because on Android the data of the background tabs is loaded on demand,
     # when the user switches to them, rather than during startup. In view of
     # this, to get the same measures on all platform, we only measure the
     # foreground tab on all platforms.
 
     RecordTabLoadTime(tab.browser.foreground_tab)
 
     foreground_tab_stats = tab_load_times[0]
     foreground_tab_load_complete = ((foreground_tab_stats.load_start_ms +
         foreground_tab_stats.load_duration_ms) - browser_main_entry_time_ms)
     results.AddValue(scalar.ScalarValue(
         results.current_page, 'foreground_tab_load_complete', 'ms',
         foreground_tab_load_complete))
+    if (foreground_tab_stats.request_start_ms > 0):
+      results.AddValue(scalar.ScalarValue(
+          results.current_page, 'foreground_tab_request_start', 'ms',

[pasko, 2014/09/17 13:25:08]

why absolute value and not the relative one? LoadingMetric reports it as
relative to navigationStart. I am not sure in which circumstances we use each
metric though.

[azarchs, 2014/09/17 13:57:16]

The value reported here is relative to the process start. 
window.performance.timing.requestStart is an absolute time from 1970.

+          foreground_tab_stats.request_start_ms - browser_main_entry_time_ms))
 
   def AddResults(self, tab, results):
     get_histogram_js = 'statsCollectionController.getBrowserHistogram("%s")'
 
     for display_name, histogram_name in self.HISTOGRAMS_TO_RECORD.iteritems():
       result = tab.EvaluateJavaScript(get_histogram_js % histogram_name)
       result = json.loads(result)
       measured_time = 0
 
       if 'sum' in result:
         # For all the histograms logged here, there's a single entry so sum
         # is the exact value for that entry.
         measured_time = result['sum']
       elif 'buckets' in result:
         measured_time = \
             (result['buckets'][0]['high'] + result['buckets'][0]['low']) / 2
 
       results.AddValue(scalar.ScalarValue(
           results.current_page, display_name, 'ms', measured_time))
 
     # Get tab load times.
     browser_main_entry_time_ms = self._GetBrowserMainEntryTime(tab)
     if (browser_main_entry_time_ms is None):
       print "Outdated Chrome version, browser main entry time not supported."
       return
     self._RecordTabLoadTimes(tab, browser_main_entry_time_ms, results)