Removed fixed dependencies

packages/html/lib/src/encoding_parser.dart

 library encoding_parser;
 
 import 'constants.dart';
 import 'inputstream.dart';
 
 // TODO(jmesserly): I converted StopIteration to StateError("No more elements").
 // Seems strange to throw this from outside of an iterator though.
 /// String-like object with an associated position and various extra methods
 /// If the position is ever greater than the string length then an exception is
 /// raised.
@@ skipping 103 matching lines @@
     }
   }
 
   String slice(int start, [int end]) {
     if (end == null) end = length;
     if (end < 0) end += length;
     return _bytes.substring(start, end - start);
   }
 }
 
+typedef bool _MethodHandler();
+
+class _DispatchEntry {
+  final String pattern;
+  final _MethodHandler handler;
+  _DispatchEntry(this.pattern, this.handler);
+}
+
 /// Mini parser for detecting character encoding from meta elements.
 class EncodingParser {
   final EncodingBytes data;
   String encoding;
 
   /// [bytes] - the data to work on for encoding detection.
   EncodingParser(List<int> bytes)
       // Note: this is intentionally interpreting bytes as codepoints.
       : data = new EncodingBytes(new String.fromCharCodes(bytes).toLowerCase());
 
   String getEncoding() {
     final methodDispatch = [
-      ["<!--", handleComment],
-      ["<meta", handleMeta],
-      ["</", handlePossibleEndTag],
-      ["<!", handleOther],
-      ["<?", handleOther],
-      ["<", handlePossibleStartTag]
+        new _DispatchEntry("<!--", handleComment),
+        new _DispatchEntry("<meta", handleMeta),
+        new _DispatchEntry("</", handlePossibleEndTag),
+        new _DispatchEntry("<!", handleOther),
+        new _DispatchEntry("<?", handleOther),
+        new _DispatchEntry("<", handlePossibleStartTag),
     ];
 
     try {
       for (;;) {
         for (var dispatch in methodDispatch) {
-          if (data.matchBytes(dispatch[0])) {
-            var keepParsing = dispatch[1]();
+          if (data.matchBytes(dispatch.pattern)) {
+            var keepParsing = dispatch.handler();
             if (keepParsing) break;
 
             // We found an encoding. Stop.
             return encoding;
           }
         }
         data.position += 1;
       }
-    } on StateError catch (e) {
+    } on StateError catch (_) {
       // Catch this here to match behavior of Python's StopIteration
       // TODO(jmesserly): refactor to not use exceptions
     }
     return encoding;
   }
 
   /// Skip over comments.
   bool handleComment() => data.jumpTo("-->");
 
   bool handleMeta() {
@@ skipping 17 matching lines @@
       } else if (attr[0] == "content") {
         var contentParser = new ContentAttrParser(new EncodingBytes(attr[1]));
         var tentativeEncoding = contentParser.parse();
         var codec = codecName(tentativeEncoding);
         if (codec != null) {
           encoding = codec;
           return false;
         }
       }
     }
-    return true; // unreachable
   }
 
   bool handlePossibleStartTag() => handlePossibleTag(false);
 
   bool handlePossibleEndTag() {
     data.next();
     return handlePossibleTag(true);
   }
 
   bool handlePossibleTag(bool endTag) {
@@ skipping 101 matching lines @@
       if (isSpaceOrAngleBracket(c)) {
         return [attrName.join(), attrValue.join()];
       } else if (c == null) {
         return null;
       } else if (isLetter(c)) {
         attrValue.add(c.toLowerCase());
       } else {
         attrValue.add(c);
       }
     }
-    return null; // unreachable
   }
 }
 
 class ContentAttrParser {
   final EncodingBytes data;
 
   ContentAttrParser(this.data);
 
   String parse() {
     try {
@@ skipping 17 matching lines @@
           return data.slice(oldPosition, data.position);
         } else {
           return null;
         }
       } else {
         // Unquoted value
         var oldPosition = data.position;
         try {
           data.skipUntil(isWhitespace);
           return data.slice(oldPosition, data.position);
-        } on StateError catch (e) {
+        } on StateError catch (_) {
           //Return the whole remaining value
           return data.slice(oldPosition);
         }
       }
-    } on StateError catch (e) {
+    } on StateError catch (_) {
       return null;
     }
   }
 }
 
 bool isSpaceOrAngleBracket(String char) {
   return char == ">" || char == "<" || isWhitespace(char);
 }
 
 typedef bool CharPreciate(String char);