[Android] Fix the location prompt flake in provision_devices.

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>]
@@ skipping 17 matching lines @@
 
 sys.path.append(os.path.join(constants.DIR_SOURCE_ROOT,
                              'third_party', 'android_testrunner'))
 import errors
 
 def KillHostHeartbeat():
   ps = subprocess.Popen(['ps', 'aux'], stdout = subprocess.PIPE)
   stdout, _ = ps.communicate()
   matches = re.findall('\\n.*host_heartbeat.*', stdout)
   for match in matches:
-    print 'An instance of host heart beart running... will kill'
+    logging.info('An instance of host heart beart running... will kill')
     pid = re.findall('(\d+)', match)[0]
     subprocess.call(['kill', str(pid)])
 
 
 def LaunchHostHeartbeat():
   # Kill if existing host_heartbeat
   KillHostHeartbeat()
   # Launch a new host_heartbeat
-  print 'Spawning host heartbeat...'
+  logging.info('Spawning host heartbeat...')
   subprocess.Popen([os.path.join(constants.DIR_SOURCE_ROOT,
                                  'build/android/host_heartbeat.py')])
 
 
 def PushAndLaunchAdbReboot(devices, target):
   """Pushes and launches the adb_reboot binary on the device.
 
   Arguments:
     devices: The list of serial numbers of the device to which the
              adb_reboot binary should be pushed.
     target : The build target (example, Debug or Release) which helps in
              locating the adb_reboot binary.
   """
   for device_serial in devices:
-    print 'Will push and launch adb_reboot on %s' % device_serial
+    logging.info('Will push and launch adb_reboot on %s' % device_serial)
     device = device_utils.DeviceUtils(device_serial)
     # Kill if adb_reboot is already running.
     try:
       # Don't try to kill adb_reboot more than once. We don't expect it to be
       # running at all.
       device.KillAll('adb_reboot', blocking=True, timeout=2, retries=0)
     except device_errors.CommandFailedError:
       # We can safely ignore the exception because we don't expect adb_reboot
       # to be running.
       pass
     # Push adb_reboot
-    print '  Pushing adb_reboot ...'
+    logging.info('  Pushing adb_reboot ...')
     adb_reboot = os.path.join(constants.DIR_SOURCE_ROOT,
                               'out/%s/adb_reboot' % target)
     device.PushChangedFiles(adb_reboot, '/data/local/tmp/')
     # Launch adb_reboot
-    print '  Launching adb_reboot ...'
+    logging.info('  Launching adb_reboot ...')
     device.old_interface.GetAndroidToolStatusAndOutput(
         '/data/local/tmp/adb_reboot')
   LaunchHostHeartbeat()
 
 
 def _ConfigureLocalProperties(device, is_perf):
   """Set standard readonly testing device properties prior to reboot."""
   local_props = [
       'ro.monkey=1',
       'ro.test_harness=1',
@@ skipping 63 matching lines @@
     except errors.DeviceUnresponsiveError:
       pass
     for device_serial in devices_to_reboot:
       device.WaitUntilFullyBooted(timeout=90)
 
 
 def ProvisionDevice(device_serial, is_perf, disable_location):
   device = device_utils.DeviceUtils(device_serial)
   device.old_interface.EnableAdbRoot()
   _ConfigureLocalProperties(device, is_perf)
-  device_settings_map = device_settings.DETERMINISTIC_DEVICE_SETTINGS
+  device_settings.ConfigureContentSettings(
+      device, device_settings.DETERMINISTIC_DEVICE_SETTINGS)
   if disable_location:
-    device_settings_map.update(device_settings.DISABLE_LOCATION_SETTING)
+    device_settings.ConfigureContentSettings(
+        device, device_settings.DISABLE_LOCATION_SETTINGS)
   else:
-    device_settings_map.update(device_settings.ENABLE_LOCATION_SETTING)
-  device_settings.ConfigureContentSettingsDict(device, device_settings_map)
+    device_settings.ConfigureContentSettings(
+        device, device_settings.ENABLE_LOCATION_SETTINGS)
   device_settings.SetLockScreenSettings(device)
   if is_perf:
     # TODO(tonyg): We eventually want network on. However, currently radios
     # can cause perfbots to drain faster than they charge.
-    device_settings.ConfigureContentSettingsDict(
+    device_settings.ConfigureContentSettings(
       device, device_settings.NETWORK_DISABLED_SETTINGS)
     # Some perf bots run benchmarks with USB charging disabled which leads
     # to gradual draining of the battery. We must wait for a full charge
     # before starting a run in order to keep the devices online.
     try:
       battery_info = device.old_interface.GetBatteryInfo()
     except Exception as e:
       battery_info = {}
       logging.error('Unable to obtain battery info for %s, %s',
                     device_serial, e)
@@ skipping 23 matching lines @@
 
   # Wipe devices (unless --skip-wipe was specified)
   if not options.skip_wipe:
     WipeDevicesIfPossible(devices)
 
   bad_devices = []
   # Provision devices
   for device_serial in devices:
     try:
       ProvisionDevice(device_serial, is_perf, options.disable_location)
-    except errors.WaitForResponseTimedOutError:
+    except (errors.WaitForResponseTimedOutError,
+            device_errors.CommandTimeoutError):
       logging.info('Timed out waiting for device %s. Adding to blacklist.',
                    device_serial)
       bad_devices.append(device_serial)
       # Device black list is reset by bb_device_status_check.py per build.
       device_blacklist.ExtendBlacklist([device_serial])
+    except device_errors.CommandFailedError:
+      logging.info('Failed to provision device %s. Adding to blacklist.',
+                   device_serial)
+      bad_devices.append(device_serial)
+      device_blacklist.ExtendBlacklist([device_serial])
   devices = [device for device in devices if device not in bad_devices]
 
   # If there are no good devices
   if not devices:
     raise device_errors.NoDevicesError
 
   try:
     device_utils.DeviceUtils.parallel(devices).Reboot(True)
   except errors.DeviceUnresponsiveError:
     pass
 
   bad_devices = []
   for device_serial in devices:
     device = device_utils.DeviceUtils(device_serial)
     try:
       device.WaitUntilFullyBooted(timeout=90)
       (_, prop) = device.old_interface.GetShellCommandStatusAndOutput('getprop')
       for p in prop:
-        print p
-    except errors.WaitForResponseTimedOutError:
+        logging.info(p)
+    except (errors.WaitForResponseTimedOutError,
+            device_errors.CommandTimeoutError):
       logging.info('Timed out waiting for device %s. Adding to blacklist.',
                    device_serial)
       bad_devices.append(device_serial)
       # Device black list is reset by bb_device_status_check.py per build.
       device_blacklist.ExtendBlacklist([device_serial])
+    except device_errors.CommandFailedError:
+      logging.info('Failed to provision device %s. Adding to blacklist.',
+                   device_serial)
+      bad_devices.append(device_serial)
+      device_blacklist.ExtendBlacklist([device_serial])
   devices = [device for device in devices if device not in bad_devices]
 
   # If there are no good devices
   if not devices:
     raise device_errors.NoDevicesError
 
   if options.auto_reconnect:
     PushAndLaunchAdbReboot(devices, options.target)
 
 
@@ skipping 19 matching lines @@
 
   if args:
     print >> sys.stderr, 'Unused args %s' % args
     return 1
 
   ProvisionDevices(options)
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))