Android / Telemetry: fixes surface stats collector.

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 78 matching lines @@
 
     print 'SurfaceMonitorTime: %fsecs' % seconds
     perf_tests_helper.PrintPerfResult(
         'avg_surface_fps', 'avg_surface_fps' + self._trace_tag,
         [int(round(frame_count / seconds))], 'fps')
 
   def _CollectorThread(self):
     last_timestamp = 0
     first_timestamp = 0
     latencies = []
+    retries = 0
+    has_collected_data = False
 
     while not self._stop_event.is_set():
       self._get_data_event.wait(1)
       try:
         (t, last_timestamp) = self._GetSurfaceFlingerLatencyData(last_timestamp,
                                                                  latencies)
+        if (t, last_timestamp) == (None, None):
+          retries += 1
+          if retries < 3:
+            continue
+          if has_collected_data:
+            # Some data has already been collected, but either the app
+            # was closed or there's no new data. Signal the main thread and
+            # wait.
+            self._data_queue.put((None, None))
+            self._stop_event.wait()
+            break
+          raise Exception('Unable to get surface flinger latency data')
+
+        has_collected_data = True
+
         if not first_timestamp:
           first_timestamp = t
 
         if self._get_data_event.is_set():
           self._get_data_event.clear()
           self._data_queue.put(((last_timestamp - first_timestamp) / 1e9,
                                 latencies))
           latencies = []
           first_timestamp = 0
       except Exception as e:
@@ skipping 29 matching lines @@
     Args:
       previous_timestamp: The timestamp returned from the previous call or 0.
           Only data after this timestamp will be returned.
       latencies: A list to receive latency data. The latencies are integers
           each of which is the number of refresh periods of each frame.
 
     Returns:
       A tuple containing:
       - The timestamp of the beginning of the first frame (ns),
       - The timestamp of the end of the last frame (ns).
-
-    Raises:
-      Exception if failed to run the SurfaceFlinger command or SurfaceFlinger
-          returned invalid result.
+      The tuple may be (None, None) if there was no data collected (for example,
+      if the app was closed before the collector thread has finished).
     """
     # adb shell dumpsys SurfaceFlinger --latency <window name>
     # prints some information about the last 128 frames displayed in
     # that window.
     # The data returned looks like this:
     # 16954612
     # 7657467895508   7657482691352   7657493499756
     # 7657484466553   7657499645964   7657511077881
     # 7657500793457   7657516600576   7657527404785
     # (...)
     #
     # The first line is the refresh period (here 16.95 ms), it is followed
     # by 128 lines w/ 3 timestamps in nanosecond each:
     # A) when the app started to draw
     # B) the vsync immediately preceding SF submitting the frame to the h/w
     # C) timestamp immediately after SF submitted that frame to the h/w
     #
     # The difference between the 1st and 3rd timestamp is the frame-latency.
     # An interesting data is when the frame latency crosses a refresh period
     # boundary, this can be calculated this way:
     #
     # ceil((C - A) / refresh-period)
     #
     # (each time the number above changes, we have a "jank").
     # If this happens a lot during an animation, the animation appears
     # janky, even if it runs at 60 fps in average.
     results = self._adb.RunShellCommand(
         'dumpsys SurfaceFlinger --latency %s/%s' %
         (self._window_package, self._window_activity), log_result=True)
-    assert len(results)
+    if not len(results):
+      return (None, None)
 
     refresh_period = int(results[0])
     last_timestamp = previous_timestamp
     first_timestamp = 0
     for line in results[1:]:
       fields = line.split()
       if len(fields) == 3:
         timestamp = long(fields[0])
         last_timestamp = long(fields[2])
         if (timestamp > previous_timestamp):
@@ skipping 22 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(),
     }