[Android] Change object types from AndroidCommands to DeviceUtils in build/android/.

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.
 """
 # pylint: disable=W0702
@@ skipping 59 matching lines @@
   Args:
     port: the port number.
     expected_status: boolean of expected status.
 
   Returns:
     Returns True if the status is expected. Otherwise returns False.
   """
   return _WaitUntil(lambda: ports.IsHostPortUsed(port) == expected_status)
 
 
-def _CheckDevicePortStatus(adb, port):
+def _CheckDevicePortStatus(device, port):
   """Returns whether the provided port is used."""
-  return _WaitUntil(lambda: ports.IsDevicePortUsed(adb, port))
+  return _WaitUntil(lambda: ports.IsDevicePortUsed(device, 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.
   """
   if server_type not in SERVER_TYPES:
     raise NotImplementedError('Unknown server type: %s' % server_type)
   if server_type == 'udpecho':
     raise Exception('Please do not run UDP echo tests because we do not have '
                     'a UDP forwarder tool.')
   return SERVER_TYPES[server_type]
 
 
 class TestServerThread(threading.Thread):
   """A thread to run the test server in a separate process."""
 
-  def __init__(self, ready_event, arguments, adb, tool):
+  def __init__(self, ready_event, arguments, device, tool):
     """Initialize TestServerThread with the following argument.
 
     Args:
       ready_event: event which will be set when the test server is ready.
       arguments: dictionary of arguments to run the test server.
-      adb: instance of AndroidCommands.
+      device: An instance of DeviceUtils.
       tool: instance of runtime error detection tool.
     """
     threading.Thread.__init__(self)
     self.wait_event = threading.Event()
     self.stop_flag = False
     self.ready_event = ready_event
     self.ready_event.clear()
     self.arguments = arguments
-    self.adb = adb
+    self.device = device
     self.tool = tool
     self.test_server_process = None
     self.is_ready = False
     self.host_port = self.arguments['port']
     assert isinstance(self.host_port, int)
     # The forwarder device port now is dynamically allocated.
     self.forwarder_device_port = 0
     # Anonymous pipe in order to get port info from test server.
     self.pipe_in = None
     self.pipe_out = None
@@ skipping 114 matching lines @@
                               'testserver.py')] + self.command_line
     logging.info('Running: %s', command)
     self.process = subprocess.Popen(
         command, preexec_fn=self._CloseUnnecessaryFDsForTestServerProcess)
     if self.process:
       if self.pipe_out:
         self.is_ready = self._WaitToStartAndGetPortFromTestServer()
       else:
         self.is_ready = _CheckPortStatus(self.host_port, True)
     if self.is_ready:
-      Forwarder.Map([(0, self.host_port)], self.adb, self.tool)
+      Forwarder.Map([(0, self.host_port)], self.device, self.tool)
       # Check whether the forwarder is ready on the device.
       self.is_ready = False
       device_port = Forwarder.DevicePortForHostPort(self.host_port)
-      if device_port and _CheckDevicePortStatus(self.adb, device_port):
+      if device_port and _CheckDevicePortStatus(self.device, 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.
     _WaitUntil(lambda: self.stop_flag, max_attempts=sys.maxint)
     if self.process.poll() is None:
       self.process.kill()
-    Forwarder.UnmapDevicePort(self.forwarder_device_port, self.adb)
+    Forwarder.UnmapDevicePort(self.forwarder_device_port, self.device)
     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
       self.pipe_out = None
     logging.info('Test-server has died.')
     self.wait_event.set()
 
@@ skipping 47 matching lines @@
     except:
       raise Exception('Bad content-length for start request.')
     logging.info(content_length)
     test_server_argument_json = self.rfile.read(content_length)
     logging.info(test_server_argument_json)
     assert not self.server.test_server_instance
     ready_event = threading.Event()
     self.server.test_server_instance = TestServerThread(
         ready_event,
         json.loads(test_server_argument_json),
-        self.server.adb,
+        self.server.device,
         self.server.tool)
     self.server.test_server_instance.setDaemon(True)
     self.server.test_server_instance.start()
     ready_event.wait()
     if self.server.test_server_instance.is_ready:
       self._SendResponse(200, 'OK', {}, json.dumps(
           {'port': self.server.test_server_instance.forwarder_device_port,
            'message': 'started'}))
       logging.info('Test server is running on port: %d.',
                    self.server.test_server_instance.host_port)
@@ skipping 47 matching lines @@
       self._SendResponse(200, 'OK', {}, 'ready')
       logging.info('Handled ping request and sent response.')
     else:
       self._SendResponse(400, 'Unknown request', {}, '')
       logging.info('Encounter unknown request: %s.', action)
 
 
 class SpawningServer(object):
   """The class used to start/stop a http server."""
 
-  def __init__(self, test_server_spawner_port, adb, tool):
+  def __init__(self, test_server_spawner_port, device, tool):
     logging.info('Creating new spawner on port: %d.', test_server_spawner_port)
     self.server = BaseHTTPServer.HTTPServer(('', test_server_spawner_port),
                                             SpawningServerRequestHandler)
-    self.server.adb = adb
+    self.server.device = device
     self.server.tool = tool
     self.server.test_server_instance = None
     self.server.build_type = constants.GetBuildType()
 
   def _Listen(self):
     logging.info('Starting test server spawner')
     self.server.serve_forever()
 
   def Start(self):
     """Starts the test server spawner."""
@@ skipping 11 matching lines @@
 
   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