get provision_devices to not fall over on user builds

build/android/provision_devices.py

 #!/usr/bin/env python
 #
 # Copyright (c) 2013 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.
 
 """Provisions Android devices with settings required for bots.
 
 Usage:
   ./provision_devices.py [-d <device serial number>]
 """
 
 import argparse
 import datetime
 import json
 import logging
 import os
 import posixpath
 import re
 import subprocess
 import sys
 import time
 
 from devil.android import battery_utils
 from devil.android import device_blacklist
 from devil.android import device_errors
 from devil.android import device_temp_file
 from devil.android import device_utils
+from devil.android.sdk import keyevent
 from devil.android.sdk import version_codes
 from devil.utils import run_tests_helper
 from devil.utils import timeout_retry
 from pylib import constants
 from pylib import device_settings
 
 _SYSTEM_WEBVIEW_PATHS = ['/system/app/webview', '/system/app/WebViewGoogle']
 _CHROME_PACKAGE_REGEX = re.compile('.*chrom.*')
 _TOMBSTONE_REGEX = re.compile('tombstone.*')
 
@@ skipping 57 matching lines @@
     except device_errors.CommandTimeoutError:
       logging.error('Device did not finish booting. Will try to reboot.')
       device.Reboot(timeout=reboot_timeout)
     phase_func(device, options)
     if reboot:
       device.Reboot(False, retries=0)
       device.adb.WaitForDevice()
 
   try:
     if should_run_phase(_PHASES.WIPE):
-      if options.chrome_specific_wipe:
+      if device.IsUserBuild():

[jbudorick, 2015/11/21 02:37:13]

This shouldn't preempt the chrome-specific wipe, which we should be able to do
in user builds.

[bpastene, 2015/11/23 20:01:50]

Not entirely. I moved what I could into an if_user_build check in WipeChromeData

+        logging.warning('Cannot wipe data in user builds.')
+      elif options.chrome_specific_wipe:
         run_phase(WipeChromeData)
       else:
         run_phase(WipeDevice)
 
     if should_run_phase(_PHASES.PROPERTIES):
       run_phase(SetProperties)
 
     if should_run_phase(_PHASES.FINISH):
       run_phase(FinishProvisioning, reboot=False)
 
@@ skipping 122 matching lines @@
   device.RunShellCommand(['restorecon', constants.ADB_KEYS_FILE],
                          as_root=True, check_return=True)
 
 
 def SetProperties(device, options):
   try:
     device.EnableRoot()
   except device_errors.CommandFailedError as e:
     logging.warning(str(e))
 
-  _ConfigureLocalProperties(device, options.enable_java_debug)
+  if not device.IsUserBuild():
+    _ConfigureLocalProperties(device, options.enable_java_debug)
+  else:
+    logging.warning('Cannot configure properties in user builds.')
   device_settings.ConfigureContentSettings(
       device, device_settings.DETERMINISTIC_DEVICE_SETTINGS)
   if options.disable_location:
     device_settings.ConfigureContentSettings(
         device, device_settings.DISABLE_LOCATION_SETTINGS)
   else:
     device_settings.ConfigureContentSettings(
         device, device_settings.ENABLE_LOCATION_SETTINGS)
 
   if options.disable_mock_location:
@@ skipping 44 matching lines @@
         '\n'.join(local_props), as_root=True)
     # Android will not respect the local props file if it is world writable.
     device.RunShellCommand(
         ['chmod', '644', device.LOCAL_PROPERTIES_PATH],
         as_root=True, check_return=True)
   except device_errors.CommandFailedError:
     logging.exception('Failed to configure local properties.')
 
 
 def FinishProvisioning(device, options):
+  # The lockscreen can't be disabled on user builds, so send a keyevent
+  # to unlock it.
+  if device.IsUserBuild():
+    device.SendKeyEvent(keyevent.KEYCODE_MENU)
+
   if options.min_battery_level is not None:
     try:
       battery = battery_utils.BatteryUtils(device)
       battery.ChargeDeviceToLevel(options.min_battery_level)
     except device_errors.CommandFailedError:
       logging.exception('Unable to charge device to specified level.')
 
   if options.max_battery_temp is not None:
     try:
       battery = battery_utils.BatteryUtils(device)
@@ skipping 20 matching lines @@
     tdelta = (correct_time - device_time).seconds
     if tdelta <= 1:
       logging.info('Date/time successfully set on %s', device)
       return True
     else:
       logging.error('Date mismatch. Device: %s Correct: %s',
                     device_time.isoformat(), correct_time.isoformat())
       return False
 
   # Sometimes the date is not set correctly on the devices. Retry on failure.
-  if not timeout_retry.WaitFor(_set_and_verify_date, wait_period=1,
-                               max_tries=2):
+  # TODO(bpastene): Figure out how to set the date & time on user builds.
+  if not device.IsUserBuild() and not timeout_retry.WaitFor(

[jbudorick, 2015/11/21 02:37:13]

nit: since this is going to be changed when you figure out how to set the date &
time on user builds, I'd prefer this be

  if device.IsUserBuild():
    # TODO(bpastene): ...
    pass
  else:
    if not timeout_retry.WaitFor(_set_and_verify_date, ...):
      raise device_errors.CommandFailedError(...)

which I think is more readable.

[bpastene, 2015/11/23 20:01:50]

Done.

+      _set_and_verify_date, wait_period=1, max_tries=2):
     raise device_errors.CommandFailedError(
         'Failed to set date & time.', device_serial=str(device))
 
   props = device.RunShellCommand('getprop', check_return=True)
   for prop in props:
     logging.info('  %s', prop)
   if options.auto_reconnect:
     _PushAndLaunchAdbReboot(device, options.target)
 
 
@@ skipping 120 matching lines @@
   args = parser.parse_args()
   constants.SetBuildType(args.target)
 
   run_tests_helper.SetLogLevel(args.verbose)
 
   return ProvisionDevices(args)
 
 
 if __name__ == '__main__':
   sys.exit(main())