refactor(pipes): use Injector instead of pipe factories for pipe instantiation

BREAKING CHANGE
    - Pipe factories have been removed.
    - PIpe names to pipe implementations are 1-to-1  instead of 1-to-*

 Before:
     class DateFormatter {
         transform(date, args){}
     }

     class DateFormatterFactory {
       supporst(obj) { return true; }
       create(cdRef) { return new DateFormatter(); }
     }
     new Pipes({date: [new DateFormatterFactory()]})

After
    class DateFormatter {
      transform(date, args){}
    }
    new Pipes({date: DateFormatter})

modules/angular2/test/core/compiler/integration_spec.ts

@@ -35,7 +35,13 @@ import {
   CONST,
   CONST_EXPR
 } from 'angular2/src/facade/lang';
-import {PromiseWrapper, EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
+import {
+  PromiseWrapper,
+  EventEmitter,
+  ObservableWrapper,
+  PromiseCompleter,
+  Promise
+} from 'angular2/src/facade/async';
 
 import {
   Injector,
@@ -50,7 +56,6 @@ import {
   SkipSelfMetadata
 } from 'angular2/di';
 import {
-  PipeFactory,
   Pipes,
   defaultPipes,
   Pipe,
@@ -673,6 +678,34 @@ export function main() {
 
                          async.done();
                        })}));
+
+        if (DOM.supportsDOMEvents()) {
+          it('should be checked when an async pipe requests a check',
+             inject([TestComponentBuilder], fakeAsync((tcb: TestComponentBuilder) => {
+                      tcb = tcb.overrideView(MyComp, new viewAnn.View({
+                        template: '<push-cmp-with-async #cmp></push-cmp-with-async>',
+                        directives: [[[PushCmpWithAsyncPipe]]]
+                      }));
+
+                      var rootTC;
+                      tcb.createAsync(MyComp).then(root => { rootTC = root; });
+                      tick();
+
+                      var cmp = rootTC.componentViewChildren[0].getLocal('cmp');
+                      rootTC.detectChanges();
+                      expect(cmp.numberOfChecks).toEqual(1);
+
+                      rootTC.detectChanges();
+                      rootTC.detectChanges();
+                      expect(cmp.numberOfChecks).toEqual(1);
+
+                      cmp.resolve(2);
+                      tick();
+
+                      rootTC.detectChanges();
+                      expect(cmp.numberOfChecks).toEqual(2);
+                    })));
+        }
       });
 
       it('should create a component that injects an @Host',
@@ -1607,9 +1640,30 @@ class PushCmpWithRef {
   propagate() { this.ref.requestCheck(); }
 }
 
+@Component({selector: 'push-cmp-with-async', changeDetection: ON_PUSH})
+@View({template: '{{field | async}}'})
+@Injectable()
+class PushCmpWithAsyncPipe {
+  numberOfChecks: number = 0;
+  promise: Promise<any>;
+  completer: PromiseCompleter<any>;
+
+  constructor() {
+    this.completer = PromiseWrapper.completer();
+    this.promise = this.completer.promise;
+  }
+
+  get field() {
+    this.numberOfChecks++;
+    return this.promise;
+  }
+
+  resolve(value) { this.completer.resolve(value); }
+}
+
 @Injectable()
 class PipesWithDouble extends Pipes {
-  constructor() { super({"double": [new DoublePipeFactory()]}); }
+  constructor(injector: Injector) { super({"double": DoublePipe}, injector); }
 }
 
 @Component({
@@ -1703,19 +1757,9 @@ class SomeViewport {
 @Injectable()
 class DoublePipe implements Pipe {
   onDestroy() {}
-
-  supports(obj) { return true; }
-
   transform(value, args = null) { return `${value}${value}`; }
 }
 
-@Injectable()
-class DoublePipeFactory implements PipeFactory {
-  supports(obj) { return true; }
-
-  create(cdRef) { return new DoublePipe(); }
-}
-
 @Directive({selector: '[emitter]', events: ['event']})
 @Injectable()
 class DirectiveEmitingEvent {