Convert V8GCTimes measurement to timeline based measurement.

tools/perf/metrics/v8_gc_times_metric.py

 # Copyright 2015 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 telemetry.page import page_test
-from telemetry.timeline.model import TimelineModel
-from telemetry.timeline import tracing_category_filter
-from telemetry.timeline import tracing_options
 from telemetry.util import statistics
 from telemetry.value import scalar
+from telemetry.web_perf.metrics import timeline_based_metric
 
 
-class V8GCTimes(page_test.PageTest):
-
-  _TIME_OUT_IN_SECONDS = 60
-  _CATEGORIES = ['blink.console',
-                 'renderer.scheduler',
-                 'v8',
-                 'webkit.console']
+class V8GCTimesMetric(timeline_based_metric.TimelineBasedMetric):
   _RENDERER_MAIN_THREAD = 'CrRendererMain'
   _IDLE_TASK_PARENT = 'SingleThreadIdleTaskRunner::RunTask'
 
   def __init__(self):
-    super(V8GCTimes, self).__init__()
+    super(V8GCTimesMetric, self).__init__()
 
-  def WillNavigateToPage(self, page, tab):
-    category_filter = tracing_category_filter.TracingCategoryFilter()
-
-    for category in self._CATEGORIES:
-      category_filter.AddIncludedCategory(category)
-
-    options = tracing_options.TracingOptions()
-    options.enable_chrome_trace = True
-
-    tab.browser.platform.tracing_controller.Start(
-        options, category_filter, self._TIME_OUT_IN_SECONDS)
-
-  def ValidateAndMeasurePage(self, page, tab, results):
-    trace_data = tab.browser.platform.tracing_controller.Stop()
-    timeline_model = TimelineModel(trace_data)
-    renderer_process = timeline_model.GetRendererProcessFromTabId(tab.id)
+  def AddResults(self, model, renderer_thread, interaction_records, results):
+    renderer_process = renderer_thread.parent
     self._AddV8MetricsToResults(renderer_process, results)
 
-  def DidRunPage(self, platform):
-    if platform.tracing_controller.is_tracing_running:
-      platform.tracing_controller.Stop()
-
   def _AddV8MetricsToResults(self, process, results):
     if process is None:
       return
 
     for thread in process.threads.values():
       if thread.name != self._RENDERER_MAIN_THREAD:
         continue
 
       self._AddV8EventStatsToResults(thread, results)
       self._AddCpuTimeStatsToResults(thread, results)
@@ skipping 124 matching lines @@
   for v8_event_stat in v8_event_stats_list:
     if v8_event_stat.src_event_name == event_name:
       return v8_event_stat
   return None
 
 
 def _ParentIdleTask(event):
   parent = event.parent_slice
   while parent:
     # pylint: disable=protected-access
-    if parent.name == V8GCTimes._IDLE_TASK_PARENT:
+    if parent.name == V8GCTimesMetric._IDLE_TASK_PARENT:
       return parent
     parent = parent.parent_slice
   return None
 
 
 class V8EventStat(object):
 
   def __init__(self, src_event_name, result_name, result_description):
     self.src_event_name = src_event_name
     self.result_name = result_name
     self.result_description = result_description
     self.thread_duration = 0.0
     self.thread_duration_inside_idle = 0.0
     self.idle_task_overrun_duration = 0.0
     self.max_thread_duration = 0.0
     self.count = 0
 
   @property
   def thread_duration_outside_idle(self):
     return self.thread_duration - self.thread_duration_inside_idle
 
   @property
   def percentage_thread_duration_during_idle(self):
     return statistics.DivideIfPossibleOrZero(
         100 * self.thread_duration_inside_idle, self.thread_duration)