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 5051f47485c7aa762cec9d13b4a3d14c5b0ed56e..99444fbd0f1e99da566fd17e290e842a9380d3bf 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)
@@ -43,8 +48,8 @@ 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)
@@ -57,12 +62,15 @@ class TimelineBasedMetricsTests(unittest.TestCase):
 
   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:
@@ -77,7 +85,7 @@ class TimelineBasedMetricsTests(unittest.TestCase):
         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,28 @@ class TimelineBasedMeasurementTest(
     v = results.FindAllPageSpecificValuesNamed('DrawerAnimation-jank')
     self.assertEquals(len(v), 1)
 
+  # Disabled since mainthread_jank metric is not supported on windows platform.
+  @test.Disabled('win')
+  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))
+
+    # In interaction_enabled_page.html, we create a jank loop based on
+    # window.performance.now() (basically loop for x milliseconds).
+    # Since window.performance.now() uses wall-time
+    # instead of thread time, we set time to looping to 100ms in
+    # interaction_enabled_page.html and only assert the biggest jank > 50ms here
+    # to  account for the fact that the browser may deschedule during the jank
+    # loop.
+    v = results.FindAllPageSpecificValuesNamed(
+        'JankThreadJSRun-responsive-biggest_jank_thread_time')
+    self.assertGreaterEqual(v[0].value, 50)
+
+    v = results.FindAllPageSpecificValuesNamed(
+        'JankThreadJSRun-responsive-total_big_jank_thread_time')
+    self.assertGreaterEqual(v[0].value, 50)