Allow test_runner.py to run host perf tests without devices attached

build/android/pylib/local/device/local_device_environment.py

 # Copyright 2014 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.
 
 import datetime
 import functools
 import logging
 import os
 import shutil
 import tempfile
@@ skipping 62 matching lines @@
 
 class LocalDeviceEnvironment(environment.Environment):
 
   def __init__(self, args, _error_func):
     super(LocalDeviceEnvironment, self).__init__()
     self._blacklist = (device_blacklist.Blacklist(args.blacklist_file)
                        if args.blacklist_file
                        else None)
     self._device_serial = args.test_device
     self._devices_lock = threading.Lock()
-    self._devices = []
+    self._devices = None
     self._concurrent_adb = args.enable_concurrent_adb
     self._enable_device_cache = args.enable_device_cache
     self._logcat_monitors = []
     self._logcat_output_dir = args.logcat_output_dir
     self._logcat_output_file = args.logcat_output_file
     self._max_tries = 1 + args.num_retries
     self._skip_clear_data = args.skip_clear_data
     self._target_devices_file = args.target_devices_file
     self._tool_name = args.tool
 
   #override
   def SetUp(self):
+    pass
+
+  def _InitDevices(self):
     device_arg = 'default'
     if self._target_devices_file:
       device_arg = device_list.GetPersistentDeviceList(
           self._target_devices_file)
       if not device_arg:
         logging.warning('No target devices specified. Falling back to '
                         'running on all available devices.')
         device_arg = 'default'
       else:
         logging.info(
@@ skipping 36 matching lines @@
   @property
   def blacklist(self):
     return self._blacklist
 
   @property
   def concurrent_adb(self):
     return self._concurrent_adb
 
   @property
   def devices(self):
+    # Initialize lazily so that host-only tests do not fail when no devices are
+    # attached.
+    if self._devices is None:
+      self._InitDevices()
     if not self._devices:
       raise device_errors.NoDevicesError()
     return self._devices
 
   @property
   def max_tries(self):
     return self._max_tries
 
   @property
   def parallel_devices(self):
     return parallelizer.SyncParallelizer(self.devices)
 
   @property
   def skip_clear_data(self):
     return self._skip_clear_data
 
   @property
   def tool(self):
     return self._tool_name
 
   #override
   def TearDown(self):
+    if self._devices is None:
+      return
     @handle_shard_failures_with(on_failure=self.BlacklistDevice)
     def tear_down_device(d):
       # Write the cache even when not using it so that it will be ready the
       # first time that it is enabled. Writing it every time is also necessary
       # so that an invalid cache can be flushed just by disabling it for one
       # run.
       cache_path = _DeviceCachePath(d)
       with open(cache_path, 'w') as f:
         f.write(d.DumpCacheData())
         logging.info('Wrote device cache: %s', cache_path)
@@ skipping 24 matching lines @@
            if os.path.exists(m.output_file)])
       shutil.rmtree(self._logcat_output_dir)
 
   def BlacklistDevice(self, device, reason='local_device_failure'):
     device_serial = device.adb.GetDeviceSerial()
     if self._blacklist:
       self._blacklist.Extend([device_serial], reason=reason)
     with self._devices_lock:
       self._devices = [d for d in self._devices if str(d) != device_serial]