mac: Expose keychain access frequency to Telemetry.

tools/perf/benchmarks/service_worker.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 collections
 import page_sets
 import re
 
+from measurements import PageTestMeasurement
 from measurements import timeline_controller
 from metrics import speedindex
 from telemetry import benchmark
 from telemetry.core import util
-from telemetry.page import page_test
 from telemetry.timeline import async_slice as async_slice_module
 from telemetry.timeline import slice as slice_module
 from telemetry.value import scalar
 
 
 class _ServiceWorkerTimelineMetric(object):
   def AddResultsOfCounters(self, process, counter_regex_string, results):
     counter_filter = re.compile(counter_regex_string)
     for counter_name, counter in process.counters.iteritems():
       if not counter_filter.search(counter_name):
@@ skipping 51 matching lines @@
 
     full_name = thread_name + '|' + sanitized_event_name
     results.AddValue(scalar.ScalarValue(
         results.current_page, full_name, 'ms', total))
     results.AddValue(scalar.ScalarValue(
         results.current_page, full_name + '_max', 'ms', biggest_jank))
     results.AddValue(scalar.ScalarValue(
         results.current_page, full_name + '_avg', 'ms', total / len(times)))
 
 
-class _ServiceWorkerMeasurement(page_test.PageTest):
+class _ServiceWorkerMeasurement(PageTestMeasurement):
   """Measure Speed Index and TRACE_EVENTs"""
 
   def __init__(self, *args, **kwargs):
     super(_ServiceWorkerMeasurement, self).__init__(*args, **kwargs)
     self._timeline_controller = timeline_controller.TimelineController()
     self._speed_index = speedindex.SpeedIndexMetric()
     self._page_open_times = collections.defaultdict(int)
 
   def CustomizeBrowserOptions(self, options):
+    super(_ServiceWorkerMeasurement, self).CustomizeBrowserOptions(options)
     options.AppendExtraBrowserArgs([
         '--enable-experimental-web-platform-features'
       ])
 
   def WillNavigateToPage(self, page, tab):
     self._timeline_controller.SetUp(page, tab)
     self._timeline_controller.Start(tab)
     self._speed_index.Start(page, tab)
 
   def ValidateAndMeasurePage(self, page, tab, results):
     tab.WaitForDocumentReadyStateToBeComplete(40)
     self._timeline_controller.Stop(tab)
 
     # Retrieve TRACE_EVENTs
     timeline_metric = _ServiceWorkerTimelineMetric()
     browser_process = self._timeline_controller.model.browser_process
     filter_text = '(RegisterServiceWorker|'\
                   'UnregisterServiceWorker|'\
                   'ProcessAllocate|'\
                   'FindRegistrationForDocument|'\
                   'DispatchFetchEvent)'
     timeline_metric.AddResultsOfEvents(
         browser_process, 'IOThread', filter_text , results)
+    super(_ServiceWorkerMeasurement, self).ValidateAndMeasurePage(
+        page, tab, results)
 
     # Record Speed Index
     def SpeedIndexIsFinished():
       return self._speed_index.IsFinished(tab)
     util.WaitFor(SpeedIndexIsFinished, 60)
     self._speed_index.Stop(page, tab)
     # Distinguish the first and second load from the subsequent loads
     url = str(page)
     chart_prefix = 'page_load'
     self._page_open_times[url] += 1
     if self._page_open_times[url] == 1:
       chart_prefix += '_1st'
     elif self._page_open_times[url] == 2:
       chart_prefix += '_2nd'
     else:
       chart_prefix += '_later'
     self._speed_index.AddResults(tab, results, chart_prefix)
 
 
-class _ServiceWorkerMicroBenchmarkMeasurement(page_test.PageTest):
+class _ServiceWorkerMicroBenchmarkMeasurement(PageTestMeasurement):
   """Measure JS land values and TRACE_EVENTs"""
 
   def __init__(self, *args, **kwargs):
     super(_ServiceWorkerMicroBenchmarkMeasurement, self).__init__(*args,
                                                                   **kwargs)
     self._timeline_controller = timeline_controller.TimelineController()
 
   def CustomizeBrowserOptions(self, options):
+    super(_ServiceWorkerMicroBenchmarkMeasurement, self).\
+        CustomizeBrowserOptions(options)
     options.AppendExtraBrowserArgs([
         '--enable-experimental-web-platform-features'
       ])
 
   def WillNavigateToPage(self, page, tab):
     self._timeline_controller.SetUp(page, tab)
     self._timeline_controller.Start(tab)
 
   def ValidateAndMeasurePage(self, page, tab, results):
     tab.WaitForJavaScriptExpression('window.done', 40)
     self._timeline_controller.Stop(tab)
 
     # Measure JavaScript-land
     json = tab.EvaluateJavaScript('window.results || {}')
     for key, value in json.iteritems():
       results.AddValue(scalar.ScalarValue(
           results.current_page, key, value['units'], value['value']))
 
     # Retrieve TRACE_EVENTs
     timeline_metric = _ServiceWorkerTimelineMetric()
     browser_process = self._timeline_controller.model.browser_process
     filter_text = '(RegisterServiceWorker|'\
                   'UnregisterServiceWorker|'\
                   'ProcessAllocate|'\
                   'FindRegistrationForDocument|'\
                   'DispatchFetchEvent)'
     timeline_metric.AddResultsOfEvents(
         browser_process, 'IOThread', filter_text , results)
+    super(_ServiceWorkerMicroBenchmarkMeasurement, self).ValidateAndMeasurePage(
+        page, tab, results)
 
 
 @benchmark.Enabled('android')
 class ServiceWorkerPerfTest(benchmark.Benchmark):
   """Performance test on public applications using ServiceWorker"""
   test = _ServiceWorkerMeasurement
   page_set = page_sets.ServiceWorkerPageSet
 
 
 # FIXME(nhiroki): Temporary disable the benchmark (http://crbug.com/430232).
 @benchmark.Disabled
 class ServiceWorkerMicroBenchmarkPerfTest(benchmark.Benchmark):
   """Service Worker performance test using a micro benchmark page set"""
   test = _ServiceWorkerMicroBenchmarkMeasurement
   page_set = page_sets.ServiceWorkerMicroBenchmarkPageSet