Convert V8GCTimes measurement to timeline based measurement.

tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency_unittest.py

Index: tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency_unittest.py
diff --git a/tools/perf/measurements/v8_gc_times_unittest.py b/tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency_unittest.py
similarity index 69%
copy from tools/perf/measurements/v8_gc_times_unittest.py
copy to tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency_unittest.py
index c5f6c0e69f9c48d8bd34039216df875e65fa7476..4061d52720c0ff75307d21fbbc26c111e2602cde 100644
--- a/tools/perf/measurements/v8_gc_times_unittest.py
+++ b/tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency_unittest.py
@@ -2,7 +2,6 @@
 # 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
@@ -10,10 +9,22 @@ 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 telemetry.web_perf.metrics import v8_gc_latency
+from telemetry.web_perf import timeline_interaction_record
 
+class V8EventStat(object):
 
-class V8GCTimesTestPageHelper(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
+
+class V8GCLatencyTestPageHelper(object):
 
   def __init__(self, page_set):
     self._page_set = page_set
@@ -21,6 +32,7 @@ class V8GCTimesTestPageHelper(object):
     self._renderer_process = self._model.GetOrCreateProcess(1)
     self._renderer_thread = self._renderer_process.GetOrCreateThread(2)
     self._renderer_thread.name = 'CrRendererMain'
+    self._interaction_records = []
 
   def AddEvent(self, category, name, thread_start, thread_duration,
                args=None, wall_start=None, wall_duration=None):
@@ -31,66 +43,70 @@ class V8GCTimesTestPageHelper(object):
     self._renderer_thread.EndSlice(wall_start + wall_duration,
                                    thread_start + thread_duration)
 
-  class MockV8GCTimesPage(page_module.Page):
+  def AddInteractionRecord(self, label, start, end):
+    self._interaction_records.append(
+      timeline_interaction_record.TimelineInteractionRecord(label, start, end))
+
+  class MockV8GCLatencyPage(page_module.Page):
 
     def __init__(self, page_set):
-      super(V8GCTimesTestPageHelper.MockV8GCTimesPage, self).__init__(
+      super(V8GCLatencyTestPageHelper.MockV8GCLatencyPage, self).__init__(
           'file://blank.html', page_set, page_set.base_dir)
 
   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)
+    page = V8GCLatencyTestPageHelper.MockV8GCLatencyPage(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()
-    # pylint: disable=protected-access
-    v8_gc_times_metric._renderer_process = self._renderer_process
+    metric = v8_gc_latency.V8GCLatency()
 
     # 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)
+    for interaction in self._interaction_records:
+      # Measure the V8GCLatency metric and return the results
+      # pylint: disable=protected-access
+      metric._AddV8MetricsToResults(self._model, [interaction], results)
     results.DidRunPage(page)
     return results
 
 
-class V8GCTimesTests(page_test_test_case.PageTestTestCase):
+class V8GCLatencyTests(page_test_test_case.PageTestTestCase):
 
   def setUp(self):
     self._options = options_for_unittests.GetCopy()
     self._options.browser_options.wpr_mode = wpr_modes.WPR_OFF
 
   def testWithNoTraceEvents(self):
-    test_page_helper = V8GCTimesTestPageHelper(
+    test_page_helper = V8GCLatencyTestPageHelper(
         self.CreateEmptyPageSet())
+    test_page_helper.AddInteractionRecord('Action', 0, 32)
 
     results = test_page_helper.MeasureFakePage()
     self._AssertResultsEqual(_GetEmptyResults(), _ActualValues(results))
 
   def testWithNoGarbageCollectionEvents(self):
-    test_page_helper = V8GCTimesTestPageHelper(
+    test_page_helper = V8GCLatencyTestPageHelper(
         self.CreateEmptyPageSet())
 
+    test_page_helper.AddInteractionRecord('Action', 0, 32)
     test_page_helper.AddEvent('toplevel', 'PostMessage',
         thread_start=0, thread_duration=14, wall_start=5, wall_duration=35)
 
     results = test_page_helper.MeasureFakePage()
     expected = _GetEmptyResults()
-    expected['duration'] = ('ms', 35)
-    expected['cpu_time'] = ('ms', 14)
 
     self._AssertResultsEqual(expected, _ActualValues(results))
 
   def testWithGarbageCollectionEvents(self):
-    test_page_helper = V8GCTimesTestPageHelper(
+    test_page_helper = V8GCLatencyTestPageHelper(
         self.CreateEmptyPageSet())
 
+    test_page_helper.AddInteractionRecord('Action', 0, 68)
     test_page_helper.AddEvent('toplevel', 'PostMessage',
         thread_start=0, thread_duration=57, wall_start=5, wall_duration=68)
     test_page_helper.AddEvent('v8', 'V8.GCScavenger', 5, 4)
@@ -102,8 +118,6 @@ class V8GCTimesTests(page_test_test_case.PageTestTestCase):
 
     results = test_page_helper.MeasureFakePage()
     expected = _GetEmptyResults()
-    expected['duration'] = ('ms', 68)
-    expected['cpu_time'] = ('ms', 57)
     expected['v8_gc_incremental_marking'] = ('ms', 6.0)
     expected['v8_gc_incremental_marking_average'] = ('ms', 3.0)
     expected['v8_gc_incremental_marking_count'] = ('count', 2)
@@ -125,9 +139,10 @@ class V8GCTimesTests(page_test_test_case.PageTestTestCase):
     self._AssertResultsEqual(expected, _ActualValues(results))
 
   def testWithIdleTaskGarbageCollectionEvents(self):
-    test_page_helper = V8GCTimesTestPageHelper(
+    test_page_helper = V8GCLatencyTestPageHelper(
         self.CreateEmptyPageSet())
 
+    test_page_helper.AddInteractionRecord('Action', 0, 68)
     test_page_helper.AddEvent('toplevel', 'PostMessage',
         thread_start=0, thread_duration=57, wall_start=5, wall_duration=68)
 
@@ -148,8 +163,6 @@ class V8GCTimesTests(page_test_test_case.PageTestTestCase):
 
     results = test_page_helper.MeasureFakePage()
     expected = _GetEmptyResults()
-    expected['duration'] = ('ms', 68)
-    expected['cpu_time'] = ('ms', 57)
     expected['v8_gc_incremental_marking'] = ('ms', 6.0)
     expected['v8_gc_incremental_marking_average'] = ('ms', 3.0)
     expected['v8_gc_incremental_marking_count'] = ('count', 2)
@@ -176,9 +189,10 @@ class V8GCTimesTests(page_test_test_case.PageTestTestCase):
     self._AssertResultsEqual(expected, _ActualValues(results))
 
   def testWithIdleTaskOverruns(self):
-    test_page_helper = V8GCTimesTestPageHelper(
+    test_page_helper = V8GCLatencyTestPageHelper(
         self.CreateEmptyPageSet())
 
+    test_page_helper.AddInteractionRecord('Action', 0, 92)
     test_page_helper.AddEvent('toplevel', 'PostMessage',
         thread_start=0, thread_duration=80, wall_start=5, wall_duration=92)
 
@@ -196,8 +210,6 @@ class V8GCTimesTests(page_test_test_case.PageTestTestCase):
 
     results = test_page_helper.MeasureFakePage()
     expected = _GetEmptyResults()
-    expected['duration'] = ('ms', 92)
-    expected['cpu_time'] = ('ms', 80)
     expected['v8_gc_incremental_marking'] = ('ms', 14.0)
     expected['v8_gc_incremental_marking_average'] = ('ms', 14.0)
     expected['v8_gc_incremental_marking_count'] = ('count', 1)
@@ -228,9 +240,10 @@ class V8GCTimesTests(page_test_test_case.PageTestTestCase):
     self._AssertResultsEqual(expected, _ActualValues(results))
 
   def testWithIdleTaskWallDurationOverruns(self):
-    test_page_helper = V8GCTimesTestPageHelper(
+    test_page_helper = V8GCLatencyTestPageHelper(
         self.CreateEmptyPageSet())
 
+    test_page_helper.AddInteractionRecord('Action', 0, 92)
     test_page_helper.AddEvent('toplevel', 'PostMessage',
         thread_start=0, thread_duration=80, wall_start=5, wall_duration=92)
 
@@ -241,8 +254,6 @@ class V8GCTimesTests(page_test_test_case.PageTestTestCase):
 
     results = test_page_helper.MeasureFakePage()
     expected = _GetEmptyResults()
-    expected['duration'] = ('ms', 92)
-    expected['cpu_time'] = ('ms', 80)
     expected['v8_gc_scavenger'] = ('ms', 4.0)
     expected['v8_gc_scavenger_average'] = ('ms', 4.0)
     expected['v8_gc_scavenger_count'] = ('count', 1)
@@ -262,6 +273,76 @@ class V8GCTimesTests(page_test_test_case.PageTestTestCase):
 
     self._AssertResultsEqual(expected, _ActualValues(results))
 
+  def testWithMultipleInteractionRecords(self):
+    test_page_helper = V8GCLatencyTestPageHelper(
+        self.CreateEmptyPageSet())
+
+    test_page_helper.AddInteractionRecord('Action1', 5, 18)
+    test_page_helper.AddInteractionRecord('Action2', 19, 57)
+    test_page_helper.AddInteractionRecord('Action3', 60, 68)
+    test_page_helper.AddEvent('toplevel', 'PostMessage',
+        thread_start=0, thread_duration=57, wall_start=5, wall_duration=68)
+
+    # This event is not in any interaction record.
+    test_page_helper.AddEvent('v8', 'V8.GCScavenger', 0, 1)
+
+    # These events are in Action1.
+    test_page_helper.AddEvent('v8', 'V8.GCScavenger', 5, 4)
+    test_page_helper.AddEvent('renderer.scheduler',
+        'SingleThreadIdleTaskRunner::RunTask', 15, 4, {'allotted_time_ms': 12})
+    test_page_helper.AddEvent('v8', 'V8.GCScavenger', 15, 3)
+
+    # These events are in Action2.
+    test_page_helper.AddEvent('v8', 'V8.GCIncrementalMarking', 23, 4)
+    test_page_helper.AddEvent('renderer.scheduler',
+        'SingleThreadIdleTaskRunner::RunTask', 34, 3, {'allotted_time_ms': 12})
+    test_page_helper.AddEvent('v8', 'V8.GCIncrementalMarking', 34, 2)
+    test_page_helper.AddEvent('v8', 'V8.GCCompactor', 42, 4)
+    test_page_helper.AddEvent('renderer.scheduler',
+        'SingleThreadIdleTaskRunner::RunTask', 52, 6, {'allotted_time_ms': 12})
+    test_page_helper.AddEvent('v8', 'V8.GCCompactor', 52, 5)
+
+    # This event is not in any interaction record.
+    test_page_helper.AddEvent('v8', 'V8.GCScavenger', 58, 1)
+
+    results = test_page_helper.MeasureFakePage()
+    expected = _GetEmptyResults()
+    expected['v8_gc_scavenger'] = ('ms', 7.0)
+    expected['v8_gc_scavenger_average'] = ('ms', 3.5)
+    expected['v8_gc_scavenger_count'] = ('count', 2)
+    expected['v8_gc_scavenger_max'] = ('ms', 4.0)
+    expected['v8_gc_scavenger_outside_idle'] = ('ms', 4.0)
+    expected['v8_gc_scavenger_percentage_idle'] = ('idle%', 100 * 3 / 7.0)
+    expected['v8_gc_total'] = ('ms', 7.0)
+    expected['v8_gc_total_outside_idle'] = ('ms', 4.0)
+    expected['v8_gc_total_percentage_idle'] = ('idle%', 100 * 3.0 / 7.0)
+
+    self._AssertResultsEqual(expected, _ActualValues(results, 'Action1'))
+
+    expected = _GetEmptyResults()
+    expected['v8_gc_incremental_marking'] = ('ms', 6.0)
+    expected['v8_gc_incremental_marking_average'] = ('ms', 3.0)
+    expected['v8_gc_incremental_marking_count'] = ('count', 2)
+    expected['v8_gc_incremental_marking_max'] = ('ms', 4.0)
+    expected['v8_gc_incremental_marking_outside_idle'] = ('ms', 4.0)
+    expected['v8_gc_incremental_marking_percentage_idle'] = \
+        ('idle%', 100 * 2 / 6.0)
+    expected['v8_gc_mark_compactor'] = ('ms', 9.0)
+    expected['v8_gc_mark_compactor_average'] = ('ms', 4.5)
+    expected['v8_gc_mark_compactor_count'] = ('count', 2)
+    expected['v8_gc_mark_compactor_max'] = ('ms', 5.0)
+    expected['v8_gc_mark_compactor_outside_idle'] = ('ms', 4.0)
+    expected['v8_gc_mark_compactor_percentage_idle'] = ('idle%', 100 * 5 / 9.0)
+    expected['v8_gc_total'] = ('ms', 15.0)
+    expected['v8_gc_total_outside_idle'] = ('ms', 8.0)
+    expected['v8_gc_total_percentage_idle'] = ('idle%', 100 * 7.0 / 15.0)
+
+    self._AssertResultsEqual(expected, _ActualValues(results, 'Action2'))
+
+    expected = _GetEmptyResults()
+    self._AssertResultsEqual(expected, _ActualValues(results, 'Action3'))
+
+
   def _AssertResultsEqual(self, expected, actual):
     for key in expected.iterkeys():
       self.assertIn(key, actual.keys())
@@ -269,22 +350,17 @@ class V8GCTimesTests(page_test_test_case.PageTestTestCase):
           '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):
+def _ActualValues(results, interaction_record=''):
   return dict(list(
       (v.name, (v.units, v.value))
       for v in results.all_page_specific_values
+      if (interaction_record == '' or v.tir_label == interaction_record)
       ))
 
 
 def _GetEmptyResults():
-  return {'cpu_time': ('ms', 0.0),
-          'duration': ('ms', 0.0),
-          'v8_gc_incremental_marking': ('ms', 0.0),
+  return {'v8_gc_incremental_marking': ('ms', 0.0),
           'v8_gc_incremental_marking_average': ('ms', 0.0),
           'v8_gc_incremental_marking_count': ('count', 0),
           'v8_gc_incremental_marking_max': ('ms', 0.0),