Collecting LatencyInfo in telemetry

tools/perf/metrics/smoothness.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.
 
 from metrics import Metric
 from metrics import rendering_stats
 from metrics import statistics
 from telemetry.page import page_measurement
 
 TIMELINE_MARKER = 'Smoothness'
@@ skipping 32 matching lines @@
       tab.browser.platform.StartRawDisplayFrameRateMeasurement()
 
   def Stop(self, page, tab):
     if tab.browser.platform.IsRawDisplayFrameRateSupported():
       tab.browser.platform.StopRawDisplayFrameRateMeasurement()
     tab.ExecuteJavaScript('console.timeEnd("' + TIMELINE_MARKER + '")')
     timeline_model = tab.browser.StopTracing().AsTimelineModel()
     timeline_ranges = [ action.GetActiveRangeOnTimeline(timeline_model)
                         for action in self._actions ]
 
+    browser_process = timeline_model.GetProcess(tab.browser.browser_pid)
     renderer_process = timeline_model.GetRendererProcessFromTab(tab)
     self._stats = rendering_stats.RenderingStats(
-        renderer_process, timeline_ranges)
+        renderer_process, browser_process, timeline_ranges)
 
     if not self._stats.frame_times:
       raise NotEnoughFramesError()
 
   def SetStats(self, stats):
     """ Pass in a RenderingStats object directly. For unittests that don't call
         Start/Stop.
     """
     self._stats = stats
 
   def AddResults(self, tab, results):

[nduca, 2014/01/13 18:49:32]

needs unit tests

[Yufeng Shen (Slow to review), 2014/01/14 00:05:47]

I assume the unittests for this is a test that starts a simple scrolable webpage
and run the smoothness measurement on it and check that the desired metrics show
in the result.

Currently the chrome side LatencyInfo plumbing has not totally gone
through yet (I am close in landing this CL
https://codereview.chromium.org/123563002/) so don't have a chrome
build that can return the desired input latency metric.

Either I hold off on this CL until 123563002 is landed or I merge this one first
and add the unittests later.

[Yufeng Shen (Slow to review), 2014/01/20 21:59:30]

Test added.

+    if self._stats.mouse_wheel_latency:
+      mean_mouse_wheel_latency = statistics.ArithmeticMean(
+          self._stats.mouse_wheel_latency, len(self._stats.mouse_wheel_latency))
+      results.Add('mean_mouse_wheel_latency', 'ms',
+                  round(mean_mouse_wheel_latency, 3))
+      results.Add('mouse_wheel_latency_75%', 'ms',
+                  statistics.Percentile(self._stats.mouse_wheel_latency, 75.0) )
+
+    if self._stats.gesture_scroll_latency:
+      mean_gesture_scroll_latency = statistics.ArithmeticMean(
+          self._stats.gesture_scroll_latency,
+          len(self._stats.gesture_scroll_latency))
+      results.Add('mean_gesture_scroll_latency', 'ms',
+                  round(mean_gesture_scroll_latency, 3))
+      results.Add('gesture_scroll_latency_75%', 'ms',
+                  statistics.Percentile(self._stats.gesture_scroll_latency,
+                                        75.0) )
+
+    if self._stats.touch_scroll_latency:
+      mean_touch_scroll_latency = statistics.ArithmeticMean(
+          self._stats.touch_scroll_latency,
+          len(self._stats.touch_scroll_latency))
+      results.Add('mean_touch_scroll_latency', 'ms',
+                  round(mean_touch_scroll_latency, 3))
+      results.Add('touch_scroll_latency_75%', 'ms',
+                  statistics.Percentile(self._stats.touch_scroll_latency,
+                                        75.0) )
     # List of raw frame times.
     results.Add('frame_times', 'ms', self._stats.frame_times)
 
     # Arithmetic mean of frame times.
     mean_frame_time = statistics.ArithmeticMean(self._stats.frame_times,
                                                 len(self._stats.frame_times))
     results.Add('mean_frame_time', 'ms', round(mean_frame_time, 3))
 
     # Absolute discrepancy of frame time stamps.
     jank = statistics.FrameDiscrepancy(self._stats.frame_timestamps)
     results.Add('jank', '', round(jank, 4))
 
     # Are we hitting 60 fps for 95 percent of all frames?
     # We use 19ms as a somewhat looser threshold, instead of 1000.0/60.0.
     percentile_95 = statistics.Percentile(self._stats.frame_times, 95.0)
     results.Add('mostly_smooth', '', 1.0 if percentile_95 < 19.0 else 0.0)
 
     if tab.browser.platform.IsRawDisplayFrameRateSupported():
       for r in tab.browser.platform.GetRawDisplayFrameRateMeasurements():
         if r.value is None:
           raise MissingDisplayFrameRateError(r.name)
         results.Add(r.name, r.unit, r.value)