[Android] Remove all references to pylib from telemetry.

tools/telemetry/telemetry/internal/backends/mandoline/android.py

 # Copyright 2014 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.
 
 # TODO(yzshen): Once the dep manager is ready, remove this file and use the one
 # from src/mojo/tools directly.
 
 
 import atexit
 import logging
 import os
 import signal
 import subprocess
 import sys
 import threading
 import time
 
 from .paths import Paths
 
+from telemetry.internal.util import binary_manager
+
 from devil import base_error
 from devil.android import apk_helper
 from devil.android import device_errors
 from devil.android import device_utils
-from pylib import constants
+from devil.android.sdk import adb_wrapper
+from devil.constants import exit_codes
 
 
 # Tags used by the mojo shell application logs.
 LOGCAT_TAGS = [
     'AndroidHandler',
     'MojoFileHelper',
     'MojoMain',
     'MojoShellActivity',
     'MojoShellApplication',
     'chromium',
 ]
 
 MAPPING_PREFIX = '--map-origin='
 
 
 def _ExitIfNeeded(process):
   '''Exits |process| if it is still alive.'''
   if process.poll() is None:
     process.kill()
 
 
 class AndroidShell(object):
   '''
   Used to set up and run a given mojo shell binary on an Android device.
   |config| is the mopy.config.Config for the build.
   '''
   def __init__(self, config, chrome_root):
-    self.adb_path = constants.GetAdbPath()
+    self.adb_path = adb_wrapper.AdbWrapper.GetAdbPath()
     self.config = config
     self.paths = Paths(config, chrome_root)
     self.device = None
     self.shell_args = []
     self.target_package = apk_helper.GetPackageName(self.paths.apk_path)
     self.temp_gdb_dir = None
-    # This is used by decive_utils.Install to check if the apk needs updating.
-    constants.SetOutputDirectory(self.paths.build_dir)
 
-  # TODO(msw): Use pylib's adb_wrapper and device_utils instead.
+  # TODO(msw): Use devil's adb_wrapper and device_utils instead.
   def _CreateADBCommand(self, args):
     adb_command = [self.adb_path, '-s', self.device.adb.GetDeviceSerial()]
     adb_command.extend(args)
     logging.getLogger().debug('Command: %s', ' '.join(adb_command))
     return adb_command
 
   def _ReadFifo(self, path, pipe, on_fifo_closed, max_attempts=5):
     '''
     Reads the fifo at |path| on the device and write the contents to |pipe|.
     Calls |on_fifo_closed| when the fifo is closed. This method will try to find
@@ skipping 34 matching lines @@
         self.device = next((d for d in devices if d == device), None)
         if not self.device:
           raise device_errors.DeviceUnreachableError(device)
       elif devices:
         self.device = devices[0]
       else:
         raise device_errors.NoDevicesError()
 
       logging.getLogger().debug('Using device: %s', self.device)
       # Clean the logs on the device to avoid displaying prior activity.
-      subprocess.check_call(self._CreateADBCommand(['logcat', '-c']))
+      self.device.adb.Logcat(clear=True)
       self.device.EnableRoot()
       self.device.Install(self.paths.apk_path)
     except base_error.BaseError as e:
       # Report 'device not found' as infra failures. See http://crbug.com/493900
       print 'Exception in AndroidShell.InitShell:\n%s' % str(e)
       if e.is_infra_error or 'error: device not found' in str(e):
-        return constants.INFRA_EXIT_CODE
-      return constants.ERROR_EXIT_CODE
+        return exit_codes.INFRA
+      return exit_codes.ERROR
 
     return 0
 
   def _GetProcessId(self, process):
     '''Returns the process id of the process on the remote device.'''
     while True:
       line = process.stdout.readline()
       pid_command = 'launcher waiting for GDB. pid: '
       index = line.find(pid_command)
       if index != -1:
         return line[index + len(pid_command):].strip()
     return 0
 
   def _GetLocalGdbPath(self):
     '''Returns the path to the android gdb.'''
-    if self.config.target_cpu == 'arm':
-      return os.path.join(constants.ANDROID_NDK_ROOT, 'toolchains',
-                          'arm-linux-androideabi-4.9', 'prebuilt',
-                          'linux-x86_64', 'bin', 'arm-linux-androideabi-gdb')
-    elif self.config.target_cpu == 'x86':
-      return os.path.join(constants.ANDROID_NDK_ROOT, 'toolchains',
-                          'x86-4.9', 'prebuilt', 'linux-x86_64', 'bin',
-                          'i686-linux-android-gdb')
-    elif self.config.target_cpu == 'x64':
-      return os.path.join(constants.ANDROID_NDK_ROOT, 'toolchains',
-                          'x86_64-4.9', 'prebuilt', 'linux-x86_64', 'bin',
-                          'x86_64-linux-android-gdb')
-    else:
+    if self.config.target_cpu not in ('arm', 'x86', 'x64'):
       raise Exception('Unknown target_cpu: %s' % self.config.target_cpu)
+    return binary_manager.FetchPath('gdb', self.config.target_cpu, 'android')
 
   def _WaitForProcessIdAndStartGdb(self, process):
     '''
     Waits until we see the process id from the remote device, starts up
     gdbserver on the remote device, and gdb on the local device.
     '''
     # Wait until we see 'PID'
     pid = self._GetProcessId(process)
     assert pid != 0
     # No longer need the logcat process.
@@ skipping 114 matching lines @@
              'gdb is in the directory %s\\n'
              'The following functions have been defined:\\n'
              'reload-symbols: forces reloading symbols. If after a crash you\\n'
              'still do not see symbols you likely need to create a link in\\n'
              'the directory you are in.\\n'
              'info-symbols: shows status of current shared libraries.\\n'
              'NOTE: you may need to type reload-symbols again after a '
              'crash.\\n\\n' % (tmp_dir, build_dir, tmp_dir))
   with open(gdb_init_path, 'w') as f:
     f.write(gdbinit)