[android] Make build_type a singleton.

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.
 """
 
@@ skipping 82 matching lines @@
     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, build_type):
+  def __init__(self, ready_event, arguments, adb, 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.
       tool: instance of runtime error detection tool.
-      build_type: 'Release' or 'Debug'.
     """
     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.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
     self.command_line = []
-    self.build_type = build_type
 
   def _WaitToStartAndGetPortFromTestServer(self):
     """Waits for the Python test server to start and gets the port it is using.
 
     The port information is passed by the Python test server with a pipe given
     by self.pipe_out. It is written as a result to |self.host_port|.
 
     Returns:
       Whether the port used by the test server was successfully fetched.
     """
@@ skipping 102 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.build_type, self.tool)
+      Forwarder.Map([(0, self.host_port)], self.adb, constants.GetBuildType(),
+                    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):
         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)
@@ skipping 61 matching lines @@
       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.tool,
-        self.server.build_type)
+        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)
     else:
@@ skipping 46 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, build_type):
+  def __init__(self, test_server_spawner_port, adb, 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.tool = tool
     self.server.test_server_instance = None
-    self.server.build_type = build_type
+    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."""
     listener_thread = threading.Thread(target=self._Listen)
     listener_thread.setDaemon(True)
     listener_thread.start()
 
   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