Revert of [Android] Add --blacklist-file as a command-line option.

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 30 matching lines @@
 
 
 class _PHASES(object):
   WIPE = 'wipe'
   PROPERTIES = 'properties'
   FINISH = 'finish'
 
   ALL = [WIPE, PROPERTIES, FINISH]
 
 
-def ProvisionDevices(args):
-  if args.blacklist_file:
-    blacklist = device_blacklist.Blacklist(args.blacklist_file)
-  else:
-    # TODO(jbudorick): Remove once the bots have switched over.
-    blacklist = device_blacklist.Blacklist(device_blacklist.BLACKLIST_JSON)
-
-  devices = device_utils.DeviceUtils.HealthyDevices(blacklist)
-  if args.device:
-    devices = [d for d in devices if d == args.device]
+def ProvisionDevices(options):
+  devices = device_utils.DeviceUtils.HealthyDevices()
+  if options.device:
+    devices = [d for d in devices if d == options.device]
     if not devices:
-      raise device_errors.DeviceUnreachableError(args.device)
+      raise device_errors.DeviceUnreachableError(options.device)
 
   parallel_devices = device_utils.DeviceUtils.parallel(devices)
-  parallel_devices.pMap(ProvisionDevice, blacklist, args)
-  if args.auto_reconnect:
+  parallel_devices.pMap(ProvisionDevice, options)
+  if options.auto_reconnect:
     _LaunchHostHeartbeat()
-  blacklisted_devices = blacklist.Read()
-  if args.output_device_blacklist:
-    with open(args.output_device_blacklist, 'w') as f:
-      json.dump(blacklisted_devices, f)
-  if all(d in blacklisted_devices for d in devices):
+  blacklist = device_blacklist.ReadBlacklist()
+  if options.output_device_blacklist:
+    with open(options.output_device_blacklist, 'w') as f:
+      json.dump(blacklist, f)
+  if all(d in blacklist for d in devices):
     raise device_errors.NoDevicesError
   return 0
 
 
-def ProvisionDevice(device, blacklist, options):
+def ProvisionDevice(device, options):
   if options.reboot_timeout:
     reboot_timeout = options.reboot_timeout
   elif (device.build_version_sdk >=
         constants.ANDROID_SDK_VERSION_CODES.LOLLIPOP):
     reboot_timeout = _DEFAULT_TIMEOUTS.LOLLIPOP
   else:
     reboot_timeout = _DEFAULT_TIMEOUTS.PRE_LOLLIPOP
 
   def should_run_phase(phase_name):
     return not options.phases or phase_name in options.phases
@@ skipping 15 matching lines @@
 
     if should_run_phase(_PHASES.PROPERTIES):
       run_phase(SetProperties)
 
     if should_run_phase(_PHASES.FINISH):
       run_phase(FinishProvisioning, reboot=False)
 
   except device_errors.CommandTimeoutError:
     logging.exception('Timed out waiting for device %s. Adding to blacklist.',
                       str(device))
-    blacklist.Extend([str(device)])
+    device_blacklist.ExtendBlacklist([str(device)])
 
   except device_errors.CommandFailedError:
     logging.exception('Failed to provision device %s. Adding to blacklist.',
                       str(device))
-    blacklist.Extend([str(device)])
+    device_blacklist.ExtendBlacklist([str(device)])
 
 
 def WipeDevice(device, options):
   """Wipes data from device, keeping only the adb_keys for authorization.
 
   After wiping data on a device that has been authorized, adb can still
   communicate with the device, but after reboot the device will need to be
   re-authorized because the adb keys file is stored in /data/misc/adb/.
   Thus, adb_keys file is rewritten so the device does not need to be
   re-authorized.
@@ skipping 181 matching lines @@
   # --min-battery-level 95
   #     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.
 
   parser = argparse.ArgumentParser(
       description='Provision Android devices with settings required for bots.')
   parser.add_argument('-d', '--device', metavar='SERIAL',
                       help='the serial number of the device to be provisioned'
                       ' (the default is to provision all devices attached)')
-  parser.add_argument('--blacklist-file', help='Device blacklist JSON file.')
   parser.add_argument('--phase', action='append', choices=_PHASES.ALL,
                       dest='phases',
                       help='Phases of provisioning to run. '
                            '(If omitted, all phases will be run.)')
   parser.add_argument('--skip-wipe', action='store_true', default=False,
                       help="don't wipe device data during provisioning")
   parser.add_argument('--reboot-timeout', metavar='SECS', type=int,
                       help='when wiping the device, max number of seconds to'
                       ' wait after each reboot '
                       '(default: %s)' % _DEFAULT_TIMEOUTS.HELP_TEXT)
@@ skipping 27 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())