Remove some of the instrumentation plumbing

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
 
 import telemetry.timeline.async_slice as tracing_async_slice
 import telemetry.timeline.bounds as timeline_bounds
 from telemetry.perf_tests_helper import FlattenList
@@ skipping 36 matching lines @@
 
 class ReferenceRenderingStats(object):
   """ 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.input_event_latency = []
     self.input_event = []
 
 def AddMainThreadRenderingStats(mock_timer, thread, ref_stats = None):
   """ Adds a random main thread rendering stats event.
@@ skipping 57 matching lines @@
 def AddImplThreadRenderingStats(mock_timer, thread, first_frame,
                                 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,
            '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, 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.
@@ skipping 262 matching lines @@
     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)
 
     # 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 testInputLatencyFromTimeline(self):
@@ skipping 59 matching lines @@
     stats = RenderingStats(renderer, browser, 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])