Upstream test sharder.

build/android/emulator.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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.
 
 """Provides an interface to start and stop Android emulator.
 
 Assumes system environment ANDROID_NDK_ROOT has been set.
 
   Emulator: The class provides the methods to launch/shutdown the emulator with
@@ skipping 118 matching lines @@
     self.emulator = os.path.join(android_sdk_root, 'tools', 'emulator')
     self.popen = None
     self.device = None
     self.fast_and_loose = fast_and_loose
 
   def _DeviceName(self):
     """Return our device name."""
     port = _GetAvailablePort()
     return ('emulator-%d' % port, port)
 
-  def Launch(self):
-    """Launches the emulator and waits for package manager to startup.
+  def Launch(self, kill_all_emulators):
+    """Launches the emulator asynchronously. Call ConfirmLaunch() to ensure the
+    emulator is ready for use.
 
     If fails, an exception will be raised.
     """
-    _KillAllEmulators()  # just to be sure
+    if kill_all_emulators:
+      _KillAllEmulators()  # just to be sure
     if not self.fast_and_loose:
       self._AggressiveImageCleanup()
     (self.device, port) = self._DeviceName()
     emulator_command = [
         self.emulator,
         # Speed up emulator launch by 40%.  Really.
         '-no-boot-anim',
         # The default /data size is 64M.
         # That's not enough for 4 unit test bundles and their data.
         '-partition-size', '256',
         # Use a familiar name and port.
         '-avd', 'buildbot',
         '-port', str(port)]
     if not self.fast_and_loose:
       emulator_command.extend([
           # Wipe the data.  We've seen cases where an emulator
           # gets 'stuck' if we don't do this (every thousand runs or
           # so).
           '-wipe-data',
           ])
     logging.info('Emulator launch command: %s', ' '.join(emulator_command))
     self.popen = subprocess.Popen(args=emulator_command,
                                   stderr=subprocess.STDOUT)
     self._InstallKillHandler()
-    self._ConfirmLaunch()
 
   def _AggressiveImageCleanup(self):
     """Aggressive cleanup of emulator images.
 
     Experimentally it looks like our current emulator use on the bot
     leaves image files around in /tmp/android-$USER.  If a "random"
     name gets reused, we choke with a 'File exists' error.
     TODO(jrg): is there a less hacky way to accomplish the same goal?
     """
     logging.info('Aggressive Image Cleanup')
     emulator_imagedir = '/tmp/android-%s' % os.environ['USER']
     if not os.path.exists(emulator_imagedir):
       return
     for image in os.listdir(emulator_imagedir):
       full_name = os.path.join(emulator_imagedir, image)
       if 'emulator' in full_name:
         logging.info('Deleting emulator image %s', full_name)
         os.unlink(full_name)
 
-  def _ConfirmLaunch(self, wait_for_boot=False):
+  def ConfirmLaunch(self, wait_for_boot=False):
     """Confirm the emulator launched properly.
 
     Loop on a wait-for-device with a very small timeout.  On each
     timeout, check the emulator process is still alive.
     After confirming a wait-for-device can be successful, make sure
     it returns the right answer.
     """
     a = android_commands.AndroidCommands(self.device, False)
     seconds_waited = 0
     number_of_waits = 2  # Make sure we can wfd twice
@@ skipping 44 matching lines @@
     """Install a handler to kill the emulator when we exit unexpectedly."""
     for sig in self._SIGNALS:
       signal.signal(sig, self._ShutdownOnSignal)
 
 def main(argv):
   Emulator().launch()
 
 
 if __name__ == '__main__':
   main(sys.argv)