CL for perf tryjob on android

tools/perf/measurements/blink_style.py

 # 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.
 
 from itertools import starmap
 from collections import defaultdict
-
 from telemetry.core import util
+from telemetry.core import exceptions
 from telemetry.page import page_test
 from telemetry.value import scalar
 
 from measurements import timeline_controller
 
 
 class BlinkStyle(page_test.PageTest):
   def __init__(self):
     super(BlinkStyle, self).__init__()
     self._controller = None
 
   def WillNavigateToPage(self, page, tab):
     self._controller = timeline_controller.TimelineController()
-    self._controller.trace_categories = 'blink,benchmark,blink.console'
+    self._controller.trace_categories = 'blink_style,blink.console'
     self._controller.SetUp(page, tab)
     self._controller.Start(tab)
 
   def CleanUpAfterPage(self, page, tab):
     if self._controller:
       self._controller.CleanUp(tab)
 
   def ValidateAndMeasurePage(self, page, tab, results):
-    tab.WaitForDocumentReadyStateToBeComplete()
-    if not util.WaitFor(tab.HasReachedQuiescence, 30):
-      raise page_test.MeasurementFailure('Failed to reach quiesence.')
+    tab.ExecuteJavaScript('console.time("wait-for-quiescence");')
+    try:
+      util.WaitFor(tab.HasReachedQuiescence, 15)
+    except exceptions.TimeoutException:
+      # Some sites never reach quiesence. As this benchmark normalizes/
+      # categories results, it shouldn't be necessary to reach the same
+      # state on every run.
+      pass
+    tab.ExecuteJavaScript('console.timeEnd("wait-for-quiescence");')
 
     tab.ExecuteJavaScript(
         'console.time("style-update");'
         # Occasionally documents will break the APIs we need.
         'try {'
         # Invalidate style for the whole document.
         '  document && (document.documentElement.lang += "z");'
         # Force a style update (but not layout).
         '  getComputedStyle(document.documentElement).color;'
         '} catch (e) {}'
@@ skipping 11 matching lines @@
     def duration(event):
       if event.has_thread_timestamps:
         return event.thread_duration
       else:
         return event.duration
 
     for event in renderer.all_slices:
       if (event.name == 'Document::updateStyle'
           and event.start >= marker.start
           and event.end <= marker.end):
-        access_count = event.args['resolverAccessCount']
+        access_count = event.get('resolverAccessCount')
+        if access_count is None:
+          # absent in earlier versions
+          continue
         min_access_count = 50
 
         if access_count >= min_access_count:
           result = 1000 * (duration(event) / access_count)
           results.AddValue(scalar.ScalarValue(
               page, 'update_style', 'ms/1000 elements', result))
 
     class ParserEvent(object):
       def __init__(self, summary_event, tokenize_event, parse_event):
         min_sheet_length = 1000
@@ skipping 36 matching lines @@
       tokens = sum(event.tokens for event in events)
       length = sum(event.length for event in events)
 
       results.AddValue(
           scalar.ScalarValue(page, ('parse_css_%s' % category),
                              'tokens/s', 1000 / (parse_duration / tokens)))
 
       results.AddValue(
           scalar.ScalarValue(page, ('tokenize_css_%s' % category),
                              'char/s',  1000 / (tokenize_duration / length)))