Added GPU performance metrics.

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 03a90ad239a26c3e7f10723add0b54810d25d582..b09b1b25977b77313838ae19898b18f72304ec31 100644
--- a/tools/telemetry/telemetry/web_perf/timeline_based_measurement.py
+++ b/tools/telemetry/telemetry/web_perf/timeline_based_measurement.py
@@ -35,13 +35,13 @@ class InvalidInteractions(Exception):
   pass
 
 
-def _GetMetricFromMetricType(metric_type):
+def _GetMetricsFromMetricType(metric_type):
   if metric_type == tir_module.IS_FAST:
-    return fast_metric.FastMetric()
+    return [fast_metric.FastMetric()]
   if metric_type == tir_module.IS_SMOOTH:
-    return smoothness.SmoothnessMetric()
+    return [smoothness.SmoothnessMetric()]
   if metric_type == tir_module.IS_RESPONSIVE:
-    return responsiveness_metric.ResponsivenessMetric()
+    return [responsiveness_metric.ResponsivenessMetric()]
   raise Exception('Unrecognized metric type: %s' % metric_type)
 
 
@@ -84,12 +84,12 @@ def _GetRendererThreadsToInteractionRecordsMap(model):
 
 class _TimelineBasedMetrics(object):
   def __init__(self, model, renderer_thread, interaction_records,
-               get_metric_from_metric_type_callback):
+               get_metrics_from_metric_type_callback):
     self._model = model
     self._renderer_thread = renderer_thread
     self._interaction_records = interaction_records
-    self._get_metric_from_metric_type_callback = \
-        get_metric_from_metric_type_callback
+    self._get_metrics_from_metric_type_callback = \
+        get_metrics_from_metric_type_callback
 
   def AddResults(self, results):
     interactions_by_label = defaultdict(list)
@@ -115,9 +115,10 @@ class _TimelineBasedMetrics(object):
       if len(interactions_with_metric) != len(interactions):
         raise InvalidInteractions('Interaction records with the same logical '
                                   'name must have the same flags.')
-      metric = self._get_metric_from_metric_type_callback(metric_type)
-      metric.AddResults(self._model, self._renderer_thread,
-                        interactions, wrapped_results)
+      metrics_list = self._get_metrics_from_metric_type_callback(metric_type)
+      for metric in metrics_list:
+        metric.AddResults(self._model, self._renderer_thread,
+                          interactions, wrapped_results)
 
 
 class Options(object):
@@ -127,19 +128,29 @@ class Options(object):
   Benchmark.CreateTimelineBasedMeasurementOptions.
   """
 
-  def __init__(self, overhead_level=NO_OVERHEAD_LEVEL):
-    """Save the overhead level.
-
-    As the amount of instrumentation increases, so does the overhead.
+  def __init__(self, overhead_level=NO_OVERHEAD_LEVEL,
+               get_metrics_from_metric_type_callback=_GetMetricsFromMetricType):
+    """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: one of NO_OVERHEAD_LEVEL, V8_OVERHEAD_LEVEL,
-        MINIMAL_OVERHEAD_LEVEL, or DEBUG_OVERHEAD_LEVEL.
-        The v8 overhead level is a temporary solution that may be removed.
+    overhead_level: Can either be a custom TracingCategoryFilter object or
+        one of NO_OVERHEAD_LEVEL, V8_OVERHEAD_LEVEL, MINIMAL_OVERHEAD_LEVEL,
+        or DEBUG_OVERHEAD_LEVEL. The v8 overhead level is a temporary solution
+        that may be removed.
+    get_metrics_from_metric_type_callback: Callback function to create a metric

[nednguyen, 2015/01/24 00:32:22]

"return a list of metrics based on timeline interaction records' flag"

[David Yen, 2015/01/24 00:41:10]

Done.

+        object. See the default _GetMetricsFromMetricType() as an example.
     """
     self._overhead_level = overhead_level
+    self._get_metric_from_metric_type = get_metrics_from_metric_type_callback
 
+  @property
+  def overhead_level(self):
+    return self._overhead_level
+
+  @property
+  def get_metrics_from_metric_type_callback(self):
+    return self._get_metric_from_metric_type
 
 class TimelineBasedMeasurement(object):
   """Collects multiple metrics based on their interaction records.
@@ -164,7 +175,7 @@ class TimelineBasedMeasurement(object):
   perf.metrics.timeline_interaction_record module.
   """
   def __init__(self, options):
-    self._overhead_level = options._overhead_level
+    self._tbm_options = options
 
   def WillRunUserStory(self, tracing_controller,
                        synthetic_delay_categories=None):
@@ -179,18 +190,23 @@ class TimelineBasedMeasurement(object):
     """
     if not tracing_controller.IsChromeTracingSupported():
       raise Exception('Not supported')
-    assert self._overhead_level in ALL_OVERHEAD_LEVELS
-    if self._overhead_level == NO_OVERHEAD_LEVEL:
-      category_filter = tracing_category_filter.CreateNoOverheadFilter()
-    # TODO(ernstm): Remove this overhead level when benchmark relevant v8 events
-    # become available in the 'benchmark' category.
-    elif self._overhead_level == V8_OVERHEAD_LEVEL:
-      category_filter = tracing_category_filter.CreateNoOverheadFilter()
-      category_filter.AddIncludedCategory('v8')
-    elif self._overhead_level == MINIMAL_OVERHEAD_LEVEL:
-      category_filter = tracing_category_filter.CreateMinimalOverheadFilter()
+
+    if isinstance(self._tbm_options.overhead_level,
+                  tracing_category_filter.TracingCategoryFilter):
+      category_filter = self._tbm_options.overhead_level
     else:
-      category_filter = tracing_category_filter.CreateDebugOverheadFilter()
+      assert self._tbm_options.overhead_level in ALL_OVERHEAD_LEVELS
+      if self._tbm_options.overhead_level == NO_OVERHEAD_LEVEL:
+        category_filter = tracing_category_filter.CreateNoOverheadFilter()
+      # TODO(ernstm): Remove this overhead level when benchmark relevant v8
+      # events become available in the 'benchmark' category.
+      elif self._tbm_options.overhead_level == V8_OVERHEAD_LEVEL:
+        category_filter = tracing_category_filter.CreateNoOverheadFilter()
+        category_filter.AddIncludedCategory('v8')
+      elif self._tbm_options.overhead_level == MINIMAL_OVERHEAD_LEVEL:
+        category_filter = tracing_category_filter.CreateMinimalOverheadFilter()
+      else:
+        category_filter = tracing_category_filter.CreateDebugOverheadFilter()
 
     # TODO(slamm): Move synthetic_delay_categories to the TBM options.
     for delay in synthetic_delay_categories or []:
@@ -209,7 +225,8 @@ class TimelineBasedMeasurement(object):
     for renderer_thread, interaction_records in (
         threads_to_records_map.iteritems()):
       meta_metrics = _TimelineBasedMetrics(
-          model, renderer_thread, interaction_records, _GetMetricFromMetricType)
+          model, renderer_thread, interaction_records,
+          self._tbm_options.get_metrics_from_metric_type_callback)
       meta_metrics.AddResults(results)
 
   def DidRunUserStory(self, tracing_controller):