Add ServeLocalDirectory to the shell abstraction.

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 itertools
 import json
 import logging
 import os
 import os.path
@@ skipping 124 matching lines @@
         "tcp:%d" % host_port]))
 
     unmap_command = self._CreateADBCommand(["reverse", "--remove",
                      "tcp:%d" % device_port])
 
     def _UnmapPort():
       subprocess.Popen(unmap_command)
     atexit.register(_UnmapPort)
     return device_port
 
-  def _StartHttpServerForDirectory(self, path, port=0):
-    """Starts an http server serving files from |path|. Returns the local
-    url.
-    """
-    assert path
-    print 'starting http for', path
-    server_address = StartHttpServer(path)
-
-    print 'local port=%d' % server_address[1]
-    return 'http://127.0.0.1:%d/' % self._MapPort(port, server_address[1])
-
   def _StartHttpServerForOriginMapping(self, mapping, port):
     """If |mapping| points at a local file starts an http server to serve files
     from the directory and returns the new mapping.
 
     This is intended to be called for every --map-origin value.
     """
     parts = mapping.split('=')
     if len(parts) != 2:
       return mapping
     dest = parts[1]
     # If the destination is a url, don't map it.
     if urlparse.urlparse(dest)[0]:
       return mapping
     # Assume the destination is a local file. Start a local server that
     # redirects to it.
-    localUrl = self._StartHttpServerForDirectory(dest, port)
+    localUrl = self.ServeLocalDirectory(dest, port)
     print 'started server at %s for %s' % (dest, localUrl)
     return parts[0] + '=' + localUrl
 
   def _StartHttpServerForOriginMappings(self, map_parameters, fixed_port):
     """Calls _StartHttpServerForOriginMapping for every --map-origin
     argument.
     """
     if not map_parameters:
       return []
 
@@ skipping 30 matching lines @@
         self._CreateADBCommand(['install', '-r', shell_apk_path, '-i',
                                 MOJO_SHELL_PACKAGE_NAME]),
         stdout=self.verbose_pipe)
 
   def SetUpLocalOrigin(self, local_dir, fixed_port=True):
     """Sets up a local http server to serve files in |local_dir| along with
     device port forwarding. Returns the origin flag to be set when running the
     shell.
     """
 
-    origin_url = self._StartHttpServerForDirectory(
+    origin_url = self.ServeLocalDirectory(
         local_dir, DEFAULT_BASE_PORT if fixed_port else 0)
     return "--origin=" + origin_url
 
+  def ServeLocalDirectory(self, local_dir_path, port=0):
+    """Serves the content of the local (host) directory, making it available to
+    the shell under the url returned by the function.
+
+    The server will run on a separate thread until the program terminates. The
+    call returns immediately.
+
+    Args:
+      local_dir_path: path to the directory to be served
+      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])
+
   def StartShell(self,
                  arguments,
                  stdout=None,
                  on_application_stop=None,
                  fixed_port=True):
     """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 88 matching lines @@
     Returns:
       The process responsible for reading the logs.
     """
     logcat = subprocess.Popen(self._CreateADBCommand([
                                'logcat',
                                '-s',
                                ' '.join(LOGCAT_TAGS)]),
                               stdout=sys.stdout)
     atexit.register(_ExitIfNeeded, logcat)
     return logcat