Update the Angular/DI tests to latest from github.

third_party/pkg/di/lib/static_injector.dart

 library di.static_injector;
 
 import 'di.dart';
 
-typedef Object TypeFactory(factory(Type));
-
 /**
  * Static implementation of [Injector] that uses type factories
  */
 class StaticInjector extends Injector {
   Map<Type, TypeFactory> typeFactories;
 
   StaticInjector({List<Module> modules, String name,
-                 bool allowImplicitInjection: false, this.typeFactories})
+                 bool allowImplicitInjection: false, typeFactories})
       : super(modules: modules, name: name,
-          allowImplicitInjection: allowImplicitInjection);
+          allowImplicitInjection: allowImplicitInjection) {
+    this.typeFactories = _extractTypeFactories(modules, typeFactories);
+  }
 
   StaticInjector._fromParent(List<Module> modules, Injector parent, {name})
-      : super.fromParent(modules, parent, name: name);
+      : super.fromParent(modules, parent, name: name) {
+    this.typeFactories = _extractTypeFactories(modules);
+  }
 
   newFromParent(List<Module> modules, String name) {
     return new StaticInjector._fromParent(modules, this, name: name);
   }
 
   Object newInstanceOf(Type type, ObjectFactory getInstanceByType,
                        Injector requestor, error) {
-    TypeFactory typeFactory = (root as StaticInjector).typeFactories[type];
+    TypeFactory typeFactory = _getFactory(type);
     if (typeFactory == null) {
       throw new NoProviderError(error('No type factory provided for $type!'));
     }
     return typeFactory((type) => getInstanceByType(type, requestor));
   }
-}
+
+  TypeFactory _getFactory(Type type) {
+    var cursor = this;
+    while (cursor != null) {
+      if (cursor.typeFactories.containsKey(type)) {
+        return cursor.typeFactories[type];
+      }
+      cursor = cursor.parent;
+    }
+    return null;
+  }
+}
+
+Map<Type, TypeFactory> _extractTypeFactories(List<Module> modules,
+    [Map<Type, TypeFactory> initial = const {}]) {
+  if (modules == null || modules.isEmpty) return initial;
+  var tmp = new Map.from(initial == null ? {} : initial);
+  modules.forEach((module) {
+    module.typeFactories.forEach((type, factory) {
+      tmp[type] = factory;
+    });
+  });
+  return tmp;
+}