Add skydb logcat command and make relative build_dir work

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.paths import Paths
+import skypy.paths
 from skypy.skyserver import SkyServer
 import argparse
 import json
 import logging
 import os
 import pipes
 import requests
 import signal
 import subprocess
 import sys
 import time
 import urlparse
 
-sys.path.insert(0, os.path.join(Paths('ignored').src_root, 'build', 'android'))
+SRC_ROOT = skypy.paths.Paths('ignored').src_root
+sys.path.insert(0, os.path.join(SRC_ROOT, 'build', 'android'))
 from pylib import android_commands
 from pylib import constants
 from pylib import forwarder
 
 
 SUPPORTED_MIME_TYPES = [
     'text/html',
     'text/sky',
     'text/plain',
 ]
@@ skipping 14 matching lines @@
     config = {}
     for line in subprocess.check_output(gn_cmd).strip().split('\n'):
         # FIXME: This doesn't handle = in values.
         key, value = line.split(' = ')
         config[key] = value
     return config
 
 
 class SkyDebugger(object):
     def __init__(self):
+        self.pids = {}
         self.paths = None
-        self.pids = {}
 
     def _server_root_for_url(self, url_or_path):
         path = os.path.abspath(url_or_path)
-        if os.path.commonprefix([path, self.paths.src_root]) == self.paths.src_root:
-            server_root = self.paths.src_root
+        if os.path.commonprefix([path, SRC_ROOT]) == SRC_ROOT:
+            server_root = SRC_ROOT
         else:
             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)
 
@@ skipping 37 matching lines @@
         if args.use_osmesa:
             shell_args.append('--args-for=mojo:native_viewport_service --use-osmesa')
 
         if 'remote_sky_server_port' in self.pids:
             shell_command = self._wrap_for_android(shell_args)
         else:
             shell_command = [self.paths.mojo_shell_path] + shell_args
 
         # FIXME: This doesn't work for android
         if args.gdb:
-            shell_command = ['gdb', '--args'] + shell_command
+            shell_command = ['gdb'] + shell_command
 
         return shell_command
 
     def _connect_to_device(self):
         device = android_commands.AndroidCommands(
             android_commands.GetAttachedDevices()[0])
         device.EnableAdbRoot()
         return device
 
     def sky_server_for_args(self, args):
         # FIXME: This is a hack.  sky_server should just take a build_dir
         # not a magical "configuration" name.
         configuration = os.path.basename(os.path.normpath(args.build_dir))
         server_root = self._server_root_for_url(args.url_or_path)
         sky_server = SkyServer(self.paths, SKY_SERVER_PORT,
             configuration, server_root)
         return sky_server
 
     def start_command(self, args):
+        # skypy.paths.Paths takes a root-relative build_dir argument. :(
+        build_dir = os.path.abspath(args.build_dir)
+        root_relative_build_dir = os.path.relpath(build_dir, SRC_ROOT)
         # FIXME: Lame that we use self for a command-specific variable.
-        self.paths = Paths(args.build_dir)
+        self.paths = skypy.paths.Paths(root_relative_build_dir)
 
         self.stop_command(None) # Quit any existing process.
         self.pids = {} # Clear out our pid file.
 
         # FIXME: This is probably not the right way to compute is_android
         # from the build directory?
         gn_args = gn_args_from_build_dir(args.build_dir)
         is_android = 'android_sdk_version' in gn_args
 
         sky_server = self.sky_server_for_args(args)
@@ skipping 37 matching lines @@
         if not pid:
             logging.info('No pid for %s, nothing to do.' % name)
             return
         logging.info('Killing %s (%s).' % (name, pid))
         try:
             os.kill(pid, signal.SIGTERM)
         except OSError:
             logging.info('%s (%s) already gone.' % (name, pid))
 
     def stop_command(self, args):
-        try:
-            self._send_command_to_sky('/quit')
-        except:
-            pass
-        # Kill the mojo process for good measure. :)
+        # TODO(eseidel): mojo_shell crashes when attempting graceful shutdown.
+        # self._send_command_to_sky('/quit')
         self._kill_if_exists('mojo_shell_pid', 'mojo_shell')
 
         self._kill_if_exists('sky_server_pid', 'sky_server')
         # We could be much more surgical here:
         if 'remote_sky_command_port' in self.pids:
             device = android_commands.AndroidCommands(
                 self.pids['device_serial'])
             forwarder.Forwarder.UnmapAllDevicePorts(device)
 
         if 'remote_sky_command_port' in self.pids:
@@ skipping 54 matching lines @@
                 return True
             except:
                 tries += 1
                 if tries == 3:
                     logging.warn('Still waiting for sky on port %s' %
                         self.pids['sky_command_port'])
                 if tries > 10:
                     return False
                 time.sleep(1)
 
+    def logcat_command(self, args):
+        TAGS = [
+            'AndroidHandler',
+            'MojoMain',
+            'MojoShellActivity',
+            'MojoShellApplication',
+            'chromium',
+        ]
+        subprocess.call(['adb', 'logcat', '-s'] + TAGS)
+
     def main(self):
         logging.basicConfig(level=logging.INFO)
         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)
 
+        logcat_parser = subparsers.add_parser('logcat',
+            help=('dump sky-related logs from device'))
+        logcat_parser.set_defaults(func=self.logcat_command)
+
         self._add_basic_command(subparsers, 'trace', '/trace',
             'toggle tracing')
         self._add_basic_command(subparsers, 'reload', '/reload',
             'reload the current page')
         self._add_basic_command(subparsers, 'inspect', '/inspect',
             'stop the running sky instance')
 
         load_parser = subparsers.add_parser('load',
             help='load a new page in the currently running sky')
         load_parser.add_argument('url_or_path', type=str)
         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()