Chromium -> Mojo roll.

build/android/pylib/forwarder.py

 # Copyright (c) 2012 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.
 
 # pylint: disable=W0212
 
 import fcntl
 import logging
 import os
 import psutil
@@ skipping 33 matching lines @@
 
 
 class Forwarder(object):
   """Thread-safe class to manage port forwards from the device to the host."""
 
   _DEVICE_FORWARDER_FOLDER = (constants.TEST_EXECUTABLE_DIR +
                               '/forwarder/')
   _DEVICE_FORWARDER_PATH = (constants.TEST_EXECUTABLE_DIR +
                             '/forwarder/device_forwarder')
   _LOCK_PATH = '/tmp/chrome.forwarder.lock'
-  _MULTIPROCESSING_ENV_VAR = 'CHROME_FORWARDER_USE_MULTIPROCESSING'
   # Defined in host_forwarder_main.cc
   _HOST_FORWARDER_LOG = '/tmp/host_forwarder_log'
 
   _instance = None
 
   @staticmethod
-  def UseMultiprocessing():
-    """Tells the forwarder that multiprocessing is used."""
-    os.environ[Forwarder._MULTIPROCESSING_ENV_VAR] = '1'
-
-  @staticmethod
   def Map(port_pairs, device, tool=None):
     """Runs the forwarder.
 
     Args:
       port_pairs: A list of tuples (device_port, host_port) to forward. Note
                  that you can specify 0 as a device_port, in which case a
                  port will by dynamically assigned on the device. You can
                  get the number of the assigned port using the
                  DevicePortForHostPort method.
       device: A DeviceUtils instance.
@@ skipping 162 matching lines @@
       logging.error('%s exited with %d:\n%s' % (
           instance._host_forwarder_path, exit_code, '\n'.join(output)))
     host_port = instance._device_to_host_port_map[serial_with_port]
     del instance._device_to_host_port_map[serial_with_port]
     del instance._host_to_device_port_map[host_port]
 
   @staticmethod
   def _GetPidForLock():
     """Returns the PID used for host_forwarder initialization.
 
-    In case multi-process sharding is used, the PID of the "sharder" is used.
-    The "sharder" is the initial process that forks that is the parent process.
-    By default, multi-processing is not used. In that case the PID of the
-    current process is returned.
+    The PID of the "sharder" is used to handle multiprocessing. The "sharder"
+    is the initial process that forks that is the parent process.
     """
-    use_multiprocessing = Forwarder._MULTIPROCESSING_ENV_VAR in os.environ
-    return os.getpgrp() if use_multiprocessing else os.getpid()
+    return os.getpgrp()
 
   def _InitHostLocked(self):
     """Initializes the host forwarder daemon.
 
     Note that the global lock must be acquired before calling this method. This
     method kills any existing host_forwarder process that could be stale.
     """
     # See if the host_forwarder daemon was already initialized by a concurrent
     # process or thread (in case multi-process sharding is not used).
     pid_for_lock = Forwarder._GetPidForLock()
@@ skipping 67 matching lines @@
     """
     logging.info('Killing device_forwarder.')
     Forwarder._instance._initialized_devices.discard(str(device))
     if not device.FileExists(Forwarder._DEVICE_FORWARDER_PATH):
       return
 
     cmd = '%s %s --kill-server' % (tool.GetUtilWrapper(),
                                    Forwarder._DEVICE_FORWARDER_PATH)
     device.old_interface.GetAndroidToolStatusAndOutput(
         cmd, lib_path=Forwarder._DEVICE_FORWARDER_FOLDER)