Removed fixed dependencies

packages/html/lib/src/list_proxy.dart

 // TODO(jmesserly): remove this once we have a subclassable growable list
 // in our libraries.
 
 /// A [List] proxy that you can subclass.
 library list_proxy;
 
 import 'dart:collection';
 import 'dart:math' show Random;
 
 // TOOD(jmesserly): this needs to be removed, but fixing NodeList is tricky.
 class ListProxy<E> extends IterableBase<E> implements List<E> {
 
   /// The inner [List<T>] with the actual storage.
   final List<E> _list;
 
   /// Creates a list proxy.
   /// You can optionally specify the list to use for [storage] of the items,
   /// otherwise this will create a [List<E>].
   ListProxy([List<E> storage]) : _list = storage != null ? storage : <E>[];
 
   // TODO(jmesserly): This should be on List.
   // See http://code.google.com/p/dart/issues/detail?id=947
-  bool remove(E item) {
-    int i = indexOf(item);
-    if (i == -1) return false;
-    removeAt(i);
-    return true;
+  bool remove(Object item) {
+    if (item is E) {
+      int i = indexOf(item);
+      if (i == -1) return false;
+      removeAt(i);
+      return true;
+    }
+    return false;
   }
 
   void insert(int index, E item) => _list.insert(index, item);
 
   // Override from Iterable to fix performance
   // Length and last become O(1) instead of O(N)
   // The others are just different constant factor.
   int get length => _list.length;
   E get last => _list.last;
   E get first => _list.first;
@@ skipping 36 matching lines @@
   E removeAt(int index) => _list.removeAt(index);
   E removeLast() => _list.removeLast();
 
   void removeWhere(bool test(E element)) => _list.removeWhere(test);
   void retainWhere(bool test(E element)) => _list.retainWhere(test);
 
   List<E> sublist(int start, [int end]) => _list.sublist(start, end);
 
   List<E> getRange(int start, int end) => _list.getRange(start, end);
 
-  void setRange(int start, int length, List<E> from, [int startFrom = 0]) {
+  void setRange(int start, int length, Iterable<E> from, [int startFrom = 0]) {
     _list.setRange(start, length, from, startFrom);
   }
   void removeRange(int start, int length) {
     _list.removeRange(start, length);
   }
   void insertAll(int index, Iterable<E> iterable) {
     _list.insertAll(index, iterable);
   }
 
   Iterable<E> get reversed => _list.reversed;
 
   Map<int, E> asMap() => _list.asMap();
 
   void replaceRange(int start, int end, Iterable<E> newContents) =>
       _list.replaceRange(start, end, newContents);
 
   void setAll(int index, Iterable<E> iterable) => _list.setAll(index, iterable);
 
   void fillRange(int start, int end, [E fillValue]) =>
       _list.fillRange(start, end, fillValue);
 }