Telemetry: Fix frame counting on Mac

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 131 matching lines @@
             "IO"]
 
 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"
+
 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
 
 def ThreadTimeResultName(thread_category):
@@ skipping 57 matching lines @@
     idle_time_result = float(idle_time) / num_frames
     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 CalcFrameCount(self):
-    gpu_swaps = 0
-    for thread in self._model.GetAllThreads():
-      if (ThreadCategoryName(thread.name) == "GPU"):
-        for event in thread.IterAllSlices():
-          if ":RealSwapBuffers" in event.name:
-            gpu_swaps += 1
-    return gpu_swaps
+  def CountSlices(self, slices, substring):
+    count = 0
+    for event in slices:
+      if substring in event.name:
+        count += 1
+    return count
 
   def AddResults(self, tab, results):
-    num_frames = self.CalcFrameCount()
-    if not num_frames:
-      raise MissingFramesError()
-
     # Set up each thread category for consistant results.
     thread_category_results = {}
     for name in TimelineThreadCategories.values():
       thread_category_results[name] = ResultsForThread(self.model, name)
 
     # Group the slices by their thread category.
     for thread in self._model.GetAllThreads():
       thread_category = ThreadCategoryName(thread.name)
       thread_category_results[thread_category].AppendThreadSlices(thread)
 
     # 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()
+
     # 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)