Support running with mojo:debugger in devtools.

mojo/devtools/common/devtoolslib/android_shell.py

 # Copyright 2014 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.
 
 import atexit
 import hashlib
 import json
 import logging
 import os
 import os.path
@@ skipping 85 matching lines @@
                                      fifo_path]),
                                     stdout=pipe)
       atexit.register(_ExitIfNeeded, stdout_cat)
       stdout_cat.wait()
       if on_fifo_closed:
         on_fifo_closed()
 
     thread = threading.Thread(target=Run, name="StdoutRedirector")
     thread.start()
 
-  def _MapPort(self, device_port, host_port):
+  def _ForwardDevicePortToHost(self, device_port, host_port):
     """Maps the device port to the host port. If |device_port| is 0, a random
-    available port is chosen. Returns the device port.
+    available port is chosen.
+
+    Returns:
+      The device port.
     """
     def _FindAvailablePortOnDevice():
       opened = subprocess.check_output(
           self._CreateADBCommand(['shell', 'netstat']))
       opened = [int(x.strip().split()[3].split(':')[1])
                 for x in opened if x.startswith(' tcp')]
       while True:
         port = random.randint(4096, 16384)
         if port not in opened:
           return port
     if device_port == 0:
       device_port = _FindAvailablePortOnDevice()
     subprocess.check_call(self._CreateADBCommand([
-        "reverse",
-        "tcp:%d" % device_port,
-        "tcp:%d" % host_port]))
+        "reverse", "tcp:%d" % device_port, "tcp:%d" % host_port]))
 
-    unmap_command = self._CreateADBCommand(["reverse", "--remove",
-                     "tcp:%d" % device_port])
+    unmap_command = self._CreateADBCommand([
+        "reverse", "--remove", "tcp:%d" % device_port])
 
     def _UnmapPort():
       subprocess.Popen(unmap_command)
     atexit.register(_UnmapPort)
     return device_port
 
   def _RunAdbAsRoot(self):
     if self.adb_running_as_root:
       return
 
@@ skipping 71 matching lines @@
       port: port at which the server will be available to the shell
 
     Returns:
       The url that the shell can use to access the content of |local_dir_path|.
     """
     assert local_dir_path
     print 'starting http for', local_dir_path
     server_address = StartHttpServer(local_dir_path)
 
     print 'local port=%d' % server_address[1]
-    return 'http://127.0.0.1:%d/' % self._MapPort(port,
-                                                  server_address[1])
+    return 'http://127.0.0.1:%d/' % self._ForwardDevicePortToHost(
+        port, server_address[1])
+
+  def ForwardHostPortToShell(self, host_port):
+    """Forwards a port on the host machine to the same port wherever the shell
+    is running.
+
+    This is a no-op if the shell is running locally.
+    """
+    assert host_port
+    device_port = host_port
+    subprocess.check_call(self._CreateADBCommand([
+        "forward", 'tcp:%d' % host_port, 'tcp:%d' % device_port]))
+
+    unmap_command = self._CreateADBCommand([
+        "forward", "--remove", "tcp:%d" % device_port])
+
+    def _UnmapPort():
+      subprocess.Popen(unmap_command)
+    atexit.register(_UnmapPort)
 
   def StartShell(self,
                  arguments,
                  stdout=None,
                  on_application_stop=None):
     """Starts the mojo shell, passing it the given arguments.
 
     The |arguments| list must contain the "--origin=" arg. SetUpLocalOrigin()
     can be used to set up a local directory on the host machine as origin.
     If |stdout| is not None, it should be a valid argument for subprocess.Popen.
@@ skipping 90 matching lines @@
       tags.extend(_LOGCAT_NATIVE_TAGS)
     if self.additional_logcat_tags is not None:
       tags.extend(self.additional_logcat_tags.split(","))
     logcat = subprocess.Popen(
         self._CreateADBCommand(['logcat',
                                 '-s',
                                 ' '.join(tags)]),
         stdout=sys.stdout)
     atexit.register(_ExitIfNeeded, logcat)
     return logcat