refactor(render): use render layer fully

Introduces angular2/src/core/compiler/ViewFactory which
extracts ProtoView.instantiate and replaces ViewPool.

Note: This is a work in progress commit to unblock other commits.
There will be follow ups to add unit tests, remove TODOs, …

modules/benchmarks/src/largetable/largetable_benchmark.js

@@ -8,9 +8,9 @@ import {CompilerCache} from 'angular2/src/core/compiler/compiler';
 import {DirectiveMetadataReader} from 'angular2/src/core/compiler/directive_metadata_reader';
 import {TemplateLoader} from 'angular2/src/render/dom/compiler/template_loader';
 import {TemplateResolver} from 'angular2/src/core/compiler/template_resolver';
-import {ShadowDomStrategy, NativeShadowDomStrategy, EmulatedUnscopedShadowDomStrategy} from 'angular2/src/core/compiler/shadow_dom_strategy';
-import {Content} from 'angular2/src/core/compiler/shadow_dom_emulation/content_tag';
-import {DestinationLightDom} from 'angular2/src/core/compiler/shadow_dom_emulation/light_dom';
+import {ShadowDomStrategy} from 'angular2/src/render/dom/shadow_dom/shadow_dom_strategy';
+import {NativeShadowDomStrategy} from 'angular2/src/render/dom/shadow_dom/native_shadow_dom_strategy';
+import {EmulatedUnscopedShadowDomStrategy} from 'angular2/src/render/dom/shadow_dom/emulated_unscoped_shadow_dom_strategy';
 import {LifeCycle} from 'angular2/src/core/life_cycle/life_cycle';
 import {UrlResolver} from 'angular2/src/services/url_resolver';
 import {StyleUrlResolver} from 'angular2/src/render/dom/shadow_dom/style_url_resolver';
@@ -36,6 +36,14 @@ import {EventManager} from 'angular2/src/render/dom/events/event_manager';
 import {ListWrapper} from 'angular2/src/facade/collection';
 import {Parent} from 'angular2/src/core/annotations/visibility';
 
+import {ViewFactory, VIEW_POOL_CAPACITY} from 'angular2/src/core/compiler/view_factory';
+import {ProtoViewFactory} from 'angular2/src/core/compiler/proto_view_factory';
+import {Renderer} from 'angular2/src/render/api';
+import {DirectDomRenderer} from 'angular2/src/render/dom/direct_dom_renderer';
+import * as rc from 'angular2/src/render/dom/compiler/compiler';
+import * as rvf from 'angular2/src/render/dom/view/view_factory';
+import {Inject} from 'angular2/di';
+
 var BASELINE_LARGETABLE_TEMPLATE;
 
 function setupReflector() {
@@ -139,8 +147,8 @@ function setupReflector() {
   });
 
   reflector.registerType(SwitchWhen, {
-    'factory': (el, vc, ss) => new SwitchWhen(el, vc, ss),
-    'parameters': [[NgElement],[ViewContainer],[Switch, new Parent()]],
+    'factory': (vc, ss) => new SwitchWhen(vc, ss),
+    'parameters': [[ViewContainer],[Switch, new Parent()]],
     'annotations' : [new Viewport({
         selector: '[switch-when]',
         bind: {
@@ -158,14 +166,13 @@ function setupReflector() {
   });
 
   reflector.registerType(Compiler, {
-    'factory': (cd, templateLoader, reader, parser, compilerCache, strategy, tplResolver,
-      cmpUrlMapper, urlResolver) =>
-      new Compiler(cd, templateLoader, reader, parser, compilerCache, strategy, tplResolver,
-        cmpUrlMapper, urlResolver),
-    'parameters': [[ChangeDetection], [TemplateLoader], [DirectiveMetadataReader],
-                   [Parser], [CompilerCache], [ShadowDomStrategy], [TemplateResolver],
-                   [ComponentUrlMapper], [UrlResolver]],
-    'annotations': []
+    "factory": (reader, compilerCache, tplResolver, cmpUrlMapper, urlResolver, renderer,
+                protoViewFactory) =>
+      new Compiler(reader, compilerCache, tplResolver, cmpUrlMapper, urlResolver, renderer,
+                protoViewFactory),
+    "parameters": [[DirectiveMetadataReader], [CompilerCache], [TemplateResolver], [ComponentUrlMapper],
+                   [UrlResolver], [Renderer], [ProtoViewFactory]],
+    "annotations": []
   });
 
   reflector.registerType(CompilerCache, {
@@ -240,12 +247,6 @@ function setupReflector() {
     "annotations": []
   });
 
-  reflector.registerType(Content, {
-    "factory": (lightDom, el) => new Content(lightDom, el),
-    "parameters": [[DestinationLightDom], [NgElement]],
-    "annotations" : [new Decorator({selector: '[content]'})]
-  });
-
   reflector.registerType(UrlResolver, {
     "factory": () => new UrlResolver(),
     "parameters": [],
@@ -290,12 +291,58 @@ function setupReflector() {
   });
 
   reflector.registerType(PrivateComponentLoader, {
-    "factory": (compiler, strategy, eventMgr, reader) =>
-      new PrivateComponentLoader(compiler, strategy, eventMgr, reader),
-    "parameters": [[Compiler], [ShadowDomStrategy], [EventManager], [DirectiveMetadataReader]],
+    "factory": (compiler, reader, viewFactory) =>
+      new PrivateComponentLoader(compiler, reader, viewFactory),
+    "parameters": [[Compiler], [DirectiveMetadataReader], [ViewFactory]],
     "annotations": []
   });
 
+  reflector.registerType(DirectDomRenderer, {
+    "factory": (renderCompiler, renderViewFactory, shadowDomStrategy) =>
+      new DirectDomRenderer(renderCompiler, renderViewFactory, shadowDomStrategy),
+    "parameters": [[rc.Compiler], [rvf.ViewFactory], [ShadowDomStrategy]],
+    "annotations": []
+  });
+
+  reflector.registerType(rc.DefaultCompiler, {
+    "factory": (parser, shadowDomStrategy, templateLoader) =>
+      new rc.DefaultCompiler(parser, shadowDomStrategy, templateLoader),
+    "parameters": [[Parser], [ShadowDomStrategy], [TemplateLoader]],
+    "annotations": []
+  });
+
+  reflector.registerType(rvf.ViewFactory, {
+    "factory": (capacity, eventManager, shadowDomStrategy) =>
+      new rvf.ViewFactory(capacity, eventManager, shadowDomStrategy),
+    "parameters": [[new Inject(rvf.VIEW_POOL_CAPACITY)], [EventManager], [ShadowDomStrategy]],
+    "annotations": []
+  });
+
+  reflector.registerType(rvf.VIEW_POOL_CAPACITY, {
+    "factory": () => 100000,
+    "parameters": [],
+    "annotations": []
+  });
+
+  reflector.registerType(ProtoViewFactory, {
+    "factory": (changeDetection, renderer) =>
+      new ProtoViewFactory(changeDetection, renderer),
+    "parameters": [[ChangeDetection], [Renderer]],
+    "annotations": []
+  });
+
+  reflector.registerType(ViewFactory, {
+    "factory": (capacity) =>
+      new ViewFactory(capacity),
+    "parameters": [[new Inject(VIEW_POOL_CAPACITY)]],
+    "annotations": []
+  });
+
+  reflector.registerType(VIEW_POOL_CAPACITY, {
+    "factory": () => 100000,
+    "parameters": [],
+    "annotations": []
+  });
 
   reflector.registerGetters({
     'data': (a) => a.data,