Prune the old deploy code. This CL does a few changes:

pkg/polymer/lib/src/css_analyzer.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /** Portion of the analyzer dealing with CSS sources. */
 library polymer.src.css_analyzer;
 
 import 'package:csslib/parser.dart' as css;
 import 'package:csslib/visitor.dart';
 import 'package:html5lib/dom.dart';
 import 'package:html5lib/dom_parsing.dart';
 
 import 'info.dart';
 import 'files.dart' show SourceFile;
 import 'messages.dart';
 import 'compiler_options.dart';
 
-void analyzeCss(String packageRoot, List<SourceFile> files,
+void analyzeCss(List<SourceFile> files,
                 Map<String, FileInfo> info, Map<String, String> pseudoElements,
                 Messages messages, {warningsAsErrors: false}) {
-  var analyzer = new _AnalyzerCss(packageRoot, info, pseudoElements, messages,
+  var analyzer = new _AnalyzerCss(info, pseudoElements, messages,
       warningsAsErrors);
   for (var file in files) analyzer.process(file);
   analyzer.normalize();
 }
 
 class _AnalyzerCss {
-  final String packageRoot;
   final Map<String, FileInfo> info;
   final Map<String, String> _pseudoElements;
   final Messages _messages;
   final bool _warningsAsErrors;
 
   Set<StyleSheet> allStyleSheets = new Set<StyleSheet>();
 
   /**
    * [_pseudoElements] list of known pseudo attributes found in HTML, any
    * CSS pseudo-elements 'name::custom-element' is mapped to the manged name
    * associated with the pseudo-element key.
    */
-  _AnalyzerCss(this.packageRoot, this.info, this._pseudoElements,
+  _AnalyzerCss(this.info, this._pseudoElements,
                this._messages, this._warningsAsErrors);
 
   /**
    * Run the analyzer on every file that is a style sheet or any component that
    * has a style tag.
    */
   void process(SourceFile file) {
     var fileInfo = info[file.path];
     if (file.isStyleSheet || fileInfo.styleSheets.length > 0) {
       var styleSheets = processVars(fileInfo);
@@ skipping 78 matching lines @@
       if (!seen.contains(styleSheet)) {
         // TODO(terry): VM uses expandos to implement hashes.  Currently, it's a
         //              linear (not constant) time cost (see dartbug.com/5746).
         //              If this bug isn't fixed and performance show's this a
         //              a problem we'll need to implement our own hashCode or
         //              use a different key for better perf.
         // Add the stylesheet.
         seen.add(styleSheet);
 
         // Any other imports in this stylesheet?
-        var urlInfos = findImportsInStyleSheet(styleSheet, packageRoot,
-            inputUrl, _messages);
+        var urlInfos = findImportsInStyleSheet(styleSheet, inputUrl, _messages);
 
         // Process other imports in this stylesheets.
         for (var importSS in urlInfos) {
           var importInfo = info[importSS.resolvedPath];
           if (importInfo != null) {
             // Add all known stylesheets processed.
             seen.addAll(importInfo.styleSheets);
             // Find dependencies for stylesheet referenced with a
             // @import
             for (var ss in importInfo.styleSheets) {
-              var urls = findImportsInStyleSheet(ss, packageRoot, inputUrl,
-                  _messages);
+              var urls = findImportsInStyleSheet(ss, inputUrl, _messages);
               for (var url in urls) {
                 _dependencies(info[url.resolvedPath], seen: seen);
               }
             }
           }
         }
       }
     }
 
     return seen;
@@ skipping 188 matching lines @@
                   css.TokenKind.COMBINATOR_GREATER);
           selectors.insert(++index,
               new SimpleSelectorSequence(attrSelector, span));
         }
       }
     }
   }
 }
 
 List<UrlInfo> findImportsInStyleSheet(StyleSheet styleSheet,
-    String packageRoot, UrlInfo inputUrl, Messages messages) {
-  var visitor = new _CssImports(packageRoot, inputUrl, messages);
+    UrlInfo inputUrl, Messages messages) {
+  var visitor = new _CssImports(inputUrl, messages);
   visitor.visitTree(styleSheet);
   return visitor.urlInfos;
 }
 
 /**
  * Find any imports in the style sheet; normalize the style sheet href and
  * return a list of all fully qualified CSS files.
  */
 class _CssImports extends Visitor {
-  final String packageRoot;
-
   /** Input url of the css file, used to normalize relative import urls. */
   final UrlInfo inputUrl;
 
   /** List of all imported style sheets. */
   final List<UrlInfo> urlInfos = [];
 
   final Messages _messages;
 
-  _CssImports(this.packageRoot, this.inputUrl, this._messages);
+  _CssImports(this.inputUrl, this._messages);
 
   void visitTree(StyleSheet tree) {
     visitStyleSheet(tree);
   }
 
   void visitImportDirective(ImportDirective node) {
     var urlInfo = UrlInfo.resolve(node.import, inputUrl,
-        node.span, packageRoot, _messages, ignoreAbsolute: true);
+        node.span, _messages, ignoreAbsolute: true);
     if (urlInfo == null) return;
     urlInfos.add(urlInfo);
   }
 }
 
 StyleSheet parseCss(String content, Messages messages,
     CompilerOptions options) {
   if (content.trim().isEmpty) return null;
 
   var errors = [];
@@ skipping 47 matching lines @@
 
 /**
  * Find urls imported inside style tags under [info].  If [info] is a FileInfo
  * then process only style tags in the body (don't process any style tags in a
  * component).  If [info] is a ComponentInfo only process style tags inside of
  * the element are processed.  For an [info] of type FileInfo [node] is the
  * file's document and for an [info] of type ComponentInfo then [node] is the
  * component's element tag.
  */
 List<UrlInfo> findUrlsImported(LibraryInfo info, UrlInfo inputUrl,
-    String packageRoot, Node node, Messages messages, CompilerOptions options) {
+    Node node, Messages messages, CompilerOptions options) {
   // Process any @imports inside of the <style> tag.
   var styleProcessor =
-      new _CssStyleTag(packageRoot, info, inputUrl, messages, options);
+      new _CssStyleTag(info, inputUrl, messages, options);
   styleProcessor.visit(node);
   return styleProcessor.imports;
 }
 
 /* Process CSS inside of a style tag. */
 class _CssStyleTag extends TreeVisitor {
-  final String _packageRoot;
-
   /** Either a FileInfo or ComponentInfo. */
   final LibraryInfo _info;
   final Messages _messages;
   final CompilerOptions _options;
 
   /**
    * Path of the declaring file, for a [_info] of type FileInfo it's the file's
    * path for a type ComponentInfo it's the declaring file path.
    */
   final UrlInfo _inputUrl;
 
   /** List of @imports found. */
   List<UrlInfo> imports = [];
 
-  _CssStyleTag(this._packageRoot, this._info, this._inputUrl, this._messages,
+  _CssStyleTag(this._info, this._inputUrl, this._messages,
       this._options);
 
   void visitElement(Element node) {
     // Don't process any style tags inside of element if we're processing a
     // FileInfo.  The style tags inside of a component defintion will be
     // processed when _info is a ComponentInfo.
     if (node.tagName == 'polymer-element' && _info is FileInfo) return;
     if (node.tagName == 'style') {
       // Parse the contents of the scoped style tag.
       var styleSheet = parseCss(node.nodes.single.value, _messages, _options);
       if (styleSheet != null) {
         _info.styleSheets.add(styleSheet);
 
         // Find all imports return list of @imports in this style tag.
-        var urlInfos = findImportsInStyleSheet(styleSheet, _packageRoot,
+        var urlInfos = findImportsInStyleSheet(styleSheet,
             _inputUrl, _messages);
         imports.addAll(urlInfos);
       }
     }
     super.visitElement(node);
   }
 }