Fix apptest builds and runner on Android.

mojo/tools/mopy/android.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 datetime
 import email.utils
 import hashlib
 import itertools
 import json
@@ skipping 19 matching lines @@
     'MojoMain',
     'MojoShellActivity',
     'MojoShellApplication',
     'chromium',
 ]
 
 MOJO_SHELL_PACKAGE_NAME = 'org.chromium.mojo.shell'
 
 MAPPING_PREFIX = '--map-origin='
 
-DEFAULT_BASE_PORT = 31337
-
 ZERO = datetime.timedelta(0)
 
 class UTC_TZINFO(datetime.tzinfo):
   """UTC time zone representation."""
 
   def utcoffset(self, _):
     return ZERO
 
   def tzname(self, _):
     return "UTC"
@@ skipping 213 matching lines @@
 
     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
     httpd = _SilentTCPServer(('127.0.0.1', 0), _GetHandlerClassForPath(path))
     atexit.register(httpd.shutdown)
 
     http_thread = threading.Thread(target=httpd.serve_forever)
     http_thread.daemon = True
     http_thread.start()
 
-    print 'local port=%d' % httpd.server_address[1]
+    print 'Hosting %s at http://127.0.0.1:%d' % (path, httpd.server_address[1])
     return 'http://127.0.0.1:%d/' % self._MapPort(port, httpd.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)
     print 'started server at %s for %s' % (dest, localUrl)
     return parts[0] + '=' + localUrl
 
-  def _StartHttpServerForOriginMappings(self, map_parameters, fixed_port):
+  def _StartHttpServerForOriginMappings(self, map_parameters):
     """Calls _StartHttpServerForOriginMapping for every --map-origin
     argument."""
     if not map_parameters:
       return []
 
     original_values = list(itertools.chain(
         *map(lambda x: x[len(MAPPING_PREFIX):].split(','), map_parameters)))
     sorted(original_values)
     result = []
-    for i, value in enumerate(original_values):
-      result.append(self._StartHttpServerForOriginMapping(
-          value, DEFAULT_BASE_PORT + 1 + i if fixed_port else 0))
+    for value in original_values:
+      result.append(self._StartHttpServerForOriginMapping(value, 0))
     return [MAPPING_PREFIX + ','.join(result)]
 
-  def PrepareShellRun(self, origin=None, fixed_port=True):
-    """ Prepares for StartShell: runs adb as root and installs the apk.  If no
-    --origin is specified, local http server will be set up to serve files from
-    the build directory along with port forwarding.
+  def PrepareShellRun(self, origin=None):
+    """ Prepares for StartShell: runs adb as root and installs the apk.  If the
+    origin specified is 'localhost', a local http server will be set up to serve
+    files from the build directory along with port forwarding.
 
     Returns arguments that should be appended to shell argument list."""
     if 'cannot run as root' in subprocess.check_output(
         self._CreateADBCommand(['root'])):
       raise Exception("Unable to run adb as root.")
     subprocess.check_call(
         self._CreateADBCommand(['install', '-r', self.shell_apk_path, '-i',
                                 self.target_package]))
     atexit.register(self.StopShell)
 
     extra_shell_args = []
+    if origin is 'localhost':
+      origin = self._StartHttpServerForDirectory(self.local_dir, 0)
     if origin:
-      origin_url = origin if origin else self._StartHttpServerForDirectory(
-          self.local_dir, DEFAULT_BASE_PORT if fixed_port else 0)
-      extra_shell_args.append("--origin=" + origin_url)
-
+      extra_shell_args.append("--origin=" + origin)
     return extra_shell_args
 
   def StartShell(self,
                  arguments,
                  stdout=None,
-                 on_application_stop=None,
-                 fixed_port=True):
+                 on_application_stop=None):
     """
     Starts the mojo shell, passing it the given arguments.
 
     The |arguments| list must contain the "--origin=" arg from PrepareShellRun.
     If |stdout| is not None, it should be a valid argument for subprocess.Popen.
     """
     STDOUT_PIPE = "/data/data/%s/stdout.fifo" % self.target_package
 
     cmd = self._CreateADBCommand([
            'shell',
            'am',
            'start',
            '-S',
            '-a', 'android.intent.action.VIEW',
            '-n', '%s/%s.MojoShellActivity' % (self.target_package,
                                               MOJO_SHELL_PACKAGE_NAME)])
 
     parameters = []
     if stdout or on_application_stop:
       subprocess.check_call(self._CreateADBCommand(
           ['shell', 'rm', '-f', STDOUT_PIPE]))
       parameters.append('--fifo-path=%s' % STDOUT_PIPE)
       self._ReadFifo(STDOUT_PIPE, stdout, on_application_stop)
 
     # Extract map-origin arguments.
     map_parameters, other_parameters = _Split(arguments, _IsMapOrigin)
     parameters += other_parameters
-    parameters += self._StartHttpServerForOriginMappings(map_parameters,
-                                                         fixed_port)
+    parameters += self._StartHttpServerForOriginMappings(map_parameters)
 
     if parameters:
       encodedParameters = json.dumps(parameters)
       cmd += ['--es', 'encodedParameters', encodedParameters]
 
     with open(os.devnull, 'w') as devnull:
       subprocess.Popen(cmd, stdout=devnull).wait()
 
   def StopShell(self):
     """
@@ skipping 16 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