src/tools/telemetry/telemetry/core/backends/chrome/android_browser_finder.py

   1 # Copyright 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 """Finds android browsers that can be controlled by telemetry."""
   6
   7 import os
   8 import logging as real_logging
   9 import re
  10 import subprocess
  11 import sys
  12
  13 from telemetry.core import browser
  14 from telemetry.core import possible_browser
  15 from telemetry.core import util
  16 from telemetry.core.backends import adb_commands
  17 from telemetry.core.backends.chrome import android_browser_backend
  18 from telemetry.core.platform import android_platform_backend
  19
  20 CHROME_PACKAGE_NAMES = {
  21   'android-content-shell':
  22       ['org.chromium.content_shell_apk',
  23        android_browser_backend.ContentShellBackendSettings,
  24        'ContentShell.apk'],
  25   'android-chromium-testshell':
  26       ['org.chromium.chrome.testshell',
  27        android_browser_backend.ChromiumTestShellBackendSettings,
  28        'ChromiumTestShell.apk'],
  29   'android-webview':
  30       ['com.android.webview.chromium.shell',
  31        android_browser_backend.WebviewBackendSettings,
  32        None],
  33   'android-chrome':
  34       ['com.google.android.apps.chrome',
  35        android_browser_backend.ChromeBackendSettings,
  36        'Chrome.apk'],
  37   'android-chrome-beta':
  38       ['com.chrome.beta',
  39        android_browser_backend.ChromeBackendSettings,
  40        None],
  41   'android-chrome-dev':
  42       ['com.google.android.apps.chrome_dev',
  43        android_browser_backend.ChromeBackendSettings,
  44        None],
  45   'android-jb-system-chrome':
  46       ['com.android.chrome',
  47        android_browser_backend.ChromeBackendSettings,
  48        None]
  49 }
  50
  51 ALL_BROWSER_TYPES = CHROME_PACKAGE_NAMES.keys()
  52
  53 # adb shell pm list packages
  54 # adb
  55 # intents to run (pass -D url for the rest)
  56 #   com.android.chrome/.Main
  57 #   com.google.android.apps.chrome/.Main
  58
  59 class PossibleAndroidBrowser(possible_browser.PossibleBrowser):
  60   """A launchable android browser instance."""
  61   def __init__(self, browser_type, finder_options, backend_settings, apk_name):
  62     super(PossibleAndroidBrowser, self).__init__(browser_type, 'android',
  63         finder_options)
  64     assert browser_type in ALL_BROWSER_TYPES, \
  65         'Please add %s to ALL_BROWSER_TYPES' % browser_type
  66     self._backend_settings = backend_settings
  67     self._local_apk = None
  68
  69     chrome_root = util.GetChromiumSrcDir()
  70     if apk_name:
  71       candidate_apks = []
  72       for build_dir, build_type in util.GetBuildDirectories():
  73         apk_full_name = os.path.join(chrome_root, build_dir, build_type, 'apks',
  74                                      apk_name)
  75         if os.path.exists(apk_full_name):
  76           last_changed = os.path.getmtime(apk_full_name)
  77           candidate_apks.append((last_changed, apk_full_name))
  78
  79       if candidate_apks:
  80         # Find the canadidate .apk with the latest modification time.
  81         newest_apk_path = sorted(candidate_apks)[-1][1]
  82         self._local_apk = newest_apk_path
  83
  84
  85   def __repr__(self):
  86     return 'PossibleAndroidBrowser(browser_type=%s)' % self.browser_type
  87
  88   def Create(self):
  89     backend = android_browser_backend.AndroidBrowserBackend(
  90         self.finder_options.browser_options, self._backend_settings,
  91         self.finder_options.android_rndis,
  92         output_profile_path=self.finder_options.output_profile_path,
  93         extensions_to_load=self.finder_options.extensions_to_load)
  94     platform_backend = android_platform_backend.AndroidPlatformBackend(
  95         self._backend_settings.adb.Adb(),
  96         self.finder_options.no_performance_mode)
  97     b = browser.Browser(backend, platform_backend)
  98     return b
  99
 100   def SupportsOptions(self, finder_options):
 101     if len(finder_options.extensions_to_load) != 0:
 102       return False
 103     return True
 104
 105   def HaveLocalAPK(self):
 106     return self._local_apk and os.path.exists(self._local_apk)
 107
 108   def UpdateExecutableIfNeeded(self):
 109     if self.HaveLocalAPK():
 110       real_logging.warn(
 111           'Refreshing %s on device if needed.' % self._local_apk)
 112       self._backend_settings.adb.Install(self._local_apk)
 113
 114   def last_modification_time(self):
 115     if self.HaveLocalAPK():
 116       return os.path.getmtime(self._local_apk)
 117     return -1
 118
 119 def SelectDefaultBrowser(possible_browsers):
 120   local_builds_by_date = sorted(possible_browsers,
 121                                 key=lambda b: b.last_modification_time())
 122
 123   if local_builds_by_date:
 124     newest_browser = local_builds_by_date[-1]
 125     return newest_browser
 126   return None
 127
 128 adb_works = None
 129 def CanFindAvailableBrowsers(logging=real_logging):
 130   if not adb_commands.IsAndroidSupported():
 131     return False
 132
 133   global adb_works
 134
 135   if adb_works == None:
 136     try:
 137       with open(os.devnull, 'w') as devnull:
 138         proc = subprocess.Popen(['adb', 'devices'],
 139                                 stdout=subprocess.PIPE,
 140                                 stderr=subprocess.PIPE,
 141                                 stdin=devnull)
 142         stdout, _ = proc.communicate()
 143         if re.search(re.escape('????????????\tno permissions'), stdout) != None:
 144           logging.warn(
 145               ('adb devices reported a permissions error. Consider '
 146                'restarting adb as root:'))
 147           logging.warn('  adb kill-server')
 148           logging.warn('  sudo `which adb` devices\n\n')
 149         adb_works = True
 150     except OSError:
 151       platform_tools_path = os.path.join(util.GetChromiumSrcDir(),
 152           'third_party', 'android_tools', 'sdk', 'platform-tools')
 153       if (sys.platform.startswith('linux') and
 154           os.path.exists(os.path.join(platform_tools_path, 'adb'))):
 155         os.environ['PATH'] = os.pathsep.join([platform_tools_path,
 156                                               os.environ['PATH']])
 157         adb_works = True
 158       else:
 159         adb_works = False
 160   return adb_works
 161
 162 def FindAllAvailableBrowsers(finder_options, logging=real_logging):
 163   """Finds all the desktop browsers available on this machine."""
 164   if not CanFindAvailableBrowsers(logging=logging):
 165     logging.info('No adb command found. ' +
 166                  'Will not try searching for Android browsers.')
 167     return []
 168
 169   device = None
 170   if finder_options.android_device:
 171     devices = [finder_options.android_device]
 172   else:
 173     devices = adb_commands.GetAttachedDevices()
 174
 175   if len(devices) == 0:
 176     logging.info('No android devices found.')
 177     return []
 178
 179   if len(devices) > 1:
 180     logging.warn(
 181         'Multiple devices attached. Please specify one of the following:\n' +
 182         '\n'.join(['  --device=%s' % d for d in devices]))
 183     return []
 184
 185   device = devices[0]
 186
 187   adb = adb_commands.AdbCommands(device=device)
 188
 189   if sys.platform.startswith('linux'):
 190     # Host side workaround for crbug.com/268450 (adb instability)
 191     # The adb server has a race which is mitigated by binding to a single core.
 192     import psutil  # pylint: disable=F0401
 193     pids  = [p.pid for p in psutil.process_iter() if 'adb' in p.name]
 194     with open(os.devnull, 'w') as devnull:
 195       for pid in pids:
 196         ret = subprocess.call(['taskset', '-p', '-c', '0', str(pid)],
 197                               stdout=subprocess.PIPE,
 198                               stderr=subprocess.PIPE,
 199                               stdin=devnull)
 200         if ret:
 201           logging.warn('Failed to taskset %d (%s)', pid, ret)
 202
 203     if not os.environ.get('BUILDBOT_BUILDERNAME'):
 204       # Killing adbd before running tests has proven to make them less likely to
 205       # flake out during the test. We skip this if Telemetry is running under a
 206       # buildbot because build/android/test_runner.py wrapper already took care
 207       # of it before starting the shards.
 208       adb_commands.CleanupLeftoverProcesses()
 209
 210   packages = adb.RunShellCommand('pm list packages')
 211   possible_browsers = []
 212
 213   for name, package_info in CHROME_PACKAGE_NAMES.iteritems():
 214     [package, backend_settings, local_apk] = package_info
 215     b = PossibleAndroidBrowser(
 216         name,
 217         finder_options,
 218         backend_settings(adb, package),
 219         local_apk)
 220
 221     if 'package:' + package in packages or b.HaveLocalAPK():
 222       possible_browsers.append(b)
 223
 224   if possible_browsers:
 225     installed_prebuilt_tools = adb_commands.SetupPrebuiltTools(adb)
 226     if not installed_prebuilt_tools:
 227       logging.error(
 228           'Android device detected, however prebuilt android tools could not '
 229           'be used. To run on Android you must build them first:\n'
 230           '  $ ninja -C out/Release android_tools')
 231       return []
 232
 233   return possible_browsers