Implement Timeline Based Measurement v2

telemetry/telemetry/web_perf/timeline_based_measurement.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 logging
 from collections import defaultdict
 
+from tracing.metrics import metric_runner
+
 from telemetry.timeline import model as model_module
 from telemetry.timeline import tracing_category_filter
 from telemetry.timeline import tracing_config
 from telemetry.value import trace
+from telemetry.value import translate_common_values
 from telemetry.web_perf.metrics import timeline_based_metric
 from telemetry.web_perf.metrics import blob_timeline
 from telemetry.web_perf.metrics import jitter_timeline
 from telemetry.web_perf.metrics import webrtc_rendering_timeline
 from telemetry.web_perf.metrics import gpu_timeline
 from telemetry.web_perf.metrics import indexeddb_timeline
 from telemetry.web_perf.metrics import layout
 from telemetry.web_perf.metrics import memory_timeline
 from telemetry.web_perf.metrics import responsiveness_metric
 from telemetry.web_perf.metrics import smoothness
@@ skipping 160 matching lines @@
         self._config.SetNoOverheadFilter()
       elif overhead_level == MINIMAL_OVERHEAD_LEVEL:
         self._config.SetMinimalOverheadFilter()
       else:
         self._config.SetDebugOverheadFilter()
     else:
       raise Exception("Overhead level must be a TracingCategoryFilter object"
                       " or valid overhead level string."
                       " Given overhead level: %s" % overhead_level)
 
+    self._timeline_based_metrics = None
     self._legacy_timeline_based_metrics = _GetAllLegacyTimelineBasedMetrics()
 
 
   def ExtendTraceCategoryFilter(self, filters):
     for new_category_filter in filters:
       self._config.tracing_category_filter.AddIncludedCategory(
           new_category_filter)
 
   @property
   def category_filter(self):
     return self._config.tracing_category_filter
 
   @property
   def config(self):
     return self._config
 
   def SetTimelineBasedMetrics(self, metrics):
-    # TODO(eakuefner@): implement this
-    raise NotImplementedError()
+    """Sets the new-style (TBMv2) metrics to run.
+
+    Metrics are assumed to live in //tracing/tracing/metrics, so all paths
+    should be relative to that. For example, to specify sample_metric.html,
+    you would pass ['sample_metric.html'].
+
+    Args:
+      metrics: A list of string metric paths under //tracing/tracing/metrics.
+    """
+    assert isinstance(metrics, list)
+    self._legacy_timeline_based_metrics = None
+    self._timeline_based_metrics = metrics
 
   def GetTimelineBasedMetrics(self):
-    # TODO(eakuefner@): implement this
-    raise NotImplementedError()
+    return self._timeline_based_metrics
 
   def SetLegacyTimelineBasedMetrics(self, metrics):
+    assert self._timeline_based_metrics == None
     assert isinstance(metrics, collections.Iterable)
     for m in metrics:
       assert isinstance(m, timeline_based_metric.TimelineBasedMetric)
     self._legacy_timeline_based_metrics = metrics
 
   def GetLegacyTimelineBasedMetrics(self):
     return self._legacy_timeline_based_metrics
 
 
 class TimelineBasedMeasurement(story_test.StoryTest):
@@ skipping 31 matching lines @@
 
   def WillRunStory(self, platform):
     """Configure and start tracing."""
     if not platform.tracing_controller.IsChromeTracingSupported():
       raise Exception('Not supported')
     platform.tracing_controller.StartTracing(self._tbm_options.config)
 
   def Measure(self, platform, results):
     """Collect all possible metrics and added them to results."""
     trace_result = platform.tracing_controller.StopTracing()
-    results.AddValue(trace.TraceValue(results.current_page, trace_result))
+    trace_value = trace.TraceValue(results.current_page, trace_result)
+    results.AddValue(trace_value)
+
+    if self._tbm_options.GetTimelineBasedMetrics():
+      self._ComputeTimelineBasedMetrics(results, trace_value)
+    else:
+      assert self._tbm_options.GetLegacyTimelineBasedMetrics()
+      self._ComputeLegacyTimelineBasedMetrics(results, trace_result)
+
+
+  def DidRunStory(self, platform):
+    """Clean up after running the story."""
+    if platform.tracing_controller.is_tracing_running:
+      platform.tracing_controller.StopTracing()
+
+  def _ComputeTimelineBasedMetrics(self, results, trace_value):
+    metrics = self._tbm_options.GetTimelineBasedMetrics()
+
+    # TODO(eakuefner)
+    mre_result = metric_runner.RunMetrics(trace_value.filename, metrics)
+    page = results.current_page
+
+    failure_dicts = mre_result.failures
+    for d in failure_dicts:
+      results.AddValue(
+          translate_common_values.TranslateMreFailure(d, page))
+
+    value_dicts = mre_result.pairs.get('values', [])
+    for d in value_dicts:
+      results.AddValue(
+          translate_common_values.TranslateScalarValue(d, page))
+
+  def _ComputeLegacyTimelineBasedMetrics(self, results, 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.config.enable_chrome_trace):
       logging.warning(
           'No timeline interaction records were recorded in the trace. '
           'This could be caused by console.time() & console.timeEnd() execution'
           ' failure or the tracing category specified doesn\'t include '
           'blink.console categories.')
 
     all_metrics = self._tbm_options.GetLegacyTimelineBasedMetrics()
 
     for renderer_thread, interaction_records in (
         threads_to_records_map.iteritems()):
       meta_metrics = _TimelineBasedMetrics(
           model, renderer_thread, interaction_records, self._results_wrapper,
           all_metrics)
       meta_metrics.AddResults(results)
 
     for metric in all_metrics:
       metric.AddWholeTraceResults(model, results)
-
-  def DidRunStory(self, platform):
-    """Clean up after running the story."""
-    if platform.tracing_controller.is_tracing_running:
-      platform.tracing_controller.StopTracing()