Add responsiveness_metric for timeline_based_measurement

tools/telemetry/telemetry/web_perf/timeline_based_measurement_unittest.py

Index: tools/telemetry/telemetry/web_perf/timeline_based_measurement_unittest.py
diff --git a/tools/telemetry/telemetry/web_perf/timeline_based_measurement_unittest.py b/tools/telemetry/telemetry/web_perf/timeline_based_measurement_unittest.py
index c4eeae9e8f73a5a4ec7b961becb4f119638ac8cd..4c0267e91b5bd0ab082f4a624bb5ebb0493f47e4 100644
--- a/tools/telemetry/telemetry/web_perf/timeline_based_measurement_unittest.py
+++ b/tools/telemetry/telemetry/web_perf/timeline_based_measurement_unittest.py
@@ -12,11 +12,16 @@ from telemetry.core.timeline import async_slice
 from telemetry.page import page_measurement_results
 from telemetry.page import page_measurement_unittest_base
 from telemetry.page import page_set
+from telemetry.page import page as page_module
+# pylint: disable=W0401,W0614
+from telemetry.page.actions.all_page_actions import *
 from telemetry.unittest import options_for_unittests
 from telemetry.web_perf import timeline_based_measurement as tbm_module
 from telemetry.web_perf.metrics import timeline_based_metric
 
+
 class TimelineBasedMetricsTests(unittest.TestCase):
+
   def setUp(self):
     model = model_module.TimelineModel()
     renderer_thread = model.GetOrCreateProcess(1).GetOrCreateThread(2)
@@ -33,7 +38,7 @@ class TimelineBasedMetricsTests(unittest.TestCase):
         start_thread=renderer_thread, end_thread=renderer_thread,
         thread_start=5, thread_duration=15))
     renderer_thread.async_slices.append(async_slice.AsyncSlice(
-        'cat', 'Interaction.LogicalName2/is_loading_resources',
+        'cat', 'Interaction.LogicalName2/is_responsive',
         timestamp=25, duration=5,
         start_thread=renderer_thread, end_thread=renderer_thread,
         thread_start=25, thread_duration=5))
@@ -43,26 +48,29 @@ class TimelineBasedMetricsTests(unittest.TestCase):
     self.renderer_thread = renderer_thread
 
   def testFindTimelineInteractionRecords(self):
-    metric = tbm_module._TimelineBasedMetrics( # pylint: disable=W0212
-      self.model, self.renderer_thread, lambda _: [] )
+    metric = tbm_module._TimelineBasedMetrics(  # pylint: disable=W0212
+      self.model, self.renderer_thread, lambda _: [])
     interactions = metric.FindTimelineInteractionRecords()
     self.assertEquals(2, len(interactions))
     self.assertTrue(interactions[0].is_smooth)
     self.assertEquals(0, interactions[0].start)
     self.assertEquals(20, interactions[0].end)
 
-    self.assertTrue(interactions[1].is_loading_resources)
+    self.assertTrue(interactions[1].is_responsive)
     self.assertEquals(25, interactions[1].start)
     self.assertEquals(30, interactions[1].end)
 
   def testAddResults(self):
     results = page_measurement_results.PageMeasurementResults()
+
     class FakeSmoothMetric(timeline_based_metric.TimelineBasedMetric):
+
       def AddResults(self, model, renderer_thread,
                      interaction_records, results):
         results.Add('FakeSmoothMetric', 'ms', 1)
 
     class FakeLoadingMetric(timeline_based_metric.TimelineBasedMetric):
+
       def AddResults(self, model, renderer_thread,
                      interaction_records, results):
         for r in interaction_records:
@@ -73,11 +81,11 @@ class TimelineBasedMetricsTests(unittest.TestCase):
       res = []
       if interaction.is_smooth:
         res.append(FakeSmoothMetric())
-      if interaction.is_loading_resources:
+      if interaction.is_responsive:
         res.append(FakeLoadingMetric())
       return res
 
-    metric = tbm_module._TimelineBasedMetrics( # pylint: disable=W0212
+    metric = tbm_module._TimelineBasedMetrics(  # pylint: disable=W0212
         self.model, self.renderer_thread,
         CreateMetricsForTimelineInteractionRecord)
     ps = page_set.PageSet(file_path=os.path.dirname(__file__))
@@ -93,19 +101,33 @@ class TimelineBasedMetricsTests(unittest.TestCase):
     self.assertEquals(len(v), 1)
 
 
+class TestTimelinebasedMeasurementPage(page_module.Page):
+
+  def __init__(self, ps, base_dir):
+    super(TestTimelinebasedMeasurementPage, self).__init__(
+        'file://interaction_enabled_page.html', ps, base_dir)
+
+  def RunSmoothness(self, action_runner):
+    action_runner.RunAction(WaitAction({'seconds': 2}))
+    action_runner.RunAction(TapAction(
+        {'selector': '#drawer', 'automatically_record_interaction': False}))
+    action_runner.RunAction(WaitAction({'seconds': 1}))
+
+
 class TimelineBasedMeasurementTest(
-      page_measurement_unittest_base.PageMeasurementUnitTestBase):
+    page_measurement_unittest_base.PageMeasurementUnitTestBase):
+
   def setUp(self):
     self._options = options_for_unittests.GetCopy()
     self._options.browser_options.wpr_mode = wpr_modes.WPR_OFF
 
   # Disabled due to flakiness: crbug.com/368386
   @test.Disabled
-  def testTimelineBasedForSmoke(self):
+  def testSmoothnessTimelineBasedMeasurementForSmoke(self):
     ps = self.CreatePageSetFromFileInUnittestDataDir(
         'interaction_enabled_page.html')
-    setattr(ps.pages[0], 'RunSmoothness', {'action': 'wait',
-                                        'javascript': 'window.animationDone'})
+    setattr(ps.pages[0], 'RunSmoothness', {
+        'action': 'wait', 'javascript': 'window.animationDone'})
     measurement = tbm_module.TimelineBasedMeasurement()
     results = self.RunMeasurement(measurement, ps,
                                   options=self._options)
@@ -115,3 +137,19 @@ class TimelineBasedMeasurementTest(
     v = results.FindAllPageSpecificValuesNamed('DrawerAnimation-jank')
     self.assertEquals(len(v), 1)
 
+  def testMainthreadJankTimelineBasedMeasurement(self):
+    ps = self.CreateEmptyPageSet()
+    ps.AddPage(TestTimelinebasedMeasurementPage(ps, ps.base_dir))
+
+    measurement = tbm_module.TimelineBasedMeasurement()
+    results = self.RunMeasurement(measurement, ps,
+                                  options=self._options)
+    self.assertEquals(0, len(results.failures))
+    v = results.FindAllPageSpecificValuesNamed(
+        'JankThreadJSRun-num_big_mainthread_janks')
+    self.assertEquals(len(v), 1)
+    self.assertEquals(v[0].value, 1)
+
+    v = results.FindAllPageSpecificValuesNamed(
+        'JankThreadJSRun-biggest_jank_thread_time')
+    self.assertGreaterEqual(v[0].value, 50)