[Android] Change object types from AndroidCommands to DeviceUtils in build/android/.

build/android/adb_profile_chrome.py

 #!/usr/bin/env python
 #
 # Copyright 2013 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 gzip
 import logging
 import optparse
 import os
 import re
 import select
 import shutil
 import sys
 import threading
 import time
 import webbrowser
 import zipfile
 import zlib
 
 from pylib import android_commands
 from pylib import cmd_helper
 from pylib import constants
 from pylib import pexpect
+from pylib.device import device_utils
 
 _TRACE_VIEWER_ROOT = os.path.join(constants.DIR_SOURCE_ROOT,
                                   'third_party', 'trace-viewer')
 sys.path.append(_TRACE_VIEWER_ROOT)
 from trace_viewer.build import trace2html # pylint: disable=F0401
 
 _DEFAULT_CHROME_CATEGORIES = '_DEFAULT_CHROME_CATEGORIES'
 
 
 def _GetTraceTimestamp():
   return time.strftime('%Y-%m-%d-%H%M%S', time.localtime())
 
 
 class ChromeTracingController(object):
-  def __init__(self, adb, package_info, categories, ring_buffer):
-    self._adb = adb
+  def __init__(self, device, package_info, categories, ring_buffer):
+    self._device = device
     self._package_info = package_info
     self._categories = categories
     self._ring_buffer = ring_buffer
     self._trace_file = None
     self._trace_interval = None
     self._trace_start_re = \
        re.compile(r'Logging performance trace to file: (.*)')
     self._trace_finish_re = \
        re.compile(r'Profiler finished[.] Results are in (.*)[.]')
-    self._adb.StartMonitoringLogcat(clear=False)
+    self._device.old_interface.StartMonitoringLogcat(clear=False)
 
   def __str__(self):
     return 'chrome trace'
 
   def StartTracing(self, interval):
     self._trace_interval = interval
-    self._adb.SyncLogCat()
-    self._adb.BroadcastIntent(self._package_info.package, 'GPU_PROFILER_START',
-                              '-e categories "%s"' % ','.join(self._categories),
-                              '-e continuous' if self._ring_buffer else '')
+    self._device.old_interface.SyncLogCat()
+    self._device.old_interface.BroadcastIntent(
+        self._package_info.package, 'GPU_PROFILER_START',
+        '-e categories "%s"' % ','.join(self._categories),
+        '-e continuous' if self._ring_buffer else '')
     # Chrome logs two different messages related to tracing:
     #
     # 1. "Logging performance trace to file [...]"
     # 2. "Profiler finished. Results are in [...]"
     #
     # The first one is printed when tracing starts and the second one indicates
     # that the trace file is ready to be pulled.
     try:
-      self._trace_file = self._adb.WaitForLogMatch(self._trace_start_re,
-                                                   None,
-                                                   timeout=5).group(1)
+      self._trace_file = self._device.old_interface.WaitForLogMatch(
+          self._trace_start_re, None, timeout=5).group(1)
     except pexpect.TIMEOUT:
       raise RuntimeError('Trace start marker not found. Is the correct version '
                          'of the browser running?')
 
   def StopTracing(self):
     if not self._trace_file:
       return
-    self._adb.BroadcastIntent(self._package_info.package, 'GPU_PROFILER_STOP')
-    self._adb.WaitForLogMatch(self._trace_finish_re, None, timeout=120)
+    self._device.old_interface.BroadcastIntent(self._package_info.package,
+                                               'GPU_PROFILER_STOP')
+    self._device.old_interface.WaitForLogMatch(self._trace_finish_re, None,
+                                               timeout=120)
 
   def PullTrace(self):
     # Wait a bit for the browser to finish writing the trace file.
     time.sleep(self._trace_interval / 4 + 1)
 
     trace_file = self._trace_file.replace('/storage/emulated/0/', '/sdcard/')
     host_file = os.path.join(os.path.curdir, os.path.basename(trace_file))
-    self._adb.PullFileFromDevice(trace_file, host_file)
+    self._device.old_interface.PullFileFromDevice(trace_file, host_file)
     return host_file
 
 
 _SYSTRACE_OPTIONS = [
     # Compress the trace before sending it over USB.
     '-z',
     # Use a large trace buffer to increase the polling interval.
     '-b', '16384'
 ]
 
 # Interval in seconds for sampling systrace data.
 _SYSTRACE_INTERVAL = 15
 
 
 class SystraceController(object):
