Always use mojo_shell in over-http mode

sky/tools/skydb

 #!/usr/bin/env python
 # 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.
 
 from skypy.skyserver import SkyServer
 import argparse
 import json
 import logging
 import os
@@ skipping 61 matching lines @@
             server_root = os.path.dirname(path)
             logging.warn(
                 '%s is outside of mojo root, using %s as server root' %
                 (path, server_root))
         return server_root
 
     def _in_chromoting(self):
         return os.environ.get('CHROME_REMOTE_DESKTOP_SESSION', False)
 
     def _wrap_for_android(self, shell_args):
-        build_dir_url = SkyServer.url_for_path(
-            self.pids['remote_sky_server_port'],
-            self.pids['sky_server_root'],
-            self.pids['build_dir'])
-        shell_args += ['--origin=%s' % build_dir_url]
-
         # am shell --esa: (someone shoot me now)
         #  [--esa <EXTRA_KEY> <EXTRA_STRING_VALUE>[,<EXTRA_STRING_VALUE...]]
         #  (to embed a comma into a string escape it using "\,")
         escaped_args = map(lambda arg: arg.replace(',', '\\,'), shell_args)
         return [
             'adb', 'shell',
             'am', 'start',
             '-W',
             '-S',
             '-a', 'android.intent.action.VIEW',
             '-n', ANDROID_ACTIVITY,
             # FIXME: This quoting is very error-prone.  Perhaps we should read
             # our args from a file instead?
             '--esa', 'parameters', ','.join(escaped_args),
         ]
 
     def _build_mojo_shell_command(self, args, is_android):
         content_handlers = ['%s,%s' % (mime_type, 'mojo:sky_viewer')
             for mime_type in SUPPORTED_MIME_TYPES]
 
         remote_command_port = self.pids.get('remote_sky_command_port', self.pids['sky_command_port'])
+        remote_server_port = self.pids.get('remote_sky_server_port', self.pids['sky_server_port'])
 
         shell_args = [
             '--v=1',
             '--content-handlers=%s' % ','.join(content_handlers),
             '--url-mappings=mojo:window_manager=mojo:sky_debugger',
             '--args-for=mojo:sky_debugger_prompt %d' % remote_command_port,
             'mojo:window_manager',
         ]
 
+        # Map all mojo: urls to http: urls using the --origin command.
+        build_dir_url = SkyServer.url_for_path(
+            remote_server_port,
+            self.pids['sky_server_root'],
+            self.pids['build_dir'])
+        shell_args += ['--origin=%s' % build_dir_url]
+
         # Desktop-only work-around for mojo crashing under chromoting.
         if not is_android and args.use_osmesa:
             shell_args.append(
                 '--args-for=mojo:native_viewport_service --use-osmesa')
 
         if is_android and args.gdb:
             shell_args.append('--wait_for_debugger')
 
         if 'remote_sky_server_port' in self.pids:
             shell_command = self._wrap_for_android(shell_args)
@@ skipping 187 matching lines @@
         if not urlparse.urlparse(args.url_or_path).scheme:
             # The load happens on the remote device, use the remote port.
             remote_sky_server_port = self.pids.get('remote_sky_server_port',
                 self.pids['sky_server_port'])
             url = SkyServer.url_for_path(remote_sky_server_port,
                     self.pids['sky_server_root'], args.url_or_path)
         else:
             url = args.url_or_path
         self._send_command_to_sky('/load', url)
 
+    def _read_mojo_map(self):
+        # TODO(eseidel): Does not work for android.
+        mojo_map_path = "/tmp/mojo_shell.%d.maps" % self.pids['mojo_shell_pid']
+        with open(mojo_map_path, 'r') as maps_file:
+            lines = maps_file.read().strip().split('\n')
+            return dict(map(lambda line: line.split(' '), lines))
+
     def stop_profiling_command(self, args):
         self._send_command_to_sky('/stop_profiling')
