re-land: Use browser compositor rendering stats in smoothness

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
 from metrics.rendering_stats import ComputeTouchScrollLatency
+from metrics.rendering_stats import HasRenderingStats
 from metrics.rendering_stats import RenderingStats
 import telemetry.core.timeline.bounds as timeline_bounds
 from telemetry.core.timeline import model
 import telemetry.core.timeline.async_slice as tracing_async_slice
 
 
 class MockTimer(object):
   """A mock timer class which can generate random durations.
 
   An instance of this class is used as a global timer to generate random
@@ skipping 170 matching lines @@
     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 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)
+    process_without_stats.FinalizeImport()
+    self.assertFalse(HasRenderingStats(thread_without_stats))
+
+    # A process with rendering stats, but no frames in them
+    process_without_frames = timeline.GetOrCreateProcess(pid = 2)
+    thread_without_frames = process_without_frames.GetOrCreateThread(tid = 21)
+    AddMainThreadRenderingStats(timer, thread_without_frames, True, None)
+    process_without_frames.FinalizeImport()
+    self.assertFalse(HasRenderingStats(thread_without_frames))
+
+    # A process with rendering stats and frames in them
+    process_with_frames = timeline.GetOrCreateProcess(pid = 3)
+    thread_with_frames = process_with_frames.GetOrCreateThread(tid = 31)
+    AddImplThreadRenderingStats(timer, thread_with_frames, True, None)
+    process_with_frames.FinalizeImport()
+    self.assertTrue(HasRenderingStats(thread_with_frames))
+
   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)
     renderer_main = renderer.GetOrCreateThread(tid = 21)
     renderer_compositor = renderer.GetOrCreateThread(tid = 22)
 
     timer = MockTimer()
     ref_stats = ReferenceRenderingStats()
 
     # Create 10 main and impl rendering stats events for Action A.
     timer.Advance()
     renderer_main.BeginSlice('webkit.console', 'ActionA', timer.Get(), '')
     ref_stats.AppendNewRange()
     for i in xrange(0, 10):
       first = (i == 0)
-      AddMainThreadRenderingStats(timer, renderer_main, first, ref_stats)
-      AddImplThreadRenderingStats(timer, renderer_compositor, first, ref_stats)
-      AddMainThreadRenderingStats(timer, browser_main, first, None)
-      AddImplThreadRenderingStats(timer, browser_compositor, first, None)
+      AddMainThreadRenderingStats(timer, renderer_main, first, None)
+      AddImplThreadRenderingStats(timer, renderer_compositor, first, None)
+      AddMainThreadRenderingStats(timer, browser_main, first, ref_stats)
+      AddImplThreadRenderingStats(timer, browser_compositor, first, ref_stats)
     renderer_main.EndSlice(timer.Get())
 
     # Create 5 main and impl rendering stats events not within any action.
     for i in xrange(0, 5):
       first = (i == 0)
       AddMainThreadRenderingStats(timer, renderer_main, first, None)
       AddImplThreadRenderingStats(timer, renderer_compositor, first, None)
       AddMainThreadRenderingStats(timer, browser_main, first, None)
       AddImplThreadRenderingStats(timer, browser_compositor, first, None)
 
     # Create 10 main and impl rendering stats events for Action B.
     timer.Advance()
     renderer_main.BeginSlice('webkit.console', 'ActionB', timer.Get(), '')
     ref_stats.AppendNewRange()
     for i in xrange(0, 10):
       first = (i == 0)
-      AddMainThreadRenderingStats(timer, renderer_main, first, ref_stats)
-      AddImplThreadRenderingStats(timer, renderer_compositor, first, ref_stats)
-      AddMainThreadRenderingStats(timer, browser_main, first, None)
-      AddImplThreadRenderingStats(timer, browser_compositor, first, None)
+      AddMainThreadRenderingStats(timer, renderer_main, first, None)
+      AddImplThreadRenderingStats(timer, renderer_compositor, first, None)
+      AddMainThreadRenderingStats(timer, browser_main, first, ref_stats)
+      AddImplThreadRenderingStats(timer, browser_compositor, first, ref_stats)
     renderer_main.EndSlice(timer.Get())
 
     # Create 10 main and impl rendering stats events for Action A.
     timer.Advance()
     renderer_main.BeginSlice('webkit.console', 'ActionA', timer.Get(), '')
     ref_stats.AppendNewRange()
     for i in xrange(0, 10):
       first = (i == 0)
-      AddMainThreadRenderingStats(timer, renderer_main, first, ref_stats)
-      AddImplThreadRenderingStats(timer, renderer_compositor, first, ref_stats)
-      AddMainThreadRenderingStats(timer, browser_main, first, None)
-      AddImplThreadRenderingStats(timer, browser_compositor, first, None)
+      AddMainThreadRenderingStats(timer, renderer_main, first, None)
+      AddImplThreadRenderingStats(timer, renderer_compositor, first, None)
+      AddMainThreadRenderingStats(timer, browser_main, first, ref_stats)
+      AddImplThreadRenderingStats(timer, browser_compositor, first, ref_stats)
     renderer_main.EndSlice(timer.Get())
 
-    renderer_main.FinalizeImport()
-    renderer_compositor.FinalizeImport()
+    browser.FinalizeImport()
+    renderer.FinalizeImport()
 
     timeline_markers = timeline.FindTimelineMarkers(
         ['ActionA', 'ActionB', 'ActionA'])
     timeline_ranges = [ timeline_bounds.Bounds.CreateFromEvent(marker)
                         for marker in timeline_markers ]
     stats = RenderingStats(renderer, browser, timeline_ranges)
 
+    # Check if we are using the browser compositor's stats
+    self.assertEquals(stats.top_level_process, browser)
+
     # Compare rendering stats to reference.
     self.assertEquals(stats.frame_timestamps, ref_stats.frame_timestamps)
     self.assertEquals(stats.frame_times, ref_stats.frame_times)
     self.assertEquals(stats.rasterize_times, ref_stats.rasterize_times)
     self.assertEquals(stats.rasterized_pixel_counts,
                       ref_stats.rasterized_pixel_counts)
     self.assertEquals(stats.paint_times, ref_stats.paint_times)
     self.assertEquals(stats.painted_pixel_counts,
                       ref_stats.painted_pixel_counts)
     self.assertEquals(stats.record_times, ref_stats.record_times)
@@ skipping 50 matching lines @@
     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()
+    browser.FinalizeImport()
+    renderer.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:
@@ skipping 13 matching lines @@
     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)