Telemetry / Android: further cleanup on 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 10 matching lines @@
 
   Args:
     adb: the adb connection to use.
   """
   class Result(object):
     def __init__(self, name, value, unit):
       self.name = name
       self.value = value
       self.unit = unit
 
-  def __init__(self, adb, trace_tag):
+  def __init__(self, adb, trace_tag=''):
     self._adb = adb
-    self._trace_tag = trace_tag
     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._print_perf_results = True
     self._results = []
 
   def __enter__(self):
+    self.Start()
+
+  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 __exit__(self, *args):
+    self.Stop()
+
+  def Stop(self):
     self._StorePerfResults()
-    self._PrintPerfResults()
     if self._collector_thread:
       self._stop_event.set()
       self._collector_thread.join()
       self._collector_thread = None
 
   def GetResults(self):
     return self._results
 
-  def SuppressPrintingResults(self):
-    self._print_perf_results = False
-
-  def _PrintPerfResults(self):
-    if not self._print_perf_results:
-      return
-    for r in self._results:
-      perf_tests_helper.PrintPerfResult(r.name, r.name + self._trace_tag,
-                                        r.value, r.unit)
-
   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
       (seconds, latencies) = self._GetDataFromThread()
@@ skipping 164 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(),
     }