Fix skydb --gdb to always have symbols

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 22 matching lines @@
 ]
 
 DEFAULT_SKY_COMMAND_PORT = 7777
 GDB_PORT = 8888
 SKY_SERVER_PORT = 9999
 PID_FILE_PATH = "/tmp/skydb.pids"
 DEFAULT_URL = "https://raw.githubusercontent.com/domokit/mojo/master/sky/examples/home.sky"
 
 ANDROID_PACKAGE = "org.chromium.mojo.shell"
 ANDROID_ACTIVITY = "%s/.MojoShellActivity" % ANDROID_PACKAGE
+ANDROID_APK_NAME = 'MojoShell.apk'
 CACHE_LINKS_PATH = '/tmp/mojo_cache_links'
 SYSTEM_LIBS_ROOT_PATH = '/tmp/device_libs'
 
 
 # FIXME: Move this into mopy.config
 def gn_args_from_build_dir(build_dir):
     gn_cmd = [
         'gn', 'args',
         build_dir,
         '--list', '--short'
@@ skipping 135 matching lines @@
         self.pids['sky_server_port'] = sky_server.port
         self.pids['sky_server_root'] = sky_server.root
 
         self.pids['build_dir'] = self.paths.build_dir
         self.pids['sky_command_port'] = args.command_port
 
         if is_android:
             # Pray to the build/android gods in their misspelled tongue.
             constants.SetOutputDirectort(self.paths.build_dir)
 
+            # We could make installing conditional on an argument.
+            apk_path = os.path.join(self.paths.build_dir, 'apks',
+                ANDROID_APK_NAME)
+            subprocess.check_call(['adb', 'install', '-r', apk_path])
+
             device = self._connect_to_device()
             self.pids['device_serial'] = device.GetDevice()
 
             forwarder.Forwarder.Map([(0, sky_server.port)], device)
             device_http_port = forwarder.Forwarder.DevicePortForHostPort(
                 sky_server.port)
             self.pids['remote_sky_server_port'] = device_http_port
 
             port_string = 'tcp:%s' % args.command_port
             subprocess.check_call([
@@ skipping 96 matching lines @@
             self._kill_if_exists('mojo_shell_pid', 'mojo_shell')
 
         if 'remote_gdbserver_port' in self.pids:
             self._kill_if_exists('adb_shell_gdbserver_pid',
                 'adb shell gdbserver')
 
             port_string = 'tcp:%s' % self.pids['remote_gdbserver_port']
             subprocess.call(['adb', 'forward', '--remove', port_string])
         self.pids = {} # Clear out our pid file.
 
-        self._kill_if_exists('mojo_cache_linker_pid', 'mojo cache linker')
-
     def load_command(self, args):
         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)
@@ skipping 92 matching lines @@
     def logcat_command(self, args):
         TAGS = [
             'AndroidHandler',
             'MojoMain',
             'MojoShellActivity',
             'MojoShellApplication',
             'chromium',
         ]
         subprocess.call(['adb', 'logcat', '-d', '-s'] + TAGS)
 
-    def _start_mojo_cache_linker(self, links_path):
-        self._kill_if_exists('mojo_cache_linker_pid', 'mojo cache linker')
-
-        if not os.path.exists(links_path):
-            os.makedirs(links_path)
-        shell_link_path = os.path.join(links_path, 'libmojo_shell.so')
-        if os.path.lexists(shell_link_path):
-            os.unlink(shell_link_path)
-        os.symlink(self.paths.mojo_shell_path, shell_link_path)
-
-        logcat_cmd = ['adb', 'logcat']
-        logcat = subprocess.Popen(logcat_cmd, stdout=subprocess.PIPE)
-
-        mojo_cache_linker_path = os.path.join(
-            self.paths.sky_tools_directory, 'mojo_cache_linker.py')
-        cache_linker_cmd = [
-            mojo_cache_linker_path,
-            links_path,
-            self.pids['build_dir'],
-            'http://localhost:%s' % self.pids['remote_sky_server_port']
-        ]
-        return subprocess.Popen(cache_linker_cmd, stdin=logcat.stdout).pid
-
     def _pull_system_libraries(self, system_libs_root):
         # Pull down the system libraries this pid has already mapped in.
         # TODO(eseidel): This does not handle dynamic loads.
         library_cacher_path = os.path.join(
             self.paths.sky_tools_directory, 'android_library_cacher.py')
         subprocess.call([
             library_cacher_path, system_libs_root, self.pids['mojo_shell_pid']
         ])
 
         # TODO(eseidel): adb_gdb does, this, unclear why solib-absolute-prefix
         # doesn't make this explicit listing not necessary?
         return subprocess.check_output([
             'find', system_libs_root,
             '-mindepth', '1',
             '-maxdepth', '4',
             '-type', 'd',
         ]).strip().split('\n')
 
+    def _add_android_library_links(self, links_path):
+        # TODO(eseidel): This might not match mojo_shell on the device?
+        # TODO(eseidel): Should we pass libmojo_shell.so as 'file' to gdb?
+        shell_link_path = os.path.join(links_path, 'libmojo_shell.so')
+        if os.path.lexists(shell_link_path):
+            os.unlink(shell_link_path)
+        os.symlink(self.paths.mojo_shell_path, shell_link_path)
 
     def gdb_attach_command(self, args):
         self.paths = self._create_paths_for_build_dir(self.pids['build_dir'])
 
-        symbol_search_paths = [self.pids['build_dir']]
+        if not os.path.exists(CACHE_LINKS_PATH):
+            os.makedirs(CACHE_LINKS_PATH)
+        cache_linker_path = os.path.join(
+             self.paths.sky_tools_directory, 'mojo_cache_linker.py')
+        subprocess.check_call([
+            cache_linker_path, CACHE_LINKS_PATH, self.paths.build_dir])
+
+        symbol_search_paths = [
+            self.pids['build_dir'],
+            CACHE_LINKS_PATH,
+        ]
         gdb_path = '/usr/bin/gdb'
 
-        init_commands = [
+        eval_commands = [
+            'directory %s' % self.paths.src_root,
             'file %s' % self.paths.mojo_shell_path,
-            'directory %s' % self.paths.src_root,
             'target remote localhost:%s' % GDB_PORT,
         ]
 
         # A bunch of extra work is needed for android:
         if 'remote_sky_server_port' in self.pids:
-            pid = self._start_mojo_cache_linker(CACHE_LINKS_PATH)
-            self.pids['mojo_cache_linker_pid'] = pid
+            self._add_android_library_links(CACHE_LINKS_PATH)
 
             system_lib_dirs = self._pull_system_libraries(SYSTEM_LIBS_ROOT_PATH)
-            init_commands.append(
+            eval_commands.append(
                 'set solib-absolute-prefix %s' % SYSTEM_LIBS_ROOT_PATH)
 
             symbol_search_paths = system_lib_dirs + symbol_search_paths
-            symbol_search_paths.append(CACHE_LINKS_PATH)
 
             # TODO(eseidel): We need to look up the toolchain somehow?
             gdb_path = os.path.join(SRC_ROOT, 'third_party/android_tools/ndk/'
                 'toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/'
                 'bin/arm-linux-androideabi-gdb')
 
         # Set solib-search-path after letting android modify symbol_search_paths
-        init_commands.append(
+        eval_commands.append(
             'set solib-search-path %s' % ':'.join(symbol_search_paths))
 
-        exec_command = [gdb_path]
-        for command in init_commands:
+        exec_command = ['/usr/bin/strace', '-o', 'trace.txt', gdb_path]
+        for command in eval_commands:
             exec_command += ['--eval-command', command]
+
         print " ".join(exec_command)
 
         # Write out our pid file before we exec ourselves.
         self._write_pid_file(PID_FILE_PATH, self.pids)
 
         # Exec gdb directly to avoid python intercepting symbols, etc.
         os.execv(exec_command[0], exec_command)
 
     def print_crash_command(self, args):
         logcat_cmd = ['adb', 'logcat', '-d']
@@ skipping 70 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()