Add first_gesture_scroll_update_latency metric

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

 # Copyright 2014 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.
 
 import random
 import unittest
 
 import telemetry.timeline.async_slice as tracing_async_slice
 import telemetry.timeline.bounds as timeline_bounds
 from telemetry.timeline import model
 from telemetry.util.statistics import DivideIfPossibleOrZero
 from telemetry.web_perf.metrics.rendering_stats import (
-    UI_COMP_NAME, BEGIN_COMP_NAME, ORIGINAL_COMP_NAME,
-    BEGIN_SCROLL_UPDATE_COMP_NAME, FORWARD_SCROLL_UPDATE_COMP_NAME,
-    END_COMP_NAME)
+    BEGIN_COMP_NAME,
+    BEGIN_SCROLL_UPDATE_COMP_NAME,
+    END_COMP_NAME,
+    FORWARD_SCROLL_UPDATE_COMP_NAME,
+    GESTURE_SCROLL_UPDATE_EVENT_NAME,
+    ORIGINAL_COMP_NAME,
+    SCROLL_UPDATE_EVENT_NAME,
+    UI_COMP_NAME)
 from telemetry.web_perf.metrics.rendering_stats import (
     ComputeInputEventLatencies)
 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
 
 
 class MockTimer(object):
   """A mock timer class which can generate random durations.
@@ skipping 36 matching lines @@
     self.recorded_pixel_counts.append([])
     self.rasterize_times.append([])
     self.rasterized_pixel_counts.append([])
     self.approximated_pixel_percentages.append([])
 
 class ReferenceInputLatencyStats(object):
   """ Stores expected data for comparison with actual input latency stats """
   def __init__(self):
     self.input_event_latency = []
     self.input_event = []
-    self.scroll_update_latency = []
 
 def AddMainThreadRenderingStats(mock_timer, thread, first_frame,
                                 ref_stats = None):
   """ Adds a random main thread rendering stats event.
 
   thread: The timeline model thread to which the event will be added.
   first_frame: Is this the first frame within the bounds of an action?
   ref_stats: A ReferenceRenderingStats object to record expected values.
   """
   # Create randonm data and timestap for main thread rendering stats.
@@ skipping 93 matching lines @@
            UI_COMP_NAME: {'time': ui_comp_time},
            BEGIN_COMP_NAME: {'time': begin_comp_time},
            END_COMP_NAME: {'time': end_comp_time} }
 
   timestamp = mock_timer.Get()
 
   async_slice = tracing_async_slice.AsyncSlice(
       'benchmark', 'InputLatency', timestamp)
 
   async_sub_slice = tracing_async_slice.AsyncSlice(
-      'benchmark', 'InputLatency', timestamp)
+      'benchmark', GESTURE_SCROLL_UPDATE_EVENT_NAME, timestamp)
   async_sub_slice.args = {'data': data}
   async_sub_slice.parent_slice = async_slice
   async_sub_slice.start_thread = start_thread
   async_sub_slice.end_thread = end_thread
 
   async_slice.sub_slices.append(async_sub_slice)
   async_slice.start_thread = start_thread
   async_slice.end_thread = end_thread
   start_thread.AddAsyncSlice(async_slice)
 
   # Add scroll update latency info.
   scroll_update_data = {
       BEGIN_SCROLL_UPDATE_COMP_NAME: {'time': begin_comp_time},
       FORWARD_SCROLL_UPDATE_COMP_NAME: {'time': forward_comp_time},
       END_COMP_NAME: {'time': end_comp_time} }
 
   scroll_async_slice = tracing_async_slice.AsyncSlice(
       'benchmark', 'InputLatency', timestamp)
 
   scroll_async_sub_slice = tracing_async_slice.AsyncSlice(
-      'benchmark', 'InputLatency', timestamp)
+      'benchmark', SCROLL_UPDATE_EVENT_NAME, timestamp)
   scroll_async_sub_slice.args = {'data': scroll_update_data}
   scroll_async_sub_slice.parent_slice = scroll_async_slice
   scroll_async_sub_slice.start_thread = start_thread
   scroll_async_sub_slice.end_thread = end_thread
 
   scroll_async_slice.sub_slices.append(scroll_async_sub_slice)
   scroll_async_slice.start_thread = start_thread
   scroll_async_slice.end_thread = end_thread
   start_thread.AddAsyncSlice(scroll_async_slice)
 
   if not ref_latency_stats:
     return
 
   ref_latency_stats.input_event.append(async_sub_slice)
   ref_latency_stats.input_event.append(scroll_async_sub_slice)
-  ref_latency_stats.input_event_latency.append(
-      (data[END_COMP_NAME]['time'] - data[ORIGINAL_COMP_NAME]['time']) / 1000.0)
-  ref_latency_stats.scroll_update_latency.append(
+  ref_latency_stats.input_event_latency.append((
+      GESTURE_SCROLL_UPDATE_EVENT_NAME,
+      (data[END_COMP_NAME]['time'] -
+       data[ORIGINAL_COMP_NAME]['time']) / 1000.0))
+  ref_latency_stats.input_event_latency.append((
+      SCROLL_UPDATE_EVENT_NAME,
       (scroll_update_data[END_COMP_NAME]['time'] -
-       scroll_update_data[BEGIN_SCROLL_UPDATE_COMP_NAME]['time']) / 1000.0)
+       scroll_update_data[BEGIN_SCROLL_UPDATE_COMP_NAME]['time']) / 1000.0))
 
 
 class RenderingStatsUnitTest(unittest.TestCase):
   def testHasRenderingStats(self):
     timeline = model.TimelineModel()
     timer = MockTimer()
 
     # A process without rendering stats
     process_without_stats = timeline.GetOrCreateProcess(pid = 1)
     thread_without_stats = process_without_stats.GetOrCreateThread(tid = 11)
@@ skipping 205 matching lines @@
 
     timeline_markers = timeline.FindTimelineMarkers(
         ['ActionA', 'ActionB', 'ActionA'])
     for timeline_range in [ timeline_bounds.Bounds.CreateFromEvent(marker)
                             for marker in timeline_markers ]:
       if timeline_range.is_empty:
         continue
       input_events.extend(GetInputLatencyEvents(browser, timeline_range))
 
     self.assertEquals(input_events, ref_latency.input_event)
-    input_event_latency_result, scroll_update_latency_result = (
-        ComputeInputEventLatencies(input_events))
+    input_event_latency_result = ComputeInputEventLatencies(input_events)
     self.assertEquals(input_event_latency_result,
                       ref_latency.input_event_latency)
-    self.assertEquals(scroll_update_latency_result,
-                      ref_latency.scroll_update_latency)