Addition of first_gesture_scroll_latency

tools/telemetry/telemetry/web_perf/metrics/rendering_stats_unittest.py

Index: tools/telemetry/telemetry/web_perf/metrics/rendering_stats_unittest.py
diff --git a/tools/telemetry/telemetry/web_perf/metrics/rendering_stats_unittest.py b/tools/telemetry/telemetry/web_perf/metrics/rendering_stats_unittest.py
index 8abffc2930b55ff725e2a3cb075a19ba4bca4a2f..c0ba3fb3d20df0327b25331f7f767106eb76575e 100644
--- a/tools/telemetry/telemetry/web_perf/metrics/rendering_stats_unittest.py
+++ b/tools/telemetry/telemetry/web_perf/metrics/rendering_stats_unittest.py
@@ -6,17 +6,28 @@ import random
 import unittest
 
 from telemetry.web_perf.metrics.rendering_stats import (
-    UI_COMP_NAME, BEGIN_COMP_NAME, ORIGINAL_COMP_NAME, END_COMP_NAME)
-from telemetry.web_perf.metrics.rendering_stats import ComputeInputEventLatency
-from telemetry.web_perf.metrics.rendering_stats import GetInputLatencyEvents
-from telemetry.web_perf.metrics.rendering_stats import HasRenderingStats
-from telemetry.web_perf.metrics.rendering_stats import NotEnoughFramesError
-from telemetry.web_perf.metrics.rendering_stats import RenderingStats
+    UI_COMP_NAME,
+    BEGIN_COMP_NAME,
+    ORIGINAL_COMP_NAME,
+    END_COMP_NAME,
+    GESTURE_SCROLL_UPDATE,
+    ALL_INPUT_EVENTS)
+
+from telemetry.web_perf.metrics.rendering_stats import (
+    ComputeInputEventLatency,
+    GetInputLatencyEvents,
+    HasRenderingStats,
+    NotEnoughFramesError,
+    RenderingStats,
+    GetInputEventStartAndLatency)
+
 from telemetry.util.statistics import DivideIfPossibleOrZero
 import telemetry.timeline.bounds as timeline_bounds
 from telemetry.timeline import model
 import telemetry.timeline.async_slice as tracing_async_slice
+from collections import namedtuple
 
+InputEventDetails = namedtuple('InputEventDetails','start_time latency')
 
 class MockTimer(object):
   """A mock timer class which can generate random durations.
@@ -196,6 +207,15 @@ def AddInputLatencyStats(mock_timer, start_thread, end_thread,
       (data[END_COMP_NAME]['time'] - data[ORIGINAL_COMP_NAME]['time']) / 1000.0)
 
 
+def assertListsAreAlmostEqual(self, list1, list2):
+  """Compare items in two lists to default (7 decimal places) precision
+      to avoid rounding errors generating false positives.
+  """
+  self.assertEquals(len(list1), len(list2))
+  for item1, item2 in zip(list1, list2):
+    self.assertAlmostEqual(item1, item2)
+
+
 class RenderingStatsUnitTest(unittest.TestCase):
   def testHasRenderingStats(self):
     timeline = model.TimelineModel()
@@ -364,6 +384,7 @@ class RenderingStatsUnitTest(unittest.TestCase):
     self.assertEquals(stats.recorded_pixel_counts,
                       renderer_ref_stats.recorded_pixel_counts)
 
+
   def testInputLatencyFromTimeline(self):
     timeline = model.TimelineModel()
 
@@ -419,5 +440,51 @@ class RenderingStatsUnitTest(unittest.TestCase):
       input_events.extend(GetInputLatencyEvents(browser, timeline_range))
 
     self.assertEquals(input_events, ref_latency.input_event)
-    self.assertEquals(ComputeInputEventLatency(input_events),
-                      ref_latency.input_event_latency)
+
+    assertListsAreAlmostEqual(self,
+                              ComputeInputEventLatency(input_events),
+                              ref_latency.input_event_latency)
+
+  def testGetInputEventStartAndLatency(self):
+    data_1 = { ORIGINAL_COMP_NAME: {'time': 1000.0},
+            UI_COMP_NAME: {'time': 1000.0},
+            BEGIN_COMP_NAME: {'time': 1000.0},
+            END_COMP_NAME: {'time': 5000.0} }
+
+    data_2 = { ORIGINAL_COMP_NAME: {'time': 2000.0},
+              UI_COMP_NAME: {'time': 2000.0},
+              BEGIN_COMP_NAME: {'time': 2000.0},
+              END_COMP_NAME: {'time': 8000.0} }
+
+    timestamp = MockTimer().Get()
+
+    async_slice_GSU = tracing_async_slice.AsyncSlice(
+          'benchmark', 'InputLatency', timestamp)
+
+    async_slice = tracing_async_slice.AsyncSlice(
+          'benchmark', 'InputLatency', timestamp)
+
+    async_slice_GSU.args = {'data': data_1, 'step':GESTURE_SCROLL_UPDATE}
+    async_slice.args = {'data': data_2, 'step':'GeneralInput'}
+
+    input_events = []
+
+    input_events.append(async_slice_GSU)
+    input_events.append(async_slice)
+
+    filtered_GSU_events = GetInputEventStartAndLatency(input_events,
+                                                       GESTURE_SCROLL_UPDATE)
+    self.assertEquals([InputEventDetails(1.0, 4.0)], filtered_GSU_events)
+
+    filtered_Non_GSU_events = GetInputEventStartAndLatency(input_events,
+                                                           'GeneralInput')
+    self.assertEquals([InputEventDetails(2.0, 6.0)], filtered_Non_GSU_events)
+
+    all_events = GetInputEventStartAndLatency(input_events, ALL_INPUT_EVENTS)
+    self.assertEquals([InputEventDetails(1.0, 4.0),
+                       InputEventDetails(2.0, 6.0)], all_events)
+
+    no_events = GetInputEventStartAndLatency(input_events, "Nothing to match")
+    self.assertEquals([], no_events)
+
+