Revert of [telemetry] Add a V8GCTimes measurement and benchmarks.

tools/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.
 
 from collections import defaultdict
 
 from telemetry.core.platform import tracing_category_filter
 from telemetry.core.platform import tracing_options
 from telemetry.page import page_test
 from telemetry.timeline import model as model_module
 from telemetry.value import trace
 from telemetry.web_perf import timeline_interaction_record as tir_module
+from telemetry.web_perf.metrics import fast_metric
 from telemetry.web_perf.metrics import responsiveness_metric
 from telemetry.web_perf.metrics import smoothness
 
 # 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'
+V8_OVERHEAD_LEVEL = 'v8-overhead'
 MINIMAL_OVERHEAD_LEVEL = 'minimal-overhead'
 DEBUG_OVERHEAD_LEVEL = 'debug-overhead'
 
 ALL_OVERHEAD_LEVELS = [
   NO_OVERHEAD_LEVEL,
+  V8_OVERHEAD_LEVEL,
   MINIMAL_OVERHEAD_LEVEL,
   DEBUG_OVERHEAD_LEVEL
 ]
 
 DEFAULT_METRICS = {
+  tir_module.IS_FAST: fast_metric.FastMetric,
   tir_module.IS_SMOOTH: smoothness.SmoothnessMetric,
   tir_module.IS_RESPONSIVE: responsiveness_metric.ResponsivenessMetric,
 }
 
 class InvalidInteractions(Exception):
   pass
 
 
 def _GetMetricsFromFlags(record_custom_flags):
   flags_set = set(record_custom_flags)
@@ skipping 90 matching lines @@
   Benchmark.CreateTimelineBasedMeasurementOptions.
   """
 
   def __init__(self, overhead_level=NO_OVERHEAD_LEVEL,
                get_metrics_from_flags_callback=_GetMetricsFromFlags):
     """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.
+        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_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
         overhead_level not in ALL_OVERHEAD_LEVELS):
       raise Exception("Overhead level must be a TracingCategoryFilter object"
                       " or valid overhead level string."
                       " Given overhead level: %s" % overhead_level)
@@ skipping 59 matching lines @@
 
     if isinstance(self._tbm_options.overhead_level,
                   tracing_category_filter.TracingCategoryFilter):
       category_filter = self._tbm_options.overhead_level
     else:
       assert self._tbm_options.overhead_level in ALL_OVERHEAD_LEVELS, (
           "Invalid TBM Overhead Level: %s" % self._tbm_options.overhead_level)
 
       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()
 
     for new_category_filter in self._tbm_options.extra_category_filters:
       category_filter.AddIncludedCategory(new_category_filter)
 
     # TODO(slamm): Move synthetic_delay_categories to the TBM options.
     for delay in synthetic_delay_categories or []:
@@ skipping 37 matching lines @@
         tracing_controller, page.GetSyntheticDelayCategories())
 
   def ValidateAndMeasurePage(self, page, tab, results):
     """Collect all possible metrics and added them to results."""
     tracing_controller = tab.browser.platform.tracing_controller
     self._measurement.Measure(tracing_controller, results)
 
   def CleanUpAfterPage(self, page, tab):
     tracing_controller = tab.browser.platform.tracing_controller
     self._measurement.DidRunUserStory(tracing_controller)