-  def __init__(self, adb, categories, ring_buffer):
-    self._adb = adb
+  def __init__(self, device, categories, ring_buffer):
+    self._device = device
     self._categories = categories
     self._ring_buffer = ring_buffer
     self._done = threading.Event()
     self._thread = None
     self._trace_data = None
 
   def __str__(self):
     return 'systrace'
 
   @staticmethod
-  def GetCategories(adb):
-    return adb.RunShellCommand('atrace --list_categories')
+  def GetCategories(device):
+    return device.old_interface.RunShellCommand('atrace --list_categories')
 
   def StartTracing(self, _):
     self._thread = threading.Thread(target=self._CollectData)
     self._thread.start()
 
   def StopTracing(self):
     self._done.set()
 
   def PullTrace(self):
     self._thread.join()
     self._thread = None
     if self._trace_data:
       output_name = 'systrace-%s' % _GetTraceTimestamp()
       with open(output_name, 'w') as out:
         out.write(self._trace_data)
       return output_name
 
   def _RunATraceCommand(self, command):
+    # TODO(jbudorick) can this be made work with DeviceUtils?
     # We use a separate interface to adb because the one from AndroidCommands
     # isn't re-entrant.
-    device = ['-s', self._adb.GetDevice()] if self._adb.GetDevice() else []
-    cmd = ['adb'] + device + ['shell', 'atrace', '--%s' % command] + \
+    device_param = (['-s', self._device.old_interface.GetDevice()]
+                    if self._device.old_interface.GetDevice() else [])
+    cmd = ['adb'] + device_param + ['shell', 'atrace', '--%s' % command] + \
         _SYSTRACE_OPTIONS + self._categories
     return cmd_helper.GetCmdOutput(cmd)
 
   def _CollectData(self):
     trace_data = []
     self._RunATraceCommand('async_start')
     try:
       while not self._done.is_set():
         self._done.wait(_SYSTRACE_INTERVAL)
         if not self._ring_buffer or self._done.is_set():
@@ skipping 218 matching lines @@
 
 For basic jank busting uses, use  --trace-frame-viewer
 For detailed study of ubercompositor, pass --trace-ubercompositor.
 
 When in doubt, just try out --trace-frame-viewer.
 """)
 
   if options.verbose:
     logging.getLogger().setLevel(logging.DEBUG)
 
-  adb = android_commands.AndroidCommands()
+  devices = android_commands.GetAttachedDevices()
+  if len(devices) != 1:
+    parser.error('Exactly 1 device much be attached.')
+  device = device_utils.DeviceUtils(devices[0])
+
   if options.systrace_categories in ['list', 'help']:
-    _PrintMessage('\n'.join(SystraceController.GetCategories(adb)))
+    _PrintMessage('\n'.join(SystraceController.GetCategories(device)))
     return 0
 
   if not options.time and not options.continuous:
     _PrintMessage('Time interval or continuous tracing should be specified.')
     return 1
 
   chrome_categories = _ComputeChromeCategories(options)
   systrace_categories = _ComputeSystraceCategories(options)
   package_info = _GetSupportedBrowsers()[options.browser]
 
   if chrome_categories and 'webview' in systrace_categories:
     logging.warning('Using the "webview" category in systrace together with '
                     'Chrome tracing results in duplicate trace events.')
 
   controllers = []
   if chrome_categories:
-    controllers.append(ChromeTracingController(adb,
+    controllers.append(ChromeTracingController(device,
                                                package_info,
                                                chrome_categories,
                                                options.ring_buffer))
   if systrace_categories:
-    controllers.append(SystraceController(adb,
+    controllers.append(SystraceController(device,
                                           systrace_categories,
                                           options.ring_buffer))
 
   if not controllers:
     _PrintMessage('No trace categories enabled.')
     return 1
 
   if options.output:
     options.output = os.path.expanduser(options.output)
   result = _CaptureAndPullTrace(controllers,
                                 options.time if not options.continuous else 0,
                                 options.output,
                                 options.compress,
                                 options.json)
   if options.view:
     if sys.platform == 'darwin':
       os.system('/usr/bin/open %s' % os.path.abspath(result))
     else:
       webbrowser.open(result)
 
 
 if __name__ == '__main__':
   sys.exit(main())