Move smoothness to the new API

tools/perf/measurements/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 metrics import timeline as timeline_module
 from metrics import timeline_interaction_record as tir_module
+from metrics import smoothness
 from telemetry.page import page_measurement
 from telemetry.core.timeline import model as model_module
 
 
-
 # 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'
 MINIMAL_OVERHEAD_LEVEL = 'minimal-overhead'
 DEBUG_OVERHEAD_LEVEL = 'debug-overhead'
 
 ALL_OVERHEAD_LEVELS = [
   NO_OVERHEAD_LEVEL,
   MINIMAL_OVERHEAD_LEVEL,
   DEBUG_OVERHEAD_LEVEL
 ]
 
 
 class _TimelineBasedMetrics(object):
   def __init__(self, model, renderer_thread):
     self._model = model
     self._renderer_thread = renderer_thread
 
   def FindTimelineInteractionRecords(self):
     # TODO(nduca): Add support for page-load interaction record.
-    return [tir_module.TimelineInteractionRecord(event) for
+    return [tir_module.TimelineInteractionRecord.FromEvent(event) for
             event in self._renderer_thread.IterAllAsyncSlices()
             if tir_module.IsTimelineInteractionRecord(event.name)]
 
   def CreateMetricsForTimelineInteractionRecord(self, interaction):
     res = []
     if interaction.is_smooth:
-      pass # TODO(nduca): res.append smoothness metric instance.
+      res.append(smoothness.SmoothnessMetric())
     return res
 
   def AddResults(self, results):
     interactions = self.FindTimelineInteractionRecords()
     if len(interactions) == 0:
       raise Exception('Expected at least one Interaction on the page')
     for interaction in interactions:
       metrics = self.CreateMetricsForTimelineInteractionRecord(interaction)
       for m in metrics:
         m.AddResults(self._model, self._renderer_thread,
@@ skipping 49 matching lines @@
       categories = '*,disabled-by-default-cc.debug'
     tab.browser.StartTracing(categories)
 
   def MeasurePage(self, page, tab, results):
     """ Collect all possible metrics and added them to results. """
     trace_result = tab.browser.StopTracing()
     model = model_module.TimelineModel(trace_result)
     renderer_thread = model.GetRendererThreadFromTab(tab)
     meta_metrics = _TimelineBasedMetrics(model, renderer_thread)
     meta_metrics.AddResults(results)