Fix shelldb workflow

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
@@ skipping 17 matching lines @@
 
 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',
 ])
 
+_IGNORED_PATTERNS = [
+  # Ignored because they're not indicative of specific errors.
+  re.compile(r'^$'),
+  re.compile(r'^Analyzing \['),
+  re.compile(r'^No issues found'),
+  re.compile(r'^[0-9]+ errors? and [0-9]+ warnings? found.'),
+  re.compile(r'^([0-9]+|No) (error|warning|issue)s? found.'),
+
+  # TODO: Remove once sdk-extensions are in place
+  re.compile(r'^\[error\] Native functions can only be declared in'),
+  # TODO: Remove this once dev SDK includes Uri.directory constructor.
+  re.compile(r'.*The class \'Uri\' does not have a constructor \'directory\''),
+]
+
 # This 'strict dictionary' approach is useful for catching typos.
 class Pids(object):
     def __init__(self, known_keys, contents=None):
         self._known_keys = known_keys
         self._dict = contents if contents is not None else {}
 
     def __len__(self):
         return len(self._dict)
 
     def get(self, key, default=None):
@@ skipping 56 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')
+    return os.path.join(build_dir, 'gen', 'dart-pkg', 'packages')
 
 
 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",
@@ skipping 19 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 = 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,
-        ])
-
         sky_server = self._sky_server_for_args(args, packages_root)
         pids['sky_server_pid'] = sky_server.start()
         pids['sky_server_port'] = sky_server.port
         pids['sky_server_root'] = sky_server.root
 
         pids['build_dir'] = os.path.abspath(args.build_dir)
 
         if args.install:
             # -r to replace an existing apk, -d to allow version downgrade.
             subprocess.check_call([ADB_PATH, 'install', '-r', '-d', apk_path])
@@ skipping 50 matching lines @@
     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'
 
         bindings_path = os.path.join(build_dir, 'gen/sky/bindings')
         sky_builtin_path = \
             os.path.join(SRC_ROOT, 'sky/engine/bindings/builtin.dart')
+        sky_internals_path = \
+            os.path.join(SRC_ROOT, 'sky/sdk/lib/internals.dart')
         dart_sky_path = os.path.join(bindings_path, 'dart_sky.dart')
         analyzer_args = [ANALYZER_PATH,
+            "--url-mapping=dart:sky.internals,%s" % sky_internals_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),
             "--package-warnings",
             args.app_path
         ]
-        return subprocess.call(analyzer_args)
+        try:
+          subprocess.check_output(analyzer_args,
+                                  shell=False,
+                                  stderr=subprocess.STDOUT)
+        except subprocess.CalledProcessError as e:
+          errors = set(l for l in e.output.split('\n')
+                       if not any(p.match(l) for p in _IGNORED_PATTERNS))
+          # If we do not have any errors left after filtering, return 0.
+          if len(errors) == 0:
+            return 0
+          # Print errors.
+          for error in sorted(errors):
+            print >> sys.stderr, error
+          # Return analyzer error code.
+          return e.returncode
+        return 0
+
 
 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()