Android: allows using adb from a chromium checkout without envsetup.sh

build/android/pylib/android_commands.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.
 
 """Provides an interface to communicate with the device via the adb command.
 
 Assumes adb binary is currently on system path.
 """
 
 import collections
@@ skipping 60 matching lines @@
   Both devices starting with 'emulator' will be returned in below output:
 
     * daemon not running. starting it now on port 5037 *
     * daemon started successfully *
     List of devices attached
     027c10494100b4d7        device
     emulator-5554   offline
     emulator-5558   device
   """
   re_device = re.compile('^emulator-[0-9]+', re.MULTILINE)
-  devices = re_device.findall(cmd_helper.GetCmdOutput(['adb', 'devices']))
+  devices = re_device.findall(cmd_helper.GetCmdOutput([constants.ADB_PATH,
+                                                       'devices']))
   return devices
 
 
 def GetAVDs():
   """Returns a list of AVDs."""
   re_avd = re.compile('^[ ]+Name: ([a-zA-Z0-9_:.-]+)', re.MULTILINE)
   avds = re_avd.findall(cmd_helper.GetCmdOutput(['android', 'list', 'avd']))
   return avds
 
 
 def GetAttachedDevices():
   """Returns a list of attached, online android devices.
 
   If a preferred device has been set with ANDROID_SERIAL, it will be first in
   the returned list.
 
   Example output:
 
     * daemon not running. starting it now on port 5037 *
     * daemon started successfully *
     List of devices attached
     027c10494100b4d7        device
     emulator-5554   offline
   """
   re_device = re.compile('^([a-zA-Z0-9_:.-]+)\tdevice$', re.MULTILINE)
-  devices = re_device.findall(cmd_helper.GetCmdOutput(['adb', 'devices']))
+  devices = re_device.findall(cmd_helper.GetCmdOutput([constants.ADB_PATH,
+                                                       'devices']))
   preferred_device = os.environ.get('ANDROID_SERIAL')
   if preferred_device in devices:
     devices.remove(preferred_device)
     devices.insert(0, preferred_device)
   return devices
 
 
 def IsDeviceAttached(device):
   return device in GetAttachedDevices()
 
@@ skipping 80 matching lines @@
 
 class AndroidCommands(object):
   """Helper class for communicating with Android device via adb.
 
   Args:
     device: If given, adb commands are only send to the device of this ID.
         Otherwise commands are sent to all attached devices.
   """
 
   def __init__(self, device=None):
+    adb_dir = os.path.dirname(constants.ADB_PATH)
+    if adb_dir and adb_dir not in os.environ['PATH'].split(os.pathsep):
+      # Required by third_party/android_testrunner to call directly 'adb'.
+      os.environ['PATH'] += os.pathsep + adb_dir
     self._adb = adb_interface.AdbInterface()
     if device:
       self._adb.SetTargetSerial(device)
     self._device = device
     self._logcat = None
     self.logcat_process = None
     self._logcat_tmpoutfile = None
     self._pushed_files = []
     self._device_utc_offset = self.RunShellCommand('date +%z')[0]
     self._md5sum_build_dir = ''
@@ skipping 184 matching lines @@
     if out.strip() != 'remount succeeded':
       raise errors.MsgException('Remount failed: %s' % out)
 
   def RestartAdbServer(self):
     """Restart the adb server."""
     self.KillAdbServer()
     self.StartAdbServer()
 
   def KillAdbServer(self):
     """Kill adb server."""
-    adb_cmd = ['adb', 'kill-server']
+    adb_cmd = [constants.ADB_PATH, 'kill-server']
     return cmd_helper.RunCmd(adb_cmd)
 
   def StartAdbServer(self):
     """Start adb server."""
-    adb_cmd = ['adb', 'start-server']
+    adb_cmd = [constants.ADB_PATH, 'start-server']
     return cmd_helper.RunCmd(adb_cmd)
 
   def WaitForSystemBootCompleted(self, wait_time):
     """Waits for targeted system's boot_completed flag to be set.
 
     Args:
       wait_time: time in seconds to wait
 
     Raises:
       WaitForResponseTimedOutError if wait_time elapses and flag still not
@@ skipping 487 matching lines @@
     if filters:
       args.extend(filters)
     else:
       args.append('*:v')
 
     if logfile:
       logfile = NewLineNormalizer(logfile)
 
     # Spawn logcat and syncronize with it.
     for _ in range(4):
-      self._logcat = pexpect.spawn('adb', args, timeout=10, logfile=logfile)
+      self._logcat = pexpect.spawn(constants.ADB_PATH, args, timeout=10,
+                                   logfile=logfile)
       self.RunShellCommand('log startup_sync')
       if self._logcat.expect(['startup_sync', pexpect.EOF,
                               pexpect.TIMEOUT]) == 0:
         break
       self._logcat.close(force=True)
     else:
       logging.critical('Error reading from logcat: ' + str(self._logcat.match))
       sys.exit(1)
 
   def GetMonitoredLogCat(self):
@@ skipping 48 matching lines @@
             'to debug)' %
             (timeout, success_re.pattern))
       except pexpect.EOF:
         # It seems that sometimes logcat can end unexpectedly. This seems
         # to happen during Chrome startup after a reboot followed by a cache
         # clean. I don't understand why this happens, but this code deals with
         # getting EOF in logcat.
         logging.critical('Found EOF in adb logcat. Restarting...')
         # Rerun spawn with original arguments. Note that self._logcat.args[0] is
         # the path of adb, so we don't want it in the arguments.
-        self._logcat = pexpect.spawn('adb',
+        self._logcat = pexpect.spawn(constants.ADB_PATH,
                                      self._logcat.args[1:],
                                      timeout=self._logcat.timeout,
                                      logfile=self._logcat.logfile)
 
   def StartRecordingLogcat(self, clear=True, filters=['*:v']):
     """Starts recording logcat output to eventually be saved as a string.
 
     This call should come before some series of tests are run, with either
     StopRecordingLogcat or SearchLogcatRecord following the tests.
 
@@ skipping 325 matching lines @@
   """
   def __init__(self, output):
     self._output = output
 
   def write(self, data):
     data = data.replace('\r\r\n', '\n')
     self._output.write(data)
 
   def flush(self):
     self._output.flush()