"""Finds android browsers that can be controlled by telemetry."""
-import logging as real_logging
+import logging
import os
import re
import subprocess
from telemetry import decorators
from telemetry.core import browser
-from telemetry.core import platform
+from telemetry.core import exceptions
from telemetry.core import possible_browser
+from telemetry.core import platform
from telemetry.core import util
from telemetry.core.backends import adb_commands
+from telemetry.core.platform import android_device
from telemetry.core.backends.chrome import android_browser_backend
-from telemetry.core.platform import android_platform_backend
-from telemetry.core.platform.profiler import monsoon
try:
import psutil # pylint: disable=F0401
['org.chromium.telemetry_shell',
android_browser_backend.WebviewBackendSettings,
None],
+ 'android-webview-shell':
+ ['org.chromium.android_webview.shell',
+ android_browser_backend.WebviewShellBackendSettings,
+ 'AndroidWebView.apk'],
'android-chrome':
['com.google.android.apps.chrome',
android_browser_backend.ChromeBackendSettings,
class PossibleAndroidBrowser(possible_browser.PossibleBrowser):
"""A launchable android browser instance."""
- def __init__(self, browser_type, finder_options, backend_settings, apk_name):
+ def __init__(self, browser_type, finder_options, android_platform,
+ backend_settings, apk_name):
super(PossibleAndroidBrowser, self).__init__(browser_type, 'android',
finder_options, backend_settings.supports_tab_control)
- assert browser_type in FindAllBrowserTypes(), \
+ assert browser_type in FindAllBrowserTypes(finder_options), \
('Please add %s to android_browser_finder.FindAllBrowserTypes' %
browser_type)
+ self._platform = android_platform
+ self._platform_backend = (
+ android_platform._platform_backend # pylint: disable=W0212
+ )
self._backend_settings = backend_settings
self._local_apk = None
newest_apk_path = sorted(candidate_apks)[-1][1]
self._local_apk = newest_apk_path
-
def __repr__(self):
return 'PossibleAndroidBrowser(browser_type=%s)' % self.browser_type
def _InitPlatformIfNeeded(self):
- if self._platform:
- return
-
- self._platform_backend = android_platform_backend.AndroidPlatformBackend(
- self._backend_settings.adb.device(),
- self.finder_options.no_performance_mode)
- self._platform = platform.Platform(self._platform_backend)
+ pass
def Create(self):
self._InitPlatformIfNeeded()
use_rndis_forwarder,
output_profile_path=self.finder_options.output_profile_path,
extensions_to_load=self.finder_options.extensions_to_load,
- target_arch=self.finder_options.target_arch)
- b = browser.Browser(backend, self._platform_backend)
+ target_arch=self.finder_options.target_arch,
+ android_platform_backend=self._platform_backend)
+ b = browser.Browser(backend,
+ self._platform_backend,
+ self._archive_path,
+ self._append_to_existing_wpr,
+ self._make_javascript_deterministic,
+ self._credentials_path)
return b
def SupportsOptions(self, finder_options):
@decorators.Cache
def UpdateExecutableIfNeeded(self):
if self.HaveLocalAPK():
- real_logging.warn(
- 'Refreshing %s on device if needed.' % self._local_apk)
- self._backend_settings.adb.Install(self._local_apk)
+ logging.warn('Installing %s on device if needed.' % self._local_apk)
+ self.platform.InstallApplication(self._local_apk)
def last_modification_time(self):
if self.HaveLocalAPK():
return None
-@decorators.Cache
-def CanFindAvailableBrowsers(logging=real_logging):
+def CanFindAvailableBrowsers():
if not adb_commands.IsAndroidSupported():
logging.info('Android build commands unavailable on this machine. Have '
'you installed Android build dependencies?')
return False
-def FindAllBrowserTypes():
+def FindAllBrowserTypes(_options):
return CHROME_PACKAGE_NAMES.keys()
-def FindAllAvailableBrowsers(finder_options, logging=real_logging):
+def FindAllAvailableBrowsers(finder_options):
"""Finds all the desktop browsers available on this machine."""
- if not CanFindAvailableBrowsers(logging=logging):
+ if not CanFindAvailableBrowsers():
logging.info('No adb command found. ' +
'Will not try searching for Android browsers.')
return []
-
- def _GetDevices():
- if finder_options.android_device:
- return [finder_options.android_device]
- else:
- return adb_commands.GetAttachedDevices()
-
- devices = _GetDevices()
-
- if not devices:
- try:
- m = monsoon.Monsoon(wait=False)
- m.SetUsbPassthrough(1)
- m.SetVoltage(3.8)
- m.SetMaxCurrent(8)
- logging.warn("""
-Monsoon power monitor detected, but no Android devices.
-
-The Monsoon's power output has been enabled. Please now ensure that:
-
- 1. The Monsoon's front and back USB are connected to the host.
- 2. The Device is connected to the Monsoon's main and USB channels.
- 3. The Device is turned on.
-
-Waiting for device...
-""")
- util.WaitFor(_GetDevices, 600)
- devices = _GetDevices()
- if not devices:
- raise IOError()
- except IOError:
- logging.info('No android devices found.')
- return []
-
- if len(devices) > 1:
+ if finder_options.android_device:
+ devices = [android_device.AndroidDevice(finder_options.android_device,
+ finder_options.no_performance_mode)]
+ else:
+ devices = android_device.AndroidDevice.GetAllConnectedDevices()
+
+ if len(devices) == 0:
+ logging.info('No android devices found.')
+ return []
+ elif len(devices) > 1:
logging.warn(
'Multiple devices attached. Please specify one of the following:\n' +
- '\n'.join([' --device=%s' % d for d in devices]))
+ '\n'.join([' --device=%s' % d.device_id for d in devices]))
return []
- device = devices[0]
-
- adb = adb_commands.AdbCommands(device=device)
- # Trying to root the device, if possible.
- if not adb.IsRootEnabled():
- # Ignore result.
- adb.EnableAdbRoot()
+ try:
+ android_platform = platform.GetPlatformForDevice(devices[0])
+ except exceptions.PlatformError:
+ return []
+ # Host side workaround for crbug.com/268450 (adb instability).
+ # The adb server has a race which is mitigated by binding to a single core.
if psutil:
- # Host side workaround for crbug.com/268450 (adb instability).
- # The adb server has a race which is mitigated by binding to a single core.
for proc in psutil.process_iter():
try:
if 'adb' in proc.name:
except (psutil.NoSuchProcess, psutil.AccessDenied):
logging.warn('Failed to set adb process CPU affinity')
- if not os.environ.get('BUILDBOT_BUILDERNAME'):
- # Killing adbd before running tests has proven to make them less likely to
- # flake out during the test. We skip this if Telemetry is running under a
- # buildbot because build/android/test_runner.py wrapper already took care
- # of it before starting the shards.
- adb.RestartAdbdOnDevice()
-
- packages = adb.RunShellCommand('pm list packages')
possible_browsers = []
-
for name, package_info in CHROME_PACKAGE_NAMES.iteritems():
[package, backend_settings, local_apk] = package_info
- b = PossibleAndroidBrowser(
- name,
- finder_options,
- backend_settings(adb, package),
- local_apk)
-
- if 'package:' + package in packages or b.HaveLocalAPK():
+ b = PossibleAndroidBrowser(name,
+ finder_options,
+ android_platform,
+ backend_settings(package),
+ local_apk)
+ if b.platform.CanLaunchApplication(package) or b.HaveLocalAPK():
possible_browsers.append(b)
-
- if possible_browsers:
- installed_prebuilt_tools = adb_commands.SetupPrebuiltTools(adb)
- if not installed_prebuilt_tools:
- logging.error(
- 'Android device detected, however prebuilt android tools could not '
- 'be used. To run on Android you must build them first:\n'
- ' $ ninja -C out/Release android_tools')
- return []
-
return possible_browsers
projects / platform / framework / web / crosswalk.git / blobdiff