Silence warning about falling back to checked-in adb binary

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 80 matching lines @@
     027c10494100b4d7        device
     emulator-5554   offline
 
   Args:
     hardware: Include attached actual devices that are online.
     emulator: Include emulators (i.e. AVD's) currently on host.
     offline: Include devices and emulators that are offline.
 
   Returns: List of devices.
   """
-  adb_devices_output = cmd_helper.GetCmdOutput([constants.ADB_PATH, 'devices'])
+  adb_devices_output = cmd_helper.GetCmdOutput([constants.GetAdbPath(),
+                                                'devices'])
 
   re_device = re.compile('^([a-zA-Z0-9_:.-]+)\tdevice$', re.MULTILINE)
   online_devices = re_device.findall(adb_devices_output)
 
   re_device = re.compile('^(emulator-[0-9]+)\tdevice', re.MULTILINE)
   emulator_devices = re_device.findall(adb_devices_output)
 
   re_device = re.compile('^([a-zA-Z0-9_:.-]+)\toffline$', re.MULTILINE)
   offline_devices = re_device.findall(adb_devices_output)
 
@@ skipping 120 matching lines @@
 
   def __init__(self, device=None, api_strict_mode=False):
     """Constructor.
 
     Args:
       device: If given, adb commands are only send to the device of this ID.
           Otherwise commands are sent to all attached devices.
       api_strict_mode: A boolean indicating whether fatal errors should be
           raised if this API is used improperly.
     """
-    adb_dir = os.path.dirname(constants.ADB_PATH)
+    adb_dir = os.path.dirname(constants.GetAdbPath())
     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
@@ skipping 249 matching lines @@
     ret = self.KillAdbServer()
     if ret != 0:
       raise errors.MsgException('KillAdbServer: %d' % ret)
 
     ret = self.StartAdbServer()
     if ret != 0:
       raise errors.MsgException('StartAdbServer: %d' % ret)
 
   def KillAdbServer(self):
     """Kill adb server."""
-    adb_cmd = [constants.ADB_PATH, 'kill-server']
+    adb_cmd = [constants.GetAdbPath(), 'kill-server']
     ret = cmd_helper.RunCmd(adb_cmd)
     retry = 0
     while retry < 3:
       ret = cmd_helper.RunCmd(['pgrep', 'adb'])
       if ret != 0:
         # pgrep didn't find adb, kill-server succeeded.
         return 0
       retry += 1
       time.sleep(retry)
     return ret
 
   def StartAdbServer(self):
     """Start adb server."""
-    adb_cmd = ['taskset', '-c', '0', constants.ADB_PATH, 'start-server']
+    adb_cmd = ['taskset', '-c', '0', constants.GetAdbPath(), 'start-server']
     ret = cmd_helper.RunCmd(adb_cmd)
     retry = 0
     while retry < 3:
       ret = cmd_helper.RunCmd(['pgrep', 'adb'])
       if ret == 0:
         # pgrep found adb, start-server succeeded.
         # Waiting for device to reconnect before returning success.
         self._adb.SendCommand('wait-for-device')
         return 0
       retry += 1
@@ skipping 715 matching lines @@
     if filters:
       args.extend(filters)
     else:
       args.append('*:v')
 
     if logfile:
       logfile = NewLineNormalizer(logfile)
 
     # Spawn logcat and synchronize with it.
     for _ in range(4):
-      self._logcat = pexpect.spawn(constants.ADB_PATH, args, timeout=10,
+      self._logcat = pexpect.spawn(constants.GetAdbPath(), args, timeout=10,
                                    logfile=logfile)
       if not clear or self.SyncLogCat():
         break
       self._logcat.close(force=True)
     else:
       logging.critical('Error reading from logcat: ' + str(self._logcat.match))
       sys.exit(1)
 
   def SyncLogCat(self):
     """Synchronize with logcat.
@@ skipping 61 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(constants.ADB_PATH,
+        self._logcat = pexpect.spawn(constants.GetAdbPath(),
                                      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 428 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()