Gets mandoline working 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 173 matching lines @@
 class AndroidShell(object):
   """ Allows to set up and run a given mojo shell binary on an Android device.
 
   Args:
     shell_apk_path: path to the shell Android binary
     local_dir: directory where locally build Mojo apps will be served, optional
     adb_path: path to adb, optional if adb is in PATH
     target_device: device to run on, if multiple devices are connected
   """
   def __init__(
-      self, shell_apk_path, local_dir=None, adb_path="adb", target_device=None):
+      self, shell_apk_path, local_dir=None, adb_path="adb", target_device=None,
+      target_package=MOJO_SHELL_PACKAGE_NAME):
     self.shell_apk_path = shell_apk_path
     self.adb_path = adb_path
     self.local_dir = local_dir
     self.target_device = target_device
+    self.target_package = target_package
 
   def _CreateADBCommand(self, args):
     adb_command = [self.adb_path]
     if self.target_device:
       adb_command.extend(['-s', self.target_device])
     adb_command.extend(args)
     return adb_command
 
   def _ReadFifo(self, fifo_path, pipe, on_fifo_closed, max_attempts=5):
     """
@@ skipping 109 matching lines @@
     """ 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.
 
     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',
-         MOJO_SHELL_PACKAGE_NAME]))
+                                self.target_package]))
     atexit.register(self.StopShell)
 
     extra_shell_args = []
-    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)
+    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)
 
     return extra_shell_args
 
   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 from PrepareShellRun.
     If |stdout| is not None, it should be a valid argument for subprocess.Popen.
     """
-    STDOUT_PIPE = "/data/data/%s/stdout.fifo" % MOJO_SHELL_PACKAGE_NAME
+    STDOUT_PIPE = "/data/data/%s/stdout.fifo" % self.target_package
 
     cmd = self._CreateADBCommand([
            'shell',
            'am',
            'start',
            '-S',
            '-a', 'android.intent.action.VIEW',
-           '-n', '%s/.MojoShellActivity' % MOJO_SHELL_PACKAGE_NAME])
+           '-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', STDOUT_PIPE]))
+          ['shell', 'rm', '-f', STDOUT_PIPE]))
       parameters.append('--fifo-path=%s' % STDOUT_PIPE)
       self._ReadFifo(STDOUT_PIPE, stdout, on_application_stop)
-    # The origin has to be specified whether it's local or external.
-    assert any("--origin=" in arg for arg in arguments)
 
     # Extract map-origin arguments.
     map_parameters, other_parameters = _Split(arguments, _IsMapOrigin)
     parameters += other_parameters
     parameters += self._StartHttpServerForOriginMappings(map_parameters,
                                                          fixed_port)
 
     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):
     """
     Stops the mojo shell.
     """
     subprocess.check_call(self._CreateADBCommand(['shell',
                                                   'am',
                                                   'force-stop',
-                                                  MOJO_SHELL_PACKAGE_NAME]))
+                                                  self.target_package]))
 
   def CleanLogs(self):
     """
     Cleans the logs on the device.
     """
     subprocess.check_call(self._CreateADBCommand(['logcat', '-c']))
 
   def ShowLogs(self):
     """
     Displays the log for the mojo shell.
 
     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