android: Add interactive surface statistics viewer

build/android/pylib/surface_stats_collector.py

 # Copyright (c) 2012 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 Queue
 import datetime
 import logging
 import re
 import threading
 
@@ skipping 19 matching lines @@
 
   def __init__(self, adb):
     self._adb = adb
     self._collector_thread = None
     self._use_legacy_method = False
     self._surface_before = None
     self._get_data_event = None
     self._data_queue = None
     self._stop_event = None
     self._results = []
+    self._warn_about_empty_data = True
+
+  def DisableWarningAboutEmptyData(self):
+    self._warn_about_empty_data = False
 
   def Start(self):
     assert not self._collector_thread
 
     if self._ClearSurfaceFlingerLatencyData():
       self._get_data_event = threading.Event()
       self._stop_event = threading.Event()
       self._data_queue = Queue.Queue()
       self._collector_thread = threading.Thread(target=self._CollectorThread)
       self._collector_thread.start()
     else:
       self._use_legacy_method = True
       self._surface_before = self._GetSurfaceStatsLegacy()
 
   def Stop(self):
     self._StorePerfResults()
     if self._collector_thread:
       self._stop_event.set()
       self._collector_thread.join()
       self._collector_thread = None
 
+  def SampleResults(self):
+    self._StorePerfResults()
+    results = self._results
+    self._results = []
+    return results
+
   def GetResults(self):
     return self._results
 
   @staticmethod
   def _GetNormalizedDeltas(data, refresh_period):
     deltas = [t2 - t1 for t1, t2 in zip(data, data[1:])]
     return (deltas, [delta / refresh_period for delta in deltas])
 
   def _StorePerfResults(self):
     if self._use_legacy_method:
       surface_after = self._GetSurfaceStatsLegacy()
       td = surface_after['timestamp'] - self._surface_before['timestamp']
       seconds = td.seconds + td.microseconds / 1e6
       frame_count = (surface_after['page_flip_count'] -
                      self._surface_before['page_flip_count'])
     else:
       assert self._collector_thread
       (refresh_period, timestamps) = self._GetDataFromThread()
       if not refresh_period or not len(timestamps) >= 3:
-        logging.warning('Surface stat data is empty')
+        if self._warn_about_empty_data:
+          logging.warning('Surface stat data is empty')
         return
       frame_count = len(timestamps)
       seconds = timestamps[-1] - timestamps[0]
 
       frame_lengths, normalized_frame_lengths = \
           self._GetNormalizedDeltas(timestamps, refresh_period)
       length_changes, normalized_changes = \
           self._GetNormalizedDeltas(frame_lengths, refresh_period)
       jankiness = [max(0, round(change)) for change in normalized_changes]
       pause_threshold = 20
@@ skipping 144 matching lines @@
       try:
         cur_surface = int(match.group(1), 16)
       except Exception:
         logging.error('Failed to parse current surface from ' + match.group(1))
     else:
       logging.warning('Failed to call SurfaceFlinger surface ' + results[0])
     return {
         'page_flip_count': cur_surface,
         'timestamp': datetime.datetime.now(),
     }