[Android] Don't use a device blacklist if one isn't provided. (RELAND 2)

build/android/buildbot/bb_device_status_check.py

 #!/usr/bin/env python
 #
 # Copyright 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.
 
 """A class to keep track of devices across builds and report state."""
 
 import argparse
 import json
@@ skipping 37 matching lines @@
       except (psutil.NoSuchProcess, psutil.AccessDenied):
         pass
   for p in GetAllAdb():
     try:
       logging.error('Unable to kill %d (%s [%s])', p.pid, p.name,
                     ' '.join(p.cmdline))
     except (psutil.NoSuchProcess, psutil.AccessDenied):
       pass
 
 
+def _IsBlacklisted(serial, blacklist):
+  return blacklist and serial in blacklist.Read()
+
+
 def _BatteryStatus(device, blacklist):
   battery_info = {}
   try:
     battery = battery_utils.BatteryUtils(device)
     battery_info = battery.GetBatteryInfo(timeout=5)
     battery_level = int(battery_info.get('level', 100))
 
     if battery_level < 15:
       logging.error('Critically low battery level (%d)', battery_level)
       battery = battery_utils.BatteryUtils(device)
@@ skipping 63 matching lines @@
         else 'unknown')
     usb_status = bool(serial in usb_devices)
 
     device_status = {
       'serial': serial,
       'adb_status': adb_status,
       'usb_status': usb_status,
     }
 
     if adb_status == 'device':
-      if not serial in blacklist.Read():
+      if not _IsBlacklisted(serial, blacklist):
         try:
           build_product = device.build_product
           build_id = device.build_id
           build_fingerprint = device.GetProp('ro.build.fingerprint', cache=True)
           wifi_ip = device.GetProp('dhcp.wlan0.ipaddress')
           battery_info = _BatteryStatus(device, blacklist)
           imei_slice = _IMEISlice(device)
 
           if (device.product_name == 'mantaray' and
               battery_info.get('AC powered', None) != 'true'):
@@ skipping 21 matching lines @@
 
         except device_errors.CommandTimeoutError:
           logging.exception('Timeout while getting device status for %s.',
                             str(device))
           if blacklist:
             blacklist.Extend([serial])
 
     elif blacklist:
       blacklist.Extend([serial])
 
-    device_status['blacklisted'] = serial in blacklist.Read()
+    device_status['blacklisted'] = _IsBlacklisted(serial, blacklist)
 
     return device_status
 
   parallel_devices = device_utils.DeviceUtils.parallel(devices)
   statuses = parallel_devices.pMap(blacklisting_device_status).pGet(None)
   return statuses
 
 
 def RecoverDevices(devices, blacklist):
   """Attempts to recover any inoperable devices in the provided list.
@@ skipping 22 matching lines @@
   logging.debug('Should restart USB for:')
   for d in should_restart_usb:
     logging.debug('  %s', d)
   logging.debug('Should restart ADB for:')
   for d in should_restart_adb:
     logging.debug('  %s', d)
   logging.debug('Should reboot:')
   for d in should_reboot_device:
     logging.debug('  %s', d)
 
-  blacklist.Reset()
+  if blacklist:
+    blacklist.Reset()
 
   if should_restart_adb:
     KillAllAdb()
   for serial in should_restart_usb:
     try:
       reset_usb.reset_android_usb(serial)
     except (IOError, device_errors.DeviceUnreachableError):
       logging.exception('Unable to reset USB for %s.', serial)
       if blacklist:
         blacklist.Extend([serial])
 
   def blacklisting_recovery(device):
-    if blacklist and device.adb.GetDeviceSerial() in blacklist.Read():
+    if _IsBlacklisted(device.adb.GetDeviceSerial(), blacklist):
       logging.debug('%s is blacklisted, skipping recovery.', str(device))
       return
 
     if device in should_reboot_device:
       try:
         device.WaitUntilFullyBooted()
         return
       except (device_errors.CommandTimeoutError,
               device_errors.CommandFailedError):
         logging.exception('Failure while waiting for %s. '
@@ skipping 25 matching lines @@
   parser.add_argument('--json-output',
                       help='Output JSON information into a specified file.')
   parser.add_argument('--blacklist-file', help='Device blacklist JSON file.')
   parser.add_argument('-v', '--verbose', action='count', default=1,
                       help='Log more information.')
 
   args = parser.parse_args()
 
   run_tests_helper.SetLogLevel(args.verbose)
 
-  if args.blacklist_file:
-    blacklist = device_blacklist.Blacklist(args.blacklist_file)
-  else:
-    # TODO(jbudorick): Remove this once bots pass the blacklist file.
-    blacklist = device_blacklist.Blacklist(device_blacklist.BLACKLIST_JSON)
+  blacklist = (device_blacklist.Blacklist(args.blacklist_file)
+               if args.blacklist_file
+               else None)
 
   last_devices_path = os.path.join(
       args.out_dir, device_list.LAST_DEVICES_FILENAME)
   try:
     expected_devices = set(
         device_list.GetPersistentDeviceList(last_devices_path))
   except IOError:
     expected_devices = set()
 
   usb_devices = set(lsusb.get_android_devices())
@@ skipping 51 matching lines @@
         except Exception: # pylint: disable=broad-except
           pass
 
   # Dump the device statuses to JSON.
   if args.json_output:
     with open(args.json_output, 'wb') as f:
       f.write(json.dumps(statuses, indent=4))
 
   live_devices = [status['serial'] for status in statuses
                   if (status['adb_status'] == 'device'
-                      and status['serial'] not in blacklist.Read())]
+                      and not _IsBlacklisted(status['serial'], blacklist))]
 
   # If all devices failed, or if there are no devices, it's an infra error.
   return 0 if live_devices else constants.INFRA_EXIT_CODE
 
 
 if __name__ == '__main__':
   sys.exit(main())