mac: Expose keychain access frequency to Telemetry.

tools/perf/measurements/task_execution_time.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.
 
+from measurements import PageTestMeasurement
 from telemetry.core.platform import tracing_category_filter
 from telemetry.core.platform import tracing_options
 from telemetry.timeline.model import TimelineModel
-from telemetry.page import page_test
 from telemetry.util import statistics
 from telemetry.value import scalar
 
 _CATEGORIES = ['webkit.console',
               'blink.console',
               'benchmark',
               'toplevel',
               'blink',
               'cc',
               'v8']
 
-class TaskExecutionTime(page_test.PageTest):
+class TaskExecutionTime(PageTestMeasurement):
 
   _TIME_OUT_IN_SECONDS = 60
   _NUMBER_OF_RESULTS_TO_DISPLAY = 10
 
   def __init__(self):
     super(TaskExecutionTime, self).__init__('RunSmoothness')
     self._renderer_thread = None
 
   def WillNavigateToPage(self, page, tab):
     category_filter = tracing_category_filter.TracingCategoryFilter()
 
     for category in _CATEGORIES:
       category_filter.AddIncludedCategory(category)
 
     options = tracing_options.TracingOptions()
     options.enable_chrome_trace = True
 
     tab.browser.platform.tracing_controller.Start(
         options, category_filter, self._TIME_OUT_IN_SECONDS)
 
   def DidRunActions(self, page, tab):
     timeline_data = tab.browser.platform.tracing_controller.Stop()
     timeline_model = TimelineModel(timeline_data=timeline_data)
     self._renderer_thread = timeline_model.GetRendererThreadFromTabId(tab.id)
 
   def ValidateAndMeasurePage(self, page, tab, results):
+    super(TaskExecutionTime, self).ValidateAndMeasurePage(page, tab, results)
+
     tasks = TaskExecutionTime.GetTasks(self._renderer_thread.parent)
 
     sorted_tasks = sorted(tasks,
       key=lambda slice: slice.median_self_duration, reverse=True)
 
     for task in sorted_tasks[:self.GetExpectedResultCount()]:
       results.AddValue(scalar.ScalarValue(
         results.current_page,
         task.key,
         'ms',
@@ skipping 59 matching lines @@
   if key in dictionary:
     dictionary[key].Update(
         self_duration, total_duration, depth, parent)
   else:
     dictionary[key] = SliceData(
         key, self_duration, total_duration, depth, parent)
 
   # Process sub slices recursively
   for sub_slice in task_slice.sub_slices:
     ProcessTasksForSlice(dictionary, sub_slice, depth + 1, parent)