Adding checkerboard measurements to telemetry.

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
 
 from telemetry.perf_tests_helper import FlattenList
 import telemetry.timeline.async_slice as tracing_async_slice
 import telemetry.timeline.bounds as timeline_bounds
@@ skipping 36 matching lines @@
     return self.milliseconds
 
 
 class ReferenceRenderingStats(object):
   """ Stores expected data for comparison with actual RenderingStats """
 
   def __init__(self):
     self.frame_timestamps = []
     self.frame_times = []
     self.approximated_pixel_percentages = []
+    self.checkerboarded_pixel_percentages = []
 
   def AppendNewRange(self):
     self.frame_timestamps.append([])
     self.frame_times.append([])
     self.approximated_pixel_percentages.append([])
+    self.checkerboarded_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 = []
 
 
@@ skipping 63 matching lines @@
                                 ref_stats=None):
   """ Adds a random impl 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 impl thread rendering stats.
   data = {'frame_count': 1,
           'visible_content_area': random.uniform(0, 100),
-          'approximated_visible_content_area': random.uniform(0, 5)}
+          'approximated_visible_content_area': random.uniform(0, 5),
+          'checkerboarded_visible_content_area': random.uniform(0, 5)}
   timestamp = mock_timer.AdvanceAndGet()
 
   # Add a slice with the event data to the given thread.
   thread.PushCompleteSlice(
       'benchmark', 'BenchmarkInstrumentation::ImplThreadRenderingStats',
       timestamp, duration=0.0, thread_timestamp=None, thread_duration=None,
       args={'data': data})
 
   if not ref_stats:
     return
 
   # Add timestamp only if a frame was output
   if data['frame_count'] == 1:
     if not first_frame:
       # Add frame_time if this is not the first frame in within the bounds of an
       # action.
       prev_timestamp = ref_stats.frame_timestamps[-1][-1]
       ref_stats.frame_times[-1].append(round(timestamp - prev_timestamp, 2))
     ref_stats.frame_timestamps[-1].append(timestamp)
 
   ref_stats.approximated_pixel_percentages[-1].append(
       round(DivideIfPossibleOrZero(data['approximated_visible_content_area'],
                                    data['visible_content_area']) * 100.0, 3))
 
+  ref_stats.checkerboarded_pixel_percentages[-1].append(
+      round(DivideIfPossibleOrZero(data['checkerboarded_visible_content_area'],
+                                   data['visible_content_area']) * 100.0, 3))
 
 def AddInputLatencyStats(mock_timer, start_thread, end_thread,
                          ref_latency_stats=None):
   """ Adds a random input latency stats event.
 
   start_thread: The start thread on which the async slice is added.
   end_thread: The end thread on which the async slice is ended.
   ref_latency_stats: A ReferenceInputLatencyStats object for expected values.
   """
 
@@ skipping 275 matching lines @@
     timeline_ranges = [timeline_bounds.Bounds.CreateFromEvent(marker)
                        for marker in timeline_markers]
     stats = RenderingStats(renderer, browser, None, timeline_ranges)
 
     # Compare rendering stats to reference.
     self.assertEquals(stats.frame_timestamps,
                       browser_ref_stats.frame_timestamps)
     self.assertEquals(stats.frame_times, browser_ref_stats.frame_times)
     self.assertEquals(stats.approximated_pixel_percentages,
                       renderer_ref_stats.approximated_pixel_percentages)
+    self.assertEquals(stats.checkerboarded_pixel_percentages,
+                      renderer_ref_stats.checkerboarded_pixel_percentages)
 
   def testInputLatencyFromTimeline(self):
     timeline = model.TimelineModel()
 
     # Create a browser process and a renderer process.
     browser = timeline.GetOrCreateProcess(pid=1)
     browser_main = browser.GetOrCreateThread(tid=11)
     renderer = timeline.GetOrCreateProcess(pid=2)
     renderer_main = renderer.GetOrCreateThread(tid=21)
 
@@ skipping 48 matching lines @@
     stats = RenderingStats(renderer, browser, None, timeline_ranges)
     self.assertEquals(FlattenList(stats.input_event_latency), [
         latency for name, latency in ref_latency.input_event_latency
         if name != SCROLL_UPDATE_EVENT_NAME])
     self.assertEquals(FlattenList(stats.scroll_update_latency), [
         latency for name, latency in ref_latency.input_event_latency
         if name == SCROLL_UPDATE_EVENT_NAME])
     self.assertEquals(FlattenList(stats.gesture_scroll_update_latency), [
         latency for name, latency in ref_latency.input_event_latency
         if name == GESTURE_SCROLL_UPDATE_EVENT_NAME])