Telemetry: Use cc frames and fix bots.

tools/perf/metrics/timeline.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 collections
 
 from metrics import Metric
 from telemetry.page import page_measurement
 
 TRACING_MODE = 'tracing-mode'
 TIMELINE_MODE = 'timeline-mode'
@@ skipping 133 matching lines @@
 AllThreads = TimelineThreadCategories.values()
 NoThreads = []
 MainThread = ["renderer_main"]
 FastPathResults = AllThreads
 FastPathDetails = NoThreads
 SilkResults = ["renderer_main", "total_all"]
 SilkDetails = MainThread
 
 # TODO(epenner): Thread names above are likely fairly stable but trace names
 # could change. We should formalize this trace to keep this robust.
-GpuFrameTraceName = ":RealSwapBuffers"
-# TODO(epenner): The decoder swap-buffers can be used by several producers.
-# we need to find the canonical swap buffers on Mac.
-GpuFrameTraceNameMac = "GLES2DecoderImpl::DoSwapBuffers"
+CompositorFrameTraceName = "::SwapBuffers"
 
 def ThreadCategoryName(thread_name):
   thread_category = "other"
   for substring, category in TimelineThreadCategories.iteritems():
     if substring in MatchBySubString and substring in thread_name:
       thread_category = category
   if thread_name in TimelineThreadCategories:
     thread_category = TimelineThreadCategories[thread_name]
   return thread_category
 
@@ skipping 30 matching lines @@
         res += x.thread_duration
     return res
 
   def AppendThreadSlices(self, thread):
     self.all_slices.extend(thread.all_slices)
     self.toplevel_slices.extend(thread.toplevel_slices)
 
   def AddResults(self, num_frames, results):
     clock_report_name = ThreadTimeResultName(self.name)
     cpu_report_name  = ThreadCpuTimeResultName(self.name)
-    clock_per_frame = float(self.clock_time) / num_frames
-    cpu_per_frame   = float(self.cpu_time) / num_frames
+    clock_per_frame = (float(self.clock_time) / num_frames) if num_frames else 0
+    cpu_per_frame   = (float(self.cpu_time) / num_frames) if num_frames else 0
     results.Add(clock_report_name, 'ms', clock_per_frame)
     results.Add(cpu_report_name, 'ms', cpu_per_frame)
 
   def AddDetailedResults(self, num_frames, results):
     slices_by_category = collections.defaultdict(list)
     for s in self.all_slices:
       slices_by_category[s.category].append(s)
     all_self_times = []
     for category, slices_in_category in slices_by_category.iteritems():
       self_time = sum([x.self_time for x in slices_in_category])
       all_self_times.append(self_time)
-      self_time_result = float(self_time) / num_frames
+      self_time_result = (float(self_time) / num_frames) if num_frames else 0
       results.Add(ThreadDetailResultName(self.name, category),
                   'ms', self_time_result)
     all_measured_time = sum(all_self_times)
     idle_time = max(0, self.model.bounds.bounds - all_measured_time)
-    idle_time_result = float(idle_time) / num_frames
+    idle_time_result = (float(idle_time) / num_frames) if num_frames else 0
     results.Add(ThreadDetailResultName(self.name, "idle"),
                 'ms', idle_time_result)
 
 class ThreadTimesTimelineMetric(TimelineMetric):
   def __init__(self):
     super(ThreadTimesTimelineMetric, self).__init__(TRACING_MODE)
     self.results_to_report = AllThreads
     self.details_to_report = NoThreads
 
   def CountSlices(self, slices, substring):
@@ skipping 16 matching lines @@
 
     # Group all threads.
     for thread in self._model.GetAllThreads():
       thread_category_results['total_all'].AppendThreadSlices(thread)
 
     # Also group fast-path threads.
     for thread in self._model.GetAllThreads():
       if ThreadCategoryName(thread.name) in FastPath:
         thread_category_results['total_fast_path'].AppendThreadSlices(thread)
 
-    # Calculate the number of frames from the GPU thread.
-    gpu_slices = thread_category_results['GPU'].all_slices
-    num_frames = self.CountSlices(gpu_slices, GpuFrameTraceName)
-    if not num_frames:
-      num_frames = self.CountSlices(gpu_slices, GpuFrameTraceNameMac)
-    if not num_frames:
-      raise MissingFramesError()
+    # Calculate the number of frames from the CC thread.
+    cc_slices = thread_category_results['renderer_compositor'].all_slices
+    num_frames = self.CountSlices(cc_slices, CompositorFrameTraceName)
 
     # Report the desired results and details.
     for thread_results in thread_category_results.values():
       if thread_results.name in self.results_to_report:
         thread_results.AddResults(num_frames, results)
       # TOOD(nduca): When generic results objects are done, this special case
       # can be replaced with a generic UI feature.
       if thread_results.name in self.details_to_report:
         thread_results.AddDetailedResults(num_frames, results)