CL for perf tryjob on mac

tools/telemetry/telemetry/web_perf/timeline_based_measurement.py

Index: tools/telemetry/telemetry/web_perf/timeline_based_measurement.py
diff --git a/tools/telemetry/telemetry/web_perf/timeline_based_measurement.py b/tools/telemetry/telemetry/web_perf/timeline_based_measurement.py
index 3c80ccdd943531704b817612450cdf1a0eed3cb9..3305ab00828551efcfe2cbc414d841067ed5b956 100644
--- a/tools/telemetry/telemetry/web_perf/timeline_based_measurement.py
+++ b/tools/telemetry/telemetry/web_perf/timeline_based_measurement.py
@@ -4,10 +4,8 @@
 import collections
 from collections import defaultdict
 
+from telemetry.web_perf import tracing_based_measurement
 from telemetry.timeline import model as model_module
-from telemetry.timeline import tracing_category_filter
-from telemetry.timeline import tracing_options
-from telemetry.value import trace
 from telemetry.web_perf.metrics import timeline_based_metric
 from telemetry.web_perf.metrics import blob_timeline
 from telemetry.web_perf.metrics import gpu_timeline
@@ -21,21 +19,6 @@ from telemetry.web_perf import smooth_gesture_util
 from telemetry.web_perf import story_test
 from telemetry.web_perf import timeline_interaction_record as tir_module
 
-# TimelineBasedMeasurement considers all instrumentation as producing a single
-# timeline. But, depending on the amount of instrumentation that is enabled,
-# overhead increases. The user of the measurement must therefore chose between
-# a few levels of instrumentation.
-NO_OVERHEAD_LEVEL = 'no-overhead'
-MINIMAL_OVERHEAD_LEVEL = 'minimal-overhead'
-DEBUG_OVERHEAD_LEVEL = 'debug-overhead'
-
-ALL_OVERHEAD_LEVELS = [
-  NO_OVERHEAD_LEVEL,
-  MINIMAL_OVERHEAD_LEVEL,
-  DEBUG_OVERHEAD_LEVEL
-]
-
-
 def _GetAllTimelineBasedMetrics():
   # TODO(nednguyen): use discovery pattern to return all the instances of
   # all TimelineBasedMetrics class in web_perf/metrics/ folder.
@@ -140,7 +123,7 @@ class _TimelineBasedMetrics(object):
                         interactions, wrapped_results)
 
 
-class Options(object):
+class Options(tracing_based_measurement.Options):
   """A class to be used to configure TimelineBasedMeasurement.
 
   This is created and returned by
@@ -151,55 +134,11 @@ class Options(object):
   To customize your metric needs, use SetTimelineBasedMetrics().
   """
 
-  def __init__(self, overhead_level=NO_OVERHEAD_LEVEL):
-    """As the amount of instrumentation increases, so does the overhead.
-    The user of the measurement chooses the overhead level that is appropriate,
-    and the tracing is filtered accordingly.
-
-    overhead_level: Can either be a custom TracingCategoryFilter object or
-        one of NO_OVERHEAD_LEVEL, MINIMAL_OVERHEAD_LEVEL or
-        DEBUG_OVERHEAD_LEVEL.
-    """
-    self._category_filter = None
-    if isinstance(overhead_level,
-                  tracing_category_filter.TracingCategoryFilter):
-      self._category_filter = overhead_level
-    elif overhead_level in ALL_OVERHEAD_LEVELS:
-      if overhead_level == NO_OVERHEAD_LEVEL:
-        self._category_filter = tracing_category_filter.CreateNoOverheadFilter()
-      elif overhead_level == MINIMAL_OVERHEAD_LEVEL:
-        self._category_filter = (
-          tracing_category_filter.CreateMinimalOverheadFilter())
-      else:
-        self._category_filter = (
-          tracing_category_filter.CreateDebugOverheadFilter())
-    else:
-      raise Exception("Overhead level must be a TracingCategoryFilter object"
-                      " or valid overhead level string."
-                      " Given overhead level: %s" % overhead_level)
-
-    self._tracing_options = tracing_options.TracingOptions()
-    self._tracing_options.enable_chrome_trace = True
-    self._tracing_options.enable_platform_display_trace = True
+  def __init__(self,
+               overhead_level=tracing_based_measurement.NO_OVERHEAD_LEVEL):
+    super(Options, self).__init__(overhead_level)
     self._timeline_based_metrics = _GetAllTimelineBasedMetrics()
 
-
-  def ExtendTraceCategoryFilter(self, filters):
-    for new_category_filter in filters:
-      self._category_filter.AddIncludedCategory(new_category_filter)
-
-  @property
-  def category_filter(self):
-    return self._category_filter
-
-  @property
-  def tracing_options(self):
-    return self._tracing_options
-
-  @tracing_options.setter
-  def tracing_options(self, value):
-    self._tracing_options = value
-
   def SetTimelineBasedMetrics(self, metrics):
     assert isinstance(metrics, collections.Iterable)
     for m in metrics:
@@ -210,7 +149,8 @@ class Options(object):
     return self._timeline_based_metrics
 
 
-class TimelineBasedMeasurement(story_test.StoryTest):
+class TimelineBasedMeasurement(
+    tracing_based_measurement.TracingBasedMeasurement):
   """Collects multiple metrics based on their interaction records.
 
   A timeline based measurement shifts the burden of what metrics to collect onto
@@ -240,25 +180,15 @@ class TimelineBasedMeasurement(story_test.StoryTest):
         supported long term and to be removed when crbug.com/453109 is resolved.
   """
   def __init__(self, options, results_wrapper=None):
-    self._tbm_options = options
+    super(TimelineBasedMeasurement, self).__init__(options)
     self._results_wrapper = results_wrapper or _TBMResultWrapper()
 
-  def WillRunStory(self, platform):
-    """Configure and start tracing."""
-    if not platform.tracing_controller.IsChromeTracingSupported():
-      raise Exception('Not supported')
-
-    platform.tracing_controller.Start(self._tbm_options.tracing_options,
-                                      self._tbm_options.category_filter)
-
-  def Measure(self, platform, results):
+  def ComputeMetricsForTrace(self, trace_result, results):
     """Collect all possible metrics and added them to results."""
-    trace_result = platform.tracing_controller.Stop()
-    results.AddValue(trace.TraceValue(results.current_page, trace_result))
     model = model_module.TimelineModel(trace_result)
     threads_to_records_map = _GetRendererThreadsToInteractionRecordsMap(model)
     if (len(threads_to_records_map.values()) == 0 and
-        self._tbm_options.tracing_options.enable_chrome_trace):
+        self._options.tracing_options.enable_chrome_trace):
       raise story_test.Failure(
           'No timeline interaction records were recorded in the trace. '
           'This could be caused by console.time() & console.timeEnd() execution'
@@ -268,10 +198,6 @@ class TimelineBasedMeasurement(story_test.StoryTest):
         threads_to_records_map.iteritems()):
       meta_metrics = _TimelineBasedMetrics(
           model, renderer_thread, interaction_records,
-          self._results_wrapper, self._tbm_options.GetTimelineBasedMetrics())
+          self._results_wrapper,
+        self._options.GetTimelineBasedMetrics())
       meta_metrics.AddResults(results)
-
-  def DidRunStory(self, platform):
-    """Clean up after running the story."""
-    if platform.tracing_controller.is_tracing_running:
-      platform.tracing_controller.Stop()