Speedup net_unittests on Android by 30%.

build/android/pylib/chrome_test_server_spawner.py

 # 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 "Test Server Spawner" that handles killing/stopping per-test test servers.
 
 It's used to accept requests from the device to spawn and kill instances of the
 chrome test server on the host.
 """
 
 import BaseHTTPServer
 import json
 import logging
 import os
 import select
 import struct
 import subprocess
+import sys
 import threading
 import time
 import urlparse
 
 import constants
 from forwarder import Forwarder
 import ports
 
 
 # Path that are needed to import necessary modules when launching a testserver.
@@ skipping 10 matching lines @@
     'ftp': '-f',
     'sync': '',  # Sync uses its own script, and doesn't take a server type arg.
     'tcpecho': '--tcp-echo',
     'udpecho': '--udp-echo',
 }
 
 
 # The timeout (in seconds) of starting up the Python test server.
 TEST_SERVER_STARTUP_TIMEOUT = 10
 
+def _WaitUntil(predicate, max_attempts=5):
+  """Blocks until the provided predicate (function) is true.
+
+  Returns:
+    Whether the provided predicate was satisfied once (before the timeout).
+  """
+  sleep_time_sec = 0.025
+  for attempt in xrange(1, max_attempts):
+    if predicate():
+      return True
+    time.sleep(sleep_time_sec)
+    sleep_time_sec = min(1, sleep_time_sec * 2)  # Don't wait more than 1 sec.
+  return False
+
 
 def _CheckPortStatus(port, expected_status):
   """Returns True if port has expected_status.
 
   Args:
     port: the port number.
     expected_status: boolean of expected status.
 
   Returns:
     Returns True if the status is expected. Otherwise returns False.
   """
-  for timeout in range(1, 5):
-    if ports.IsHostPortUsed(port) == expected_status:
-      return True
-    time.sleep(timeout)
-  return False
+  return _WaitUntil(lambda: ports.IsHostPortUsed(port) == expected_status)
+
+
+def _CheckDevicePortStatus(adb, port):
+  """Returns whether the provided port is used."""
+  return _WaitUntil(lambda: ports.IsDevicePortUsed(adb, port))
 
 
 def _GetServerTypeCommandLine(server_type):
   """Returns the command-line by the given server type.
 
   Args:
     server_type: the server type to be used (e.g. 'http').
 
   Returns:
     A string containing the command-line argument.
@@ skipping 149 matching lines @@
       else:
         self.is_ready = _CheckPortStatus(self.host_port, True)
     if self.is_ready:
       self._test_server_forwarder = Forwarder(self.adb, self.build_type)
       self._test_server_forwarder.Run(
           [(0, self.host_port)], self.tool, '127.0.0.1')
       # Check whether the forwarder is ready on the device.
       self.is_ready = False
       device_port = self._test_server_forwarder.DevicePortForHostPort(
           self.host_port)
-      if device_port:
-        for timeout in range(1, 5):
-          if ports.IsDevicePortUsed(self.adb, device_port, 'LISTEN'):
-            self.is_ready = True
-            self.forwarder_device_port = device_port
-            break
-          time.sleep(timeout)
+      if device_port and _CheckDevicePortStatus(self.adb, device_port):
+        self.is_ready = True
+        self.forwarder_device_port = device_port
     # Wake up the request handler thread.
     self.ready_event.set()
     # Keep thread running until Stop() gets called.
-    while not self.stop_flag:
-      time.sleep(1)
+    _WaitUntil(lambda: self.stop_flag, max_attempts=sys.maxint)
     if self.process.poll() is None:
       self.process.kill()
     if self._test_server_forwarder:
       self._test_server_forwarder.Close()
     self.process = None
     self.is_ready = False
     if self.pipe_out:
       os.close(self.pipe_in)
       os.close(self.pipe_out)
       self.pipe_in = None
@@ skipping 139 matching lines @@
 
   def _Listen(self):
     logging.info('Starting test server spawner')
     self.server.serve_forever()
 
   def Start(self):
     """Starts the test server spawner."""
     listener_thread = threading.Thread(target=self._Listen)
     listener_thread.setDaemon(True)
     listener_thread.start()
-    time.sleep(1)
 
   def Stop(self):
     """Stops the test server spawner.
 
     Also cleans the server state.
     """
     self.CleanupState()
     self.server.shutdown()
 
   def CleanupState(self):
     """Cleans up the spawning server state.
 
     This should be called if the test server spawner is reused,
     to avoid sharing the test server instance.
     """
     if self.server.test_server_instance:
       self.server.test_server_instance.Stop()
       self.server.test_server_instance = None