[Telemetry] Output all timeline based metrics on all timeline interaction records

BUG=444697

Review URL: https://codereview.chromium.org/965953002

Cr-Commit-Position: refs/heads/master@{#318918}

tools/perf/benchmarks/gpu_times.py

@@ -13,18 +13,13 @@ TOPLEVEL_CATEGORIES = ['disabled-by-default-gpu.device',
                        'disabled-by-default-gpu.service']
 
 
-def _GetGPUTimelineMetric(_):
-      return [gpu_timeline.GPUTimelineMetric()]
-
-
 class _GPUTimes(benchmark.Benchmark):
   def CreateTimelineBasedMeasurementOptions(self):
     cat_string = ','.join(TOPLEVEL_CATEGORIES)
     cat_filter = tracing_category_filter.TracingCategoryFilter(cat_string)
 
     return timeline_based_measurement.Options(
-        overhead_level=cat_filter,
-        get_metrics_from_flags_callback=_GetGPUTimelineMetric)
+        overhead_level=cat_filter)
 
   @classmethod
   def ValueCanBeAddedPredicate(cls, value):

tools/telemetry/telemetry/web_perf/timeline_based_measurement.py

@@ -12,6 +12,7 @@ from telemetry.value import trace
 from telemetry.web_perf import timeline_interaction_record as tir_module
 from telemetry.web_perf.metrics import responsiveness_metric
 from telemetry.web_perf.metrics import smoothness
+from telemetry.web_perf.metrics import layout
 
 # TimelineBasedMeasurement considers all instrumentation as producing a single
 # timeline. But, depending on the amount of instrumentation that is enabled,
@@ -27,23 +28,18 @@ ALL_OVERHEAD_LEVELS = [
   DEBUG_OVERHEAD_LEVEL
 ]
 
-DEFAULT_METRICS = {
-  tir_module.IS_SMOOTH: smoothness.SmoothnessMetric,
-  tir_module.IS_RESPONSIVE: responsiveness_metric.ResponsivenessMetric,
-}
 
-class InvalidInteractions(Exception):
-  pass
+def _GetAllTimelineBasedMetrics():
+  # TODO(nednguyen): use discovery pattern to return all the instances of
+  # all TimelineBasedMetrics class in web_perf/metrics/ folder.
+  # This cannot be done until crbug.com/460208 is fixed.
+  return (smoothness.SmoothnessMetric(),
+          responsiveness_metric.ResponsivenessMetric(),
+          layout.LayoutMetric())
 
 
-def _GetMetricsFromFlags(record_custom_flags):
-  flags_set = set(record_custom_flags)
-  unknown_flags = flags_set.difference(DEFAULT_METRICS)
-  if unknown_flags:
-    raise Exception("Unknown metric flags: %s" % sorted(unknown_flags))
-
-  return [metric() for flag, metric in DEFAULT_METRICS.iteritems()
-          if flag in flags_set]
+class InvalidInteractions(Exception):
+  pass
 
 
 # TODO(nednguyen): Get rid of this results wrapper hack after we add interaction
@@ -86,13 +82,10 @@ def _GetRendererThreadsToInteractionRecordsMap(model):
 
 
 class _TimelineBasedMetrics(object):
-  def __init__(self, model, renderer_thread, interaction_records,
-               get_metrics_from_flags_callback):
+  def __init__(self, model, renderer_thread, interaction_records):
     self._model = model
     self._renderer_thread = renderer_thread
     self._interaction_records = interaction_records
-    self._get_metrics_from_flags_callback = \
-        get_metrics_from_flags_callback
 
   def AddResults(self, results):
     interactions_by_label = defaultdict(list)
@@ -118,8 +111,7 @@ class _TimelineBasedMetrics(object):
         raise InvalidInteractions('Interaction records with the same logical '
                                   'name must have the same flags.')
 
-    metrics_list = self._get_metrics_from_flags_callback(records_custom_flags)
-    for metric in metrics_list:
+    for metric in _GetAllTimelineBasedMetrics():
       metric.AddResults(self._model, self._renderer_thread,
                         interactions, wrapped_results)
 
@@ -131,8 +123,7 @@ class Options(object):
   Benchmark.CreateTimelineBasedMeasurementOptions.
   """
 
-  def __init__(self, overhead_level=NO_OVERHEAD_LEVEL,
-               get_metrics_from_flags_callback=_GetMetricsFromFlags):
+  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.
@@ -140,9 +131,6 @@ class Options(object):
     overhead_level: Can either be a custom TracingCategoryFilter object or
         one of NO_OVERHEAD_LEVEL, MINIMAL_OVERHEAD_LEVEL or
         DEBUG_OVERHEAD_LEVEL.
-    get_metrics_from_flags_callback: Callback function which returns a
-        a list of metrics based on timeline record flags. See the default
-        _GetMetricsFromFlags() as an example.
     """
     if (not isinstance(overhead_level,
                        tracing_category_filter.TracingCategoryFilter) and
@@ -153,7 +141,6 @@ class Options(object):
 
     self._overhead_level = overhead_level
     self._extra_category_filters = []
-    self._get_metrics_from_flags_callback = get_metrics_from_flags_callback
 
   def ExtendTraceCategoryFilters(self, filters):
     self._extra_category_filters.extend(filters)
@@ -166,10 +153,6 @@ class Options(object):
   def overhead_level(self):
     return self._overhead_level
 
-  @property
-  def get_metrics_from_flags_callback(self):
-    return self._get_metrics_from_flags_callback
-
 
 class TimelineBasedMeasurement(object):
   """Collects multiple metrics based on their interaction records.
@@ -244,8 +227,7 @@ class TimelineBasedMeasurement(object):
     for renderer_thread, interaction_records in (
         threads_to_records_map.iteritems()):
       meta_metrics = _TimelineBasedMetrics(
-          model, renderer_thread, interaction_records,
-          self._tbm_options.get_metrics_from_flags_callback)
+          model, renderer_thread, interaction_records)
       meta_metrics.AddResults(results)
 
   def DidRunUserStory(self, tracing_controller):

tools/telemetry/telemetry/web_perf/timeline_based_measurement_unittest.py

@@ -42,22 +42,6 @@ class FakeLoadingMetric(timeline_based_metric.TimelineBasedMetric):
         len(interaction_records)))
 
 
-FAKE_METRICS_METRICS = {
-  tir_module.IS_SMOOTH: FakeSmoothMetric,
-  tir_module.IS_RESPONSIVE: FakeLoadingMetric,
-}
-
-
-def GetMetricFromFlags(record_custom_flags):
-  flags_set = set(record_custom_flags)
-  unknown_flags = flags_set.difference(FAKE_METRICS_METRICS)
-  if unknown_flags:
-    raise Exception("Unknown metric flags: %s" % sorted(unknown_flags))
-
-  return [metric() for flag, metric in FAKE_METRICS_METRICS.iteritems()
-          if flag in flags_set]
-
-
 class TimelineBasedMetricTestData(object):
 
   def __init__(self):
@@ -111,13 +95,21 @@ class TimelineBasedMetricTestData(object):
   def AddResults(self):
     for thread, records in self._threads_to_records_map.iteritems():
       metric = tbm_module._TimelineBasedMetrics(  # pylint: disable=W0212
-        self._model, thread, records, GetMetricFromFlags)
+        self._model, thread, records)
       metric.AddResults(self._results)
     self._results.DidRunPage(self._ps.pages[0])
 
 
 class TimelineBasedMetricsTests(unittest.TestCase):
 
+  def setUp(self):
+    self.actual_get_all_tbm_metrics = tbm_module._GetAllTimelineBasedMetrics
+    fake_tbm_metrics = (FakeSmoothMetric(), FakeLoadingMetric())
+    tbm_module._GetAllTimelineBasedMetrics = lambda: fake_tbm_metrics
+
+  def tearDown(self):
+    tbm_module._GetAllTimelineBasedMetrics = self.actual_get_all_tbm_metrics
+
   def testGetRendererThreadsToInteractionRecordsMap(self):
     d = TimelineBasedMetricTestData()
     # Insert 2 interaction records to renderer_thread and 1 to foo_thread