Add latency metric mean_js_touch_scroll_latency for JS touch handler driven scroll

tools/perf/metrics/rendering_stats_unittest.py

 # Copyright 2013 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
 
 from metrics.rendering_stats import UI_COMP_NAME, BEGIN_COMP_NAME, END_COMP_NAME
 from metrics.rendering_stats import GetScrollInputLatencyEvents
 from metrics.rendering_stats import ComputeMouseWheelScrollLatency
@@ skipping 43 matching lines @@
     self.record_times.append([])
     self.recorded_pixel_counts.append([])
     self.rasterize_times.append([])
     self.rasterized_pixel_counts.append([])
 
 class ReferenceInputLatencyStats(object):
   """ Stores expected data for comparison with actual input latency stats """
   def __init__(self):
     self.mouse_wheel_scroll_latency = []
     self.touch_scroll_latency = []
+    self.js_touch_scroll_latency = []
     self.mouse_wheel_scroll_events = []
     self.touch_scroll_events = []
+    self.js_touch_scroll_events = []
 
 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 103 matching lines @@
   start_thread.AddAsyncSlice(async_slice)
 
   if not ref_latency_stats:
     return
 
   if input_type == 'MouseWheel':
     ref_latency_stats.mouse_wheel_scroll_events.append(async_sub_slice)
     ref_latency_stats.mouse_wheel_scroll_latency.append(
         (data[END_COMP_NAME]['time'] - data[BEGIN_COMP_NAME]['time']) / 1000.0)
 
-
   if input_type == 'GestureScrollUpdate':
     ref_latency_stats.touch_scroll_events.append(async_sub_slice)
     ref_latency_stats.touch_scroll_latency.append(
         (data[END_COMP_NAME]['time'] - data[UI_COMP_NAME]['time']) / 1000.0)
 
+  if input_type == 'TouchMove':
+    ref_latency_stats.js_touch_scroll_events.append(async_sub_slice)
+    ref_latency_stats.js_touch_scroll_latency.append(
+        (data[END_COMP_NAME]['time'] - data[UI_COMP_NAME]['time']) / 1000.0)
+
 class RenderingStatsUnitTest(unittest.TestCase):
   def testFromTimeline(self):
     timeline = model.TimelineModel()
 
     # Create a browser process and a renderer process, and a main thread and
     # impl thread for each.
     browser = timeline.GetOrCreateProcess(pid = 1)
     browser_main = browser.GetOrCreateThread(tid = 11)
     browser_compositor = browser.GetOrCreateThread(tid = 12)
     renderer = timeline.GetOrCreateProcess(pid = 2)
@@ skipping 82 matching lines @@
     ref_latency_stats = ReferenceInputLatencyStats()
 
     # Create 10 input latency stats events for Action A.
     timer.Advance()
     renderer_main.BeginSlice('webkit.console', 'ActionA', timer.Get(), '')
     for _ in xrange(0, 10):
       AddInputLatencyStats(timer, 'MouseWheel', browser_main,
                            renderer_main, ref_latency_stats)
       AddInputLatencyStats(timer, 'GestureScrollUpdate', browser_main,
                            renderer_main, ref_latency_stats)
+      AddInputLatencyStats(timer, 'TouchMove', browser_main,
+                           renderer_main, ref_latency_stats)
     renderer_main.EndSlice(timer.Get())
 
     # Create 5 input latency stats events not within any action.
     for _ in xrange(0, 5):
       AddInputLatencyStats(timer, 'MouseWheel', browser_main,
                            renderer_main, None)
       AddInputLatencyStats(timer, 'GestureScrollUpdate', browser_main,
                            renderer_main, None)
+      AddInputLatencyStats(timer, 'TouchMove', browser_main,
+                           renderer_main, None)
 
     # Create 10 input latency stats events for Action B.
     timer.Advance()
     renderer_main.BeginSlice('webkit.console', 'ActionB', timer.Get(), '')
     for _ in xrange(0, 10):
       AddInputLatencyStats(timer, 'MouseWheel', browser_main,
                            renderer_main, ref_latency_stats)
       AddInputLatencyStats(timer, 'GestureScrollUpdate', browser_main,
                            renderer_main, ref_latency_stats)
+      AddInputLatencyStats(timer, 'TouchMove', browser_main,
+                           renderer_main, ref_latency_stats)
     renderer_main.EndSlice(timer.Get())
 
     # Create 10 input latency stats events for Action A.
     timer.Advance()
     renderer_main.BeginSlice('webkit.console', 'ActionA', timer.Get(), '')
     for _ in xrange(0, 10):
       AddInputLatencyStats(timer, 'MouseWheel', browser_main,
                                   renderer_main, ref_latency_stats)
       AddInputLatencyStats(timer, 'GestureScrollUpdate', browser_main,
                                   renderer_main, ref_latency_stats)
+      AddInputLatencyStats(timer, 'TouchMove', browser_main,
+                                  renderer_main, ref_latency_stats)
     renderer_main.EndSlice(timer.Get())
 
     browser_main.FinalizeImport()
     renderer_main.FinalizeImport()
 
     mouse_wheel_scroll_events = []
     touch_scroll_events = []
+    js_touch_scroll_events = []
 
     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
-      tmp_mouse_events, tmp_touch_events = GetScrollInputLatencyEvents(
-          browser, timeline_range)
+      tmp_mouse_events = GetScrollInputLatencyEvents(
+          'MouseWheel', browser, timeline_range)
+      tmp_touch_scroll_events = GetScrollInputLatencyEvents(
+          'GestureScrollUpdate', browser, timeline_range)
+      tmp_js_touch_scroll_events = GetScrollInputLatencyEvents(
+          'TouchMove', browser, timeline_range)
       mouse_wheel_scroll_events.extend(tmp_mouse_events)
-      touch_scroll_events.extend(tmp_touch_events)
+      touch_scroll_events.extend(tmp_touch_scroll_events)
+      js_touch_scroll_events.extend(tmp_js_touch_scroll_events)
 
     self.assertEquals(mouse_wheel_scroll_events,
                       ref_latency_stats.mouse_wheel_scroll_events)
     self.assertEquals(touch_scroll_events,
                       ref_latency_stats.touch_scroll_events)
+    self.assertEquals(js_touch_scroll_events,
+                      ref_latency_stats.js_touch_scroll_events)
     self.assertEquals(ComputeMouseWheelScrollLatency(mouse_wheel_scroll_events),
                       ref_latency_stats.mouse_wheel_scroll_latency)
     self.assertEquals(ComputeTouchScrollLatency(touch_scroll_events),
                       ref_latency_stats.touch_scroll_latency)
+    self.assertEquals(ComputeTouchScrollLatency(js_touch_scroll_events),
+                      ref_latency_stats.js_touch_scroll_latency)