re-land: telemetry: Add approximated pixels percentage to 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
 from metrics.rendering_stats import NotEnoughFramesError
+from telemetry.util.statistics import DivideIfPossibleOrZero
 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
   durations for stats and consistent timestamps for all mock trace events.
@@ skipping 15 matching lines @@
   """ Stores expected data for comparison with actual RenderingStats """
   def __init__(self):
     self.frame_timestamps = []
     self.frame_times = []
     self.paint_times = []
     self.painted_pixel_counts = []
     self.record_times = []
     self.recorded_pixel_counts = []
     self.rasterize_times = []
     self.rasterized_pixel_counts = []
+    self.approximated_pixel_percentages = []
 
   def AppendNewRange(self):
     self.frame_timestamps.append([])
     self.frame_times.append([])
     self.paint_times.append([])
     self.painted_pixel_counts.append([])
     self.record_times.append([])
     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.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 = []
@@ skipping 42 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,
            'rasterize_time': mock_timer.Advance(5, 10) / 1000.0,
-           'rasterized_pixel_count': 1280*720 }
+           'rasterized_pixel_count': 1280*720,
+           'visible_content_area': random.uniform(0, 100),
+           'approximated_visible_content_area': random.uniform(0, 5)}
   timestamp = mock_timer.Get()
 
   # 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.rasterize_times[-1].append(data['rasterize_time'] * 1000.0)
   ref_stats.rasterized_pixel_counts[-1].append(data['rasterized_pixel_count'])
+  ref_stats.approximated_pixel_percentages[-1].append(
+      round(DivideIfPossibleOrZero(data['approximated_visible_content_area'],
+                                   data['visible_content_area']) * 100.0, 3))
 
 
 def AddInputLatencyStats(mock_timer, input_type, start_thread, end_thread,
                          ref_latency_stats = None):
   """ Adds a random input latency stats event.
 
   input_type: The input type for which the latency slice is generated.
   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 197 matching lines @@
                         for marker in timeline_markers ]
     stats = RenderingStats(renderer, browser, 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.rasterize_times, renderer_ref_stats.rasterize_times)
     self.assertEquals(stats.rasterized_pixel_counts,
                       renderer_ref_stats.rasterized_pixel_counts)
+    self.assertEquals(stats.approximated_pixel_percentages,
+                      renderer_ref_stats.approximated_pixel_percentages)
     self.assertEquals(stats.paint_times, renderer_ref_stats.paint_times)
     self.assertEquals(stats.painted_pixel_counts,
                       renderer_ref_stats.painted_pixel_counts)
     self.assertEquals(stats.record_times, renderer_ref_stats.record_times)
     self.assertEquals(stats.recorded_pixel_counts,
                       renderer_ref_stats.recorded_pixel_counts)
 
   def testScrollLatencyFromTimeline(self):
     timeline = model.TimelineModel()
 
@@ skipping 83 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)