-        # We need to munge the profile to replace foo.mojo with libfoo.so so
-        # that pprof knows this represents an SO.
-        with open("sky_viewer.pprof", "r+") as profile_file:
-            data = profile_file.read()
+        mojo_map = self._read_mojo_map()
+
+        # TODO(eseidel): We should have a helper for resolving urls, etc.
+        remote_server_port = self.pids.get('remote_sky_server_port', self.pids['sky_server_port'])
+        build_dir_url = SkyServer.url_for_path(
+            remote_server_port,
+            self.pids['sky_server_root'],
+            self.pids['build_dir'])
+
+        # Map /tmp cache paths to urls and then to local build_dir paths.
+        def map_to_local_paths(match):
+            path = match.group('mojo_path')
+            url = mojo_map.get(path)
+            if url and url.startswith(build_dir_url):
+                return url.replace(build_dir_url, self.pids['build_dir'])
+            return match.group(0)
+
+        MOJO_PATH_RE = re.compile(r'(?P<mojo_path>\S+\.mojo)')
+        MOJO_NAME_RE = re.compile(r'(?P<mojo_name>\w+)\.mojo')
+
+        with open("sky_viewer.pprof", "rb+") as profile_file:
+            # ISO-8859-1 can represent arbitrary binary while still keeping
+            # ASCII characters in the ASCII range (allowing us to regexp).
+            # http://en.wikipedia.org/wiki/ISO/IEC_8859-1
+            as_string = profile_file.read().decode('iso-8859-1')
+            # Using the mojo_shell.PID.maps file tmp paths to build_dir paths.
+            as_string = MOJO_PATH_RE.sub(map_to_local_paths, as_string)
+            # In release foo.mojo is stripped but libfoo_library.so isn't.
+            as_string = MOJO_NAME_RE.sub(r'lib\1_library.so', as_string)
             profile_file.seek(0)
-            profile_file.write(re.sub(r'(\w+)\.mojo', r'lib\1_library.so', data))
+            profile_file.write(as_string.encode('iso-8859-1'))
             profile_file.truncate()
 
     def _command_base_url(self):
         return 'http://localhost:%s' % self.pids['sky_command_port']
 
     def _send_command_to_sky(self, command_path, payload=None):
         url = 'http://localhost:%s%s' % (
             self.pids['sky_command_port'], command_path)
         if payload:
             response = requests.post(url, payload)
@@ skipping 137 matching lines @@
     def print_crash_command(self, args):
         logcat_cmd = ['adb', 'logcat', '-d']
         logcat = subprocess.Popen(logcat_cmd, stdout=subprocess.PIPE)
 
         stack_path = os.path.join(SRC_ROOT,
             'tools', 'android_stack_parser', 'stack')
         stack = subprocess.Popen([stack_path, '-'], stdin=logcat.stdout)
         logcat.wait()
         stack.wait()
 
+    def pids_command(self, args):
+        print json.dumps(self.pids, indent=1)
+
     def main(self):
         logging.basicConfig(level=logging.WARNING)
         logging.getLogger("requests").setLevel(logging.WARNING)
 
         self.pids = self._load_pid_file(PID_FILE_PATH)
 
         parser = argparse.ArgumentParser(description='Sky launcher/debugger')
         subparsers = parser.add_subparsers(help='sub-command help')
 
         start_parser = subparsers.add_parser('start',
             help='launch a new mojo_shell with sky')
         start_parser.add_argument('--gdb', action='store_true')
         start_parser.add_argument('--command-port', type=int,
             default=DEFAULT_SKY_COMMAND_PORT)
         start_parser.add_argument('--use-osmesa', action='store_true',
             default=self._in_chromoting())
         start_parser.add_argument('build_dir', type=str)
         start_parser.add_argument('url_or_path', nargs='?', type=str,
             default=DEFAULT_URL)
         start_parser.add_argument('--show-command', action='store_true',
             help='Display the shell command and exit')
         start_parser.set_defaults(func=self.start_command)
 
         stop_parser = subparsers.add_parser('stop',
             help=('stop sky (as listed in %s)' % PID_FILE_PATH))
         stop_parser.set_defaults(func=self.stop_command)
 
+        pids_parser = subparsers.add_parser('pids',
+            help='dump the current skydb pids file')
+        pids_parser.set_defaults(func=self.pids_command)
+
         logcat_parser = subparsers.add_parser('logcat',
             help=('dump sky-related logs from device'))
         logcat_parser.set_defaults(func=self.logcat_command)
 
         print_crash_parser = subparsers.add_parser('print_crash',
             help=('dump (and symbolicate) recent crash-stacks'))
         print_crash_parser.set_defaults(func=self.print_crash_command)
 
         gdb_attach_parser = subparsers.add_parser('gdb_attach',
             help='launch gdb and attach to gdbserver launched from start --gdb')
@@ skipping 18 matching lines @@
         load_parser.set_defaults(func=self.load_command)
 
         args = parser.parse_args()
         args.func(args)
 
         self._write_pid_file(PID_FILE_PATH, self.pids)
 
 
 if __name__ == '__main__':
     SkyDebugger().main()