Convert V8GCTimes measurement to timeline based measurement.

tools/perf/metrics/v8_gc_times_metric_unittest.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 import decorators
 from telemetry.internal.results import page_test_results
 from telemetry.page import page as page_module
 from telemetry.testing import options_for_unittests
 from telemetry.testing import page_test_test_case
 from telemetry.timeline import model as model_module
 from telemetry.util import wpr_modes
 
-from measurements import v8_gc_times
+from metrics import v8_gc_times_metric
 
 
 class V8GCTimesTestPageHelper(object):
 
   def __init__(self, page_set):
     self._page_set = page_set
     self._model = model_module.TimelineModel()
     self._renderer_process = self._model.GetOrCreateProcess(1)
     self._renderer_thread = self._renderer_process.GetOrCreateThread(2)
     self._renderer_thread.name = 'CrRendererMain'
@@ skipping 15 matching lines @@
 
   def MeasureFakePage(self):
     # Create a fake page and add it to the page set.
     results = page_test_results.PageTestResults()
     page = V8GCTimesTestPageHelper.MockV8GCTimesPage(self._page_set)
     self._page_set.AddStory(page)
 
     # Pretend we're about to run the tests to silence lower level asserts.
     results.WillRunPage(page)
 
-    v8_gc_times_metric = v8_gc_times.V8GCTimes()
+    metric = v8_gc_times_metric.V8GCTimesMetric()
     # pylint: disable=protected-access
-    v8_gc_times_metric._renderer_process = self._renderer_process
+    metric._renderer_process = self._renderer_process
 
     # Finalize the timeline import.
     self._model.FinalizeImport()
 
     # Measure the V8GCTimes metric and return the results
     # pylint: disable=protected-access
-    v8_gc_times_metric._AddV8MetricsToResults(self._renderer_process, results)
+    metric._AddV8MetricsToResults(self._renderer_process, results)
     results.DidRunPage(page)
     return results
 
 
 class V8GCTimesTests(page_test_test_case.PageTestTestCase):
 
   def setUp(self):
     self._options = options_for_unittests.GetCopy()
     self._options.browser_options.wpr_mode = wpr_modes.WPR_OFF
 
@@ skipping 193 matching lines @@
 
     self._AssertResultsEqual(expected, _ActualValues(results))
 
   def _AssertResultsEqual(self, expected, actual):
     for key in expected.iterkeys():
       self.assertIn(key, actual.keys())
       self.assertEqual(expected[key], actual[key],
           'Result for [' + key + '] - expected ' + str(expected[key]) +
           ' but got ' + str(actual[key]))
 
-  @decorators.Disabled('win')  # crbug.com/416502
-  def testCleanUpTrace(self):
-    self.TestTracingCleanedUp(v8_gc_times.V8GCTimes, self._options)
-
 
 def _ActualValues(results):
   return dict(list(
       (v.name, (v.units, v.value))
       for v in results.all_page_specific_values
       ))
 
 
 def _GetEmptyResults():
   return {'cpu_time': ('ms', 0.0),
@@ skipping 15 matching lines @@
           'v8_gc_scavenger': ('ms', 0.0),
           'v8_gc_scavenger_average': ('ms', 0.0),
           'v8_gc_scavenger_count': ('count', 0),
           'v8_gc_scavenger_max': ('ms', 0.0),
           'v8_gc_scavenger_idle_deadline_overrun': ('ms', 0.0),
           'v8_gc_scavenger_outside_idle': ('ms', 0.0),
           'v8_gc_scavenger_percentage_idle': ('idle%', 0.0),
           'v8_gc_total': ('ms', 0.0),
           'v8_gc_total_idle_deadline_overrun': ('ms', 0.0),
           'v8_gc_total_outside_idle': ('ms', 0.0)}