Fix sky_tool's calling of adb, and shelldb's analyze and stop

sky/tools/shelldb

 #!/usr/bin/env python
 # Copyright 2015 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
 import re
+import signal
 import subprocess
 import sys
 import time
 import urlparse
 
 SKY_TOOLS_DIR = os.path.dirname(os.path.abspath(__file__))
 SKY_ROOT = os.path.dirname(SKY_TOOLS_DIR)
 SRC_ROOT = os.path.dirname(SKY_ROOT)
 
 SKY_SERVER_PORT = 9888
 DEFAULT_URL = "sky://domokit.github.io/home"
 APK_NAME = 'SkyDemo.apk'
 ADB_PATH = os.path.join(SRC_ROOT,
     'third_party/android_tools/sdk/platform-tools/adb')
-
+ANDROID_PACKAGE = "org.domokit.sky.demo"
 
 PID_FILE_PATH = "/tmp/skydemo.pids"
 PID_FILE_KEYS = frozenset([
     'remote_sky_server_port',
     'sky_server_pid',
     'sky_server_port',
     'sky_server_root',
     'build_dir',
 ])
 
@@ skipping 25 matching lines @@
     def __iter__(self):
         return iter(self._dict)
 
     def __contains__(self, key):
         assert key in self._known_keys, '%s not in allowed_keys' % key
         return key in self._dict
 
     def clear(self):
         self._dict = {}
 
+    def pop(self, key, default=None):
+        assert key in self._known_keys, '%s not in allowed_keys' % key
+        return self._dict.pop(key, default)
+
     @classmethod
     def read_from(cls, path, known_keys):
         contents = {}
         try:
             with open(path, 'r') as pid_file:
                 contents = json.load(pid_file)
         except:
             if os.path.exists(path):
                 logging.warn('Failed to read pid file: %s' % path)
         return cls(known_keys, contents)
@@ skipping 17 matching lines @@
     if urlparse.urlparse(args.url_or_path).scheme:
         return args.url_or_path
     # The load happens on the remote device, use the remote port.
     remote_sky_server_port = pids.get('remote_sky_server_port',
         pids['sky_server_port'])
     url = SkyServer.url_for_path(remote_sky_server_port,
         pids['sky_server_root'], args.url_or_path)
     return _convert_to_sky_url(url)
 
 
+def dev_sdk_root(build_dir):
+    return os.path.join(build_dir, 'gen', 'sky_sdk')
+
+def dev_packages_root(build_dir):
+    return os.path.join(dev_sdk_root(build_dir), 'packages_root')
+
+
 class StartSky(object):
     def add_subparser(self, subparsers):
         start_parser = subparsers.add_parser('start',
             help='launch SKyShell.apk on the device')
         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('--no_install', action="store_false",
             default=True, dest="install",
             help="Don't install SkyDemo.apk before starting")
@@ skipping 17 matching lines @@
         server_root = self._server_root_for_url(args.url_or_path)
         sky_server = SkyServer(SKY_SERVER_PORT, configuration, server_root, packages_root)
         return sky_server
 
     def run(self, args, pids):
         apk_path = os.path.join(args.build_dir, 'apks', APK_NAME)
         if not os.path.exists(apk_path):
             print "'%s' does not exist?" % apk_path
             return 2
 
-        sdk_root = os.path.join(args.build_dir, 'gen', 'sky_sdk')
-        packages_root = os.path.join(sdk_root, 'packages_root')
+        sdk_root = dev_sdk_root(args.build_dir)
+        packages_root = dev_packages_root(args.build_dir)
         sky_tools_directory = os.path.join(SRC_ROOT, 'sky/tools')
         subprocess.check_call([
             os.path.join(sky_tools_directory, 'deploy_sdk.py'),
             '--build-dir', args.build_dir,
             '--non-interactive',
             '--dev-environment',
             '--fake-pub-get-into', packages_root,
             sdk_root,
         ])
 
@@ skipping 32 matching lines @@
             return
         logging.info('Killing %s (%d).' % (name, pid))
         try:
             os.kill(pid, signal.SIGTERM)
         except OSError:
             logging.info('%s (%d) already gone.' % (name, pid))
 
     def run(self, args, pids):
         self._kill_if_exists(pids, 'sky_server_pid', 'sky_server')
 
-        if 'remote_sky_server_port' in self.pids:
-            port_string = 'tcp:%s' % self.pids['remote_sky_server_port']
+        if 'remote_sky_server_port' in pids:
+            port_string = 'tcp:%s' % pids['remote_sky_server_port']
             subprocess.call([ADB_PATH, 'reverse', '--remove', port_string])
 
         subprocess.call([
             ADB_PATH, 'shell', 'am', 'force-stop', ANDROID_PACKAGE])
 
         pids.clear()
 
 
 class Analyze(object):
     def add_subparser(self, subparsers):
         analyze_parser = subparsers.add_parser('analyze',
             help=('run the dart analyzer with sky url mappings'))
         analyze_parser.add_argument('app_path', type=str)
         analyze_parser.set_defaults(func=self.run)
 
     def run(self, args, pids):
+        build_dir = pids.get('build_dir')
+        if not build_dir:
+            logging.fatal("pids file missing build_dir. Try 'start' first.")
+            return 2
         ANALYZER_PATH = 'third_party/dart-sdk/dart-sdk/bin/dartanalyzer'
 
-        build_dir = os.path.abspath(pids['build_dir'])
         bindings_path = os.path.join(build_dir, 'gen/sky/bindings')
         sky_builtin_path = \
             os.path.join(SRC_ROOT, 'sky/engine/bindings/builtin.dart')
         dart_sky_path = os.path.join(bindings_path, 'dart_sky.dart')
         analyzer_args = [ANALYZER_PATH,
             "--url-mapping=dart:sky,%s" % dart_sky_path,
             "--url-mapping=dart:sky_builtin,%s" % sky_builtin_path,
+            "--package-root", dev_packages_root(build_dir),
             args.app_path
         ]
-        subprocess.call(analyzer_args)
+        return subprocess.call(analyzer_args)
 
 class StartTracing(object):
     def add_subparser(self, subparsers):
         start_tracing_parser = subparsers.add_parser('start_tracing',
             help=('start tracing a running sky instance'))
         start_tracing_parser.set_defaults(func=self.run)
 
     def run(self, args, pids):
         subprocess.check_output([ADB_PATH, 'shell',
             'am', 'broadcast',
@@ skipping 53 matching lines @@
         args = parser.parse_args()
         pids = Pids.read_from(PID_FILE_PATH, PID_FILE_KEYS)
         exit_code = args.func(args, pids)
         # We could do this with an at-exit handler instead?
         pids.write_to(PID_FILE_PATH)
         sys.exit(exit_code)
 
 
 if __name__ == '__main__':
     SkyShellRunner().main()