cc: Remove main thread rendering stats

tools/telemetry/telemetry/web_perf/metrics/rendering_stats.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.
 from operator import attrgetter
 
 from telemetry.web_perf.metrics import rendering_frame
 
 # These are LatencyInfo component names indicating the various components
 # that the input event has travelled through.
 # This is when the input event first reaches chrome.
@@ skipping 123 matching lines @@
       timestamp_process = renderer_process
 
     timestamp_event_name = GetTimestampEventName(timestamp_process)
 
     # A lookup from list names below to any errors or exceptions encountered
     # in attempting to generate that list.
     self.errors = {}
 
     self.frame_timestamps = []
     self.frame_times = []
-    self.paint_times = []
-    self.painted_pixel_counts = []
-    self.record_times = []
-    self.recorded_pixel_counts = []
     self.approximated_pixel_percentages = []
     # End-to-end latency for input event - from when input event is
     # generated to when the its resulted page is swap buffered.
     self.input_event_latency = []
     self.frame_queueing_durations = []
     # Latency from when a scroll update is sent to the main thread until the
     # resulting frame is swapped.
     self.scroll_update_latency = []
     # Latency for a GestureScrollUpdate input event.
     self.gesture_scroll_update_latency = []
 
     for timeline_range in timeline_ranges:
       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.approximated_pixel_percentages.append([])
       self.input_event_latency.append([])
       self.scroll_update_latency.append([])
       self.gesture_scroll_update_latency.append([])
 
       if timeline_range.is_empty:
         continue
       self._InitFrameTimestampsFromTimeline(
           timestamp_process, timestamp_event_name, timeline_range)
-      self._InitMainThreadRenderingStatsFromTimeline(
-          renderer_process, timeline_range)
       self._InitImplThreadRenderingStatsFromTimeline(
           renderer_process, timeline_range)
       self._InitInputLatencyStatsFromTimeline(
           browser_process, renderer_process, timeline_range)
       self._InitFrameQueueingDurationsFromTimeline(
           renderer_process, timeline_range)
 
   def _InitInputLatencyStatsFromTimeline(
       self, browser_process, renderer_process, timeline_range):
     latency_events = GetInputLatencyEvents(browser_process, timeline_range)
@@ skipping 34 matching lines @@
       if len(self.frame_timestamps[-1]) >= 2:
         self.frame_times[-1].append(round(self.frame_timestamps[-1][-1] -
                                           self.frame_timestamps[-1][-2], 2))
 
   def _InitFrameTimestampsFromTimeline(
       self, process, timestamp_event_name, timeline_range):
     for event in self._GatherEvents(
         timestamp_event_name, process, timeline_range):
       self._AddFrameTimestamp(event)
 
-  def _InitMainThreadRenderingStatsFromTimeline(self, process, timeline_range):
-    event_name = 'BenchmarkInstrumentation::MainThreadRenderingStats'
-    for event in self._GatherEvents(event_name, process, timeline_range):
-      data = event.args['data']
-      self.paint_times[-1].append(1000.0 * data['paint_time'])
-      self.painted_pixel_counts[-1].append(data['painted_pixel_count'])
-      self.record_times[-1].append(1000.0 * data['record_time'])
-      self.recorded_pixel_counts[-1].append(data['recorded_pixel_count'])
-
   def _InitImplThreadRenderingStatsFromTimeline(self, process, timeline_range):
     event_name = 'BenchmarkInstrumentation::ImplThreadRenderingStats'
     for event in self._GatherEvents(event_name, process, timeline_range):
       data = event.args['data']
       if data.get('visible_content_area', 0):
         self.approximated_pixel_percentages[-1].append(
             round(float(data['approximated_visible_content_area']) /
                   float(data['visible_content_area']) * 100.0, 3))
       else:
         self.approximated_pixel_percentages[-1].append(0.0)
 
   def _InitFrameQueueingDurationsFromTimeline(self, process, timeline_range):
     try:
       events = rendering_frame.GetFrameEventsInsideRange(process,
                                                          timeline_range)
       new_frame_queueing_durations = [e.queueing_duration for e in events]
       self.frame_queueing_durations.append(new_frame_queueing_durations)
     except rendering_frame.NoBeginFrameIdException:
       self.errors['frame_queueing_durations'] = (
           'Current chrome version does not support the queueing delay metric.')