refactor(compiler): use the new compiler everywhere

Closes #3605

BREAKING CHANGE:
- we don't mark an element as bound any more if it only contains text bindings
  E.g. <div>{{hello}}</div>
  This changes the indices when using `DebugElement.componentViewChildren` / `DebugElement.children`.
- `@Directive.compileChildren` was removed,
  `ng-non-bindable` is now builtin and not a directive any more
- angular no more adds the `ng-binding` class to elements with bindings
- directives are now ordered as they are listed in the View.directives regarding change detection.
  Previously they had an undefined order.
- the `Renderer` interface has new methods `createProtoView` and `registerComponentTemplate`. See `DomRenderer` for default implementations.
- reprojection with `ng-content` is now all or nothing per `ng-content` element
- angular2 transformer can't be used in tests that modify directive metadata.
  Use `angular2/src/transform/inliner_for_test` transformer instead.

modules/angular2/src/web_workers/shared/api.ts

@@ -1,9 +1,75 @@
 import {CONST_EXPR} from "angular2/src/core/facade/lang";
 import {OpaqueToken} from "angular2/src/core/di";
-import {RenderElementRef, RenderViewRef} from "angular2/src/core/render/api";
+import {
+  RenderElementRef,
+  RenderViewRef,
+  RenderTemplateCmd,
+  RenderTextCmd,
+  RenderNgContentCmd,
+  RenderBeginElementCmd,
+  RenderBeginComponentCmd,
+  RenderEmbeddedTemplateCmd,
+  RenderCommandVisitor
+} from "angular2/src/core/render/api";
 
 export const ON_WEB_WORKER = CONST_EXPR(new OpaqueToken('WebWorker.onWebWorker'));
 
 export class WebWorkerElementRef implements RenderElementRef {
   constructor(public renderView: RenderViewRef, public renderBoundElementIndex: number) {}
 }
+
+export class WebWorkerTemplateCmd implements RenderTemplateCmd {
+  visit(visitor: RenderCommandVisitor, context: any): any { return null; }
+}
+
+export class WebWorkerTextCmd implements RenderTextCmd {
+  constructor(public isBound: boolean, public ngContentIndex: number, public value: string) {}
+  visit(visitor: RenderCommandVisitor, context: any): any {
+    return visitor.visitText(this, context);
+  }
+}
+
+export class WebWorkerNgContentCmd implements RenderNgContentCmd {
+  constructor(public ngContentIndex: number) {}
+  visit(visitor: RenderCommandVisitor, context: any): any {
+    return visitor.visitNgContent(this, context);
+  }
+}
+
+export class WebWorkerBeginElementCmd implements RenderBeginElementCmd {
+  constructor(public isBound: boolean, public ngContentIndex: number, public name: string,
+              public attrNameAndValues: string[], public eventTargetAndNames: string[]) {}
+  visit(visitor: RenderCommandVisitor, context: any): any {
+    return visitor.visitBeginElement(this, context);
+  }
+}
+
+export class WebWorkerEndElementCmd implements RenderTemplateCmd {
+  visit(visitor: RenderCommandVisitor, context: any): any {
+    return visitor.visitEndElement(context);
+  }
+}
+
+export class WebWorkerBeginComponentCmd implements RenderBeginComponentCmd {
+  constructor(public isBound: boolean, public ngContentIndex: number, public name: string,
+              public attrNameAndValues: string[], public eventTargetAndNames: string[],
+              public nativeShadow: boolean, public templateId: number) {}
+  visit(visitor: RenderCommandVisitor, context: any): any {
+    return visitor.visitBeginComponent(this, context);
+  }
+}
+
+export class WebWorkerEndComponentCmd implements RenderTemplateCmd {
+  visit(visitor: RenderCommandVisitor, context: any): any {
+    return visitor.visitEndComponent(context);
+  }
+}
+
+export class WebWorkerEmbeddedTemplateCmd implements RenderEmbeddedTemplateCmd {
+  constructor(public isBound: boolean, public ngContentIndex: number, public name: string,
+              public attrNameAndValues: string[], public eventTargetAndNames: string[],
+              public isMerged: boolean, public children: RenderTemplateCmd[]) {}
+  visit(visitor: RenderCommandVisitor, context: any): any {
+    return visitor.visitEmbeddedTemplate(this, context);
+  }
+}

modules/angular2/src/web_workers/shared/messaging_api.ts

@@ -3,7 +3,6 @@
  * You should not use these channels in your application code.
  */
 export const SETUP_CHANNEL = "ng-WebWorkerSetup";
-export const RENDER_COMPILER_CHANNEL = "ng-RenderCompiler";
 export const RENDERER_CHANNEL = "ng-Renderer";
 export const XHR_CHANNEL = "ng-XHR";
 export const EVENT_CHANNEL = "ng-events";

modules/angular2/src/web_workers/shared/render_proto_view_ref_store.ts

@@ -12,41 +12,33 @@ export class RenderProtoViewRefStore {
 
   constructor(@Inject(ON_WEB_WORKER) onWebworker) { this._onWebworker = onWebworker; }
 
-  storeRenderProtoViewRef(ref: RenderProtoViewRef): number {
-    if (this._lookupByProtoView.has(ref)) {
-      return this._lookupByProtoView.get(ref);
-    } else {
-      this._lookupByIndex.set(this._nextIndex, ref);
-      this._lookupByProtoView.set(ref, this._nextIndex);
-      return this._nextIndex++;
-    }
+  allocate(): RenderProtoViewRef {
+    var index = this._nextIndex++;
+    var result = new WebWorkerRenderProtoViewRef(index);
+    this.store(result, index);
+    return result;
   }
 
-  retreiveRenderProtoViewRef(index: number): RenderProtoViewRef {
-    return this._lookupByIndex.get(index);
+  store(ref: RenderProtoViewRef, index: number): void {
+    this._lookupByProtoView.set(ref, index);
+    this._lookupByIndex.set(index, ref);
   }
 
   deserialize(index: number): RenderProtoViewRef {
     if (index == null) {
       return null;
     }
-
-    if (this._onWebworker) {
-      return new WebWorkerRenderProtoViewRef(index);
-    } else {
-      return this.retreiveRenderProtoViewRef(index);
-    }
+    return this._lookupByIndex.get(index);
   }
 
   serialize(ref: RenderProtoViewRef): number {
     if (ref == null) {
       return null;
     }
-
     if (this._onWebworker) {
       return (<WebWorkerRenderProtoViewRef>ref).refNumber;
     } else {
-      return this.storeRenderProtoViewRef(ref);
+      return this._lookupByProtoView.get(ref);
     }
   }
 }

modules/angular2/src/web_workers/shared/serializer.ts

@@ -29,9 +29,26 @@ import {
   RenderElementRef,
   ViewType,
   ViewEncapsulation,
-  PropertyBindingType
+  PropertyBindingType,
+  RenderTemplateCmd,
+  RenderCommandVisitor,
+  RenderTextCmd,
+  RenderNgContentCmd,
+  RenderBeginElementCmd,
+  RenderBeginComponentCmd,
+  RenderEmbeddedTemplateCmd
 } from "angular2/src/core/render/api";
-import {WebWorkerElementRef} from 'angular2/src/web_workers/shared/api';
+import {
+  WebWorkerElementRef,
+  WebWorkerTemplateCmd,
+  WebWorkerTextCmd,
+  WebWorkerNgContentCmd,
+  WebWorkerBeginElementCmd,
+  WebWorkerEndElementCmd,
+  WebWorkerBeginComponentCmd,
+  WebWorkerEndComponentCmd,
+  WebWorkerEmbeddedTemplateCmd
+} from 'angular2/src/web_workers/shared/api';
 import {AST, ASTWithSource} from 'angular2/src/core/change_detection/change_detection';
 import {Parser} from "angular2/src/core/change_detection/parser/parser";
 import {Injectable} from "angular2/src/core/di";
@@ -109,6 +126,8 @@ export class Serializer {
       return this._serializeElementPropertyBinding(obj);
     } else if (type == EventBinding) {
       return this._serializeEventBinding(obj);
+    } else if (type == WebWorkerTemplateCmd) {
+      return serializeTemplateCmd(obj);
     } else {
       throw new BaseException("No serializer for " + type.toString());
     }
@@ -153,6 +172,8 @@ export class Serializer {
       return this._deserializeEventBinding(map);
     } else if (type == ElementPropertyBinding) {
       return this._deserializeElementPropertyBinding(map);
+    } else if (type == WebWorkerTemplateCmd) {
+      return deserializeTemplateCmd(map);
     } else {
       throw new BaseException("No deserializer for " + type.toString());
     }
@@ -406,3 +427,82 @@ export class Serializer {
     });
   }
 }
+
+function serializeTemplateCmd(cmd: RenderTemplateCmd): Object {
+  return cmd.visit(RENDER_TEMPLATE_CMD_SERIALIZER, null);
+}
+
+function deserializeTemplateCmd(data: StringMap<string, any>): RenderTemplateCmd {
+  return RENDER_TEMPLATE_CMD_DESERIALIZERS[data['deserializerIndex']](data);
+}
+
+class RenderTemplateCmdSerializer implements RenderCommandVisitor {
+  visitText(cmd: RenderTextCmd, context: any): any {
+    return {
+      'deserializerIndex': 0,
+      'isBound': cmd.isBound,
+      'ngContentIndex': cmd.ngContentIndex,
+      'value': cmd.value
+    };
+  }
+  visitNgContent(cmd: RenderNgContentCmd, context: any): any {
+    return {'deserializerIndex': 1, 'ngContentIndex': cmd.ngContentIndex};
+  }
+  visitBeginElement(cmd: RenderBeginElementCmd, context: any): any {
+    return {
+      'deserializerIndex': 2,
+      'isBound': cmd.isBound,
+      'ngContentIndex': cmd.ngContentIndex,
+      'name': cmd.name,
+      'attrNameAndValues': cmd.attrNameAndValues,
+      'eventTargetAndNames': cmd.eventTargetAndNames
+    };
+  }
+  visitEndElement(context: any): any { return {'deserializerIndex': 3}; }
+  visitBeginComponent(cmd: RenderBeginComponentCmd, context: any): any {
+    return {
+      'deserializerIndex': 4,
+      'isBound': cmd.isBound,
+      'ngContentIndex': cmd.ngContentIndex,
+      'name': cmd.name,
+      'attrNameAndValues': cmd.attrNameAndValues,
+      'eventTargetAndNames': cmd.eventTargetAndNames,
+      'nativeShadow': cmd.nativeShadow,
+      'templateId': cmd.templateId
+    };
+  }
+  visitEndComponent(context: any): any { return {'deserializerIndex': 5}; }
+  visitEmbeddedTemplate(cmd: RenderEmbeddedTemplateCmd, context: any): any {
+    var children = cmd.children.map(child => child.visit(this, null));
+    return {
+      'deserializerIndex': 6,
+      'isBound': cmd.isBound,
+      'ngContentIndex': cmd.ngContentIndex,
+      'name': cmd.name,
+      'attrNameAndValues': cmd.attrNameAndValues,
+      'eventTargetAndNames': cmd.eventTargetAndNames,
+      'isMerged': cmd.isMerged,
+      'children': children
+    };
+  }
+}
+
+var RENDER_TEMPLATE_CMD_SERIALIZER = new RenderTemplateCmdSerializer();
+
+var RENDER_TEMPLATE_CMD_DESERIALIZERS = [
+  (data: StringMap<string, any>) =>
+      new WebWorkerTextCmd(data['isBound'], data['ngContentIndex'], data['value']),
+  (data: StringMap<string, any>) => new WebWorkerNgContentCmd(data['ngContentIndex']),
+  (data: StringMap<string, any>) =>
+      new WebWorkerBeginElementCmd(data['isBound'], data['ngContentIndex'], data['name'],
+                                   data['attrNameAndValues'], data['eventTargetAndNames']),
+  (data: StringMap<string, any>) => new WebWorkerEndElementCmd(),
+  (data: StringMap<string, any>) => new WebWorkerBeginComponentCmd(
+      data['isBound'], data['ngContentIndex'], data['name'], data['attrNameAndValues'],
+      data['eventTargetAndNames'], data['nativeShadow'], data['templateId']),
+  (data: StringMap<string, any>) => new WebWorkerEndComponentCmd(),
+  (data: StringMap<string, any>) => new WebWorkerEmbeddedTemplateCmd(
+      data['isBound'], data['ngContentIndex'], data['name'], data['attrNameAndValues'],
+      data['eventTargetAndNames'], data['isMerged'],
+      (<any[]>data['children']).map(childData => deserializeTemplateCmd(childData))),
+];

modules/angular2/src/web_workers/ui/di_bindings.ts

@@ -18,7 +18,7 @@ import {
   DomEventsPlugin,
   EVENT_MANAGER_PLUGINS
 } from 'angular2/src/core/render/dom/events/event_manager';
-import {Compiler, CompilerCache} from 'angular2/src/core/compiler/compiler';
+import {ProtoViewFactory} from 'angular2/src/core/compiler/proto_view_factory';
 import {BrowserDomAdapter} from 'angular2/src/core/dom/browser_adapter';
 import {KeyEventsPlugin} from 'angular2/src/core/render/dom/events/key_events';
 import {HammerGesturesPlugin} from 'angular2/src/core/render/dom/events/hammer_gestures';
@@ -46,7 +46,6 @@ import {NgZone} from 'angular2/src/core/zone/ng_zone';
 import {AppViewManager} from 'angular2/src/core/compiler/view_manager';
 import {AppViewManagerUtils} from 'angular2/src/core/compiler/view_manager_utils';
 import {AppViewListener} from 'angular2/src/core/compiler/view_listener';
-import {ProtoViewFactory} from 'angular2/src/core/compiler/proto_view_factory';
 import {ViewResolver} from 'angular2/src/core/compiler/view_resolver';
 import {ViewLoader} from 'angular2/src/core/render/dom/compiler/view_loader';
 import {DirectiveResolver} from 'angular2/src/core/compiler/directive_resolver';
@@ -68,7 +67,6 @@ import {
 import {AnchorBasedAppRootUrl} from 'angular2/src/core/services/anchor_based_app_root_url';
 import {WebWorkerApplication} from 'angular2/src/web_workers/ui/impl';
 import {MessageBus} from 'angular2/src/web_workers/shared/message_bus';
-import {MessageBasedRenderCompiler} from 'angular2/src/web_workers/ui/render_compiler';
 import {MessageBasedRenderer} from 'angular2/src/web_workers/ui/renderer';
 import {MessageBasedXHRImpl} from 'angular2/src/web_workers/ui/xhr_impl';
 import {WebWorkerSetup} from 'angular2/src/web_workers/ui/setup';
@@ -111,14 +109,12 @@ function _injectorBindings(): any[] {
     bind(ElementSchemaRegistry).toValue(new DomElementSchemaRegistry()),
     RenderViewWithFragmentsStore,
     RenderProtoViewRefStore,
-    ProtoViewFactory,
     AppViewPool,
     bind(APP_VIEW_POOL_CAPACITY).toValue(10000),
     AppViewManager,
     AppViewManagerUtils,
     AppViewListener,
-    Compiler,
-    CompilerCache,
+    ProtoViewFactory,
     ViewResolver,
     DEFAULT_PIPES,
     bind(ChangeDetection).toValue(bestChangeDetection),
@@ -138,7 +134,6 @@ function _injectorBindings(): any[] {
     bind(AppRootUrl).toAlias(AnchorBasedAppRootUrl),
     WebWorkerApplication,
     WebWorkerSetup,
-    MessageBasedRenderCompiler,
     MessageBasedXHRImpl,
     MessageBasedRenderer,
     ServiceMessageBrokerFactory,

modules/angular2/src/web_workers/ui/event_serializer.dart

@@ -77,7 +77,6 @@ Map<String, dynamic> serializeKeyboardEvent(dynamic e) {
   serialized['eventPhase'] = e.eventPhase;
   serialized['keyCode'] = e.keyCode;
   serialized['keyLocation'] = e.keyLocation;
-  serialized['layer'] = serializePoint(e.layer);
   serialized['location'] = e.location;
   serialized['repeat'] = e.repeat;
   serialized['shiftKey'] = e.shiftKey;

modules/angular2/src/web_workers/ui/impl.ts

@@ -12,7 +12,6 @@ import {Injectable} from 'angular2/src/core/di';
 import {BrowserDomAdapter} from 'angular2/src/core/dom/browser_adapter';
 import {wtfInit} from 'angular2/src/core/profile/wtf_init';
 import {WebWorkerSetup} from 'angular2/src/web_workers/ui/setup';
-import {MessageBasedRenderCompiler} from 'angular2/src/web_workers/ui/render_compiler';
 import {MessageBasedRenderer} from 'angular2/src/web_workers/ui/renderer';
 import {MessageBasedXHRImpl} from 'angular2/src/web_workers/ui/xhr_impl';
 import {
@@ -35,7 +34,6 @@ export function bootstrapUICommon(bus: MessageBus): WebWorkerApplication {
   bus.attachToZone(zone);
   return zone.run(() => {
     var injector = createInjector(zone, bus);
-    injector.get(MessageBasedRenderCompiler).start();
     injector.get(MessageBasedRenderer).start();
     injector.get(MessageBasedXHRImpl).start();
     injector.get(WebWorkerSetup).start();

modules/angular2/src/web_workers/ui/render_compiler.ts

@@ -1,31 +0,0 @@
-import {Injectable} from 'angular2/src/core/di/decorators';
-import {
-  RenderDirectiveMetadata,
-  ProtoViewDto,
-  ViewDefinition,
-  RenderProtoViewRef,
-  RenderProtoViewMergeMapping,
-  RenderCompiler
-} from 'angular2/src/core/render/api';
-import {RENDER_COMPILER_CHANNEL} from 'angular2/src/web_workers/shared/messaging_api';
-import {bind} from './bind';
-import {ServiceMessageBrokerFactory} from 'angular2/src/web_workers/shared/service_message_broker';
-
-@Injectable()
-export class MessageBasedRenderCompiler {
-  constructor(private _brokerFactory: ServiceMessageBrokerFactory,
-              private _renderCompiler: RenderCompiler) {}
-
-  start(): void {
-    var broker = this._brokerFactory.createMessageBroker(RENDER_COMPILER_CHANNEL, false);
-    broker.registerMethod("compileHost", [RenderDirectiveMetadata],
-                          bind(this._renderCompiler.compileHost, this._renderCompiler),
-                          ProtoViewDto);
-    broker.registerMethod("compile", [ViewDefinition],
-                          bind(this._renderCompiler.compile, this._renderCompiler), ProtoViewDto);
-    broker.registerMethod(
-        "mergeProtoViewsRecursively", [RenderProtoViewRef],
-        bind(this._renderCompiler.mergeProtoViewsRecursively, this._renderCompiler),
-        RenderProtoViewMergeMapping);
-  }
-}

modules/angular2/src/web_workers/ui/renderer.ts

@@ -5,13 +5,15 @@ import {
   RenderViewRef,
   RenderFragmentRef,
   RenderProtoViewRef,
-  Renderer
+  Renderer,
+  RenderTemplateCmd
 } from 'angular2/src/core/render/api';
-import {WebWorkerElementRef} from 'angular2/src/web_workers/shared/api';
+import {WebWorkerElementRef, WebWorkerTemplateCmd} from 'angular2/src/web_workers/shared/api';
 import {EVENT_CHANNEL, RENDERER_CHANNEL} from 'angular2/src/web_workers/shared/messaging_api';
 import {Type} from 'angular2/src/core/facade/lang';
 import {bind} from './bind';
 import {EventDispatcher} from 'angular2/src/web_workers/ui/event_dispatcher';
+import {RenderProtoViewRefStore} from 'angular2/src/web_workers/shared/render_proto_view_ref_store';
 import {
   RenderViewWithFragmentsStore
 } from 'angular2/src/web_workers/shared/render_view_with_fragments_store';
@@ -21,12 +23,18 @@ import {ServiceMessageBrokerFactory} from 'angular2/src/web_workers/shared/servi
 export class MessageBasedRenderer {
   constructor(private _brokerFactory: ServiceMessageBrokerFactory, private _bus: MessageBus,
               private _serializer: Serializer,
+              private _renderProtoViewRefStore: RenderProtoViewRefStore,
               private _renderViewWithFragmentsStore: RenderViewWithFragmentsStore,
               private _renderer: Renderer) {}
 
   start(): void {
     var broker = this._brokerFactory.createMessageBroker(RENDERER_CHANNEL);
     this._bus.initChannel(EVENT_CHANNEL);
+
+    broker.registerMethod("registerComponentTemplate", [PRIMITIVE, WebWorkerTemplateCmd, PRIMITIVE],
+                          bind(this._renderer.registerComponentTemplate, this._renderer));
+    broker.registerMethod("createProtoView", [WebWorkerTemplateCmd, PRIMITIVE],
+                          bind(this._createProtoView, this));
     broker.registerMethod("createRootHostView",
                           [RenderProtoViewRef, PRIMITIVE, PRIMITIVE, PRIMITIVE],
                           bind(this._createRootHostView, this));
@@ -64,6 +72,11 @@ export class MessageBasedRenderer {
     this._renderViewWithFragmentsStore.remove(viewRef);
   }
 
+  private _createProtoView(cmds: RenderTemplateCmd[], refIndex: number) {
+    var protoViewRef = this._renderer.createProtoView(cmds);
+    this._renderProtoViewRefStore.store(protoViewRef, refIndex);
+  }
+
   private _createRootHostView(ref: RenderProtoViewRef, fragmentCount: number, selector: string,
                               startIndex: number) {
     var renderViewWithFragments = this._renderer.createRootHostView(ref, fragmentCount, selector);

modules/angular2/src/web_workers/worker/application.dart

@@ -9,6 +9,7 @@ import "package:angular2/src/core/compiler/dynamic_component_loader.dart" show C
 import "dart:isolate";
 import "dart:async";
 import 'dart:core';
+import 'package:angular2/src/core/dom/webworker_adapter.dart';
 
 /**
  * Bootstrapping a Webworker Application
@@ -24,6 +25,7 @@ import 'dart:core';
 Future<ComponentRef> bootstrapWebWorker(
     SendPort replyTo, Type appComponentType,
     [List<dynamic> componentInjectableBindings = null]) {
+  WebWorkerDomAdapter.makeCurrent();
   ReceivePort rPort = new ReceivePort();
   var sink = new WebWorkerMessageBusSink(replyTo, rPort);
   var source = new IsolateMessageBusSource(rPort);

modules/angular2/src/web_workers/worker/application.ts

@@ -10,6 +10,7 @@ import {Promise} from 'angular2/src/core/facade/async';
 import {bootstrapWebWorkerCommon} from "angular2/src/web_workers/worker/application_common";
 import {ComponentRef} from "angular2/src/core/compiler/dynamic_component_loader";
 export * from "angular2/src/web_workers/shared/message_bus";
+import {Parse5DomAdapter} from 'angular2/src/core/dom/parse5_adapter';
 
 // TODO(jteplitz602) remove this and compile with lib.webworker.d.ts (#3492)
 interface PostMessageInterface {
@@ -29,6 +30,7 @@ var _postMessage: PostMessageInterface = <any>postMessage;
 export function bootstrapWebWorker(
     appComponentType: Type, componentInjectableBindings: Array<Type | Binding | any[]> = null):
     Promise<ComponentRef> {
+  Parse5DomAdapter.makeCurrent();
   var sink = new PostMessageBusSink({
     postMessage: (message: any, transferrables?:[ArrayBuffer]) => {
       console.log("Sending", message);

modules/angular2/src/web_workers/worker/application_common.ts

@@ -14,7 +14,7 @@ import {Promise, PromiseWrapper, PromiseCompleter} from 'angular2/src/core/facad
 import {XHR} from 'angular2/src/core/render/xhr';
 import {WebWorkerXHRImpl} from 'angular2/src/web_workers/worker/xhr_impl';
 import {AppRootUrl} from 'angular2/src/core/services/app_root_url';
-import {WebWorkerRenderer, WebWorkerCompiler} from './renderer';
+import {WebWorkerRenderer} from './renderer';
 import {Renderer, RenderCompiler} from 'angular2/src/core/render/api';
 import {ClientMessageBrokerFactory} from 'angular2/src/web_workers/shared/client_message_broker';
 import {MessageBus} from 'angular2/src/web_workers/shared/message_bus';
@@ -35,6 +35,7 @@ import {SETUP_CHANNEL} from 'angular2/src/web_workers/shared/messaging_api';
 import {WebWorkerEventDispatcher} from 'angular2/src/web_workers/worker/event_dispatcher';
 import {ComponentRef} from 'angular2/src/core/compiler/dynamic_component_loader';
 import {NgZone} from 'angular2/src/core/zone/ng_zone';
+import {compilerBindings} from 'angular2/src/compiler/compiler';
 
 /**
  * Initialize the Angular 'platform' on the page in a manner suitable for applications
@@ -86,13 +87,12 @@ class PrintLogger {
 function webWorkerBindings(appComponentType, bus: MessageBus, initData: StringMap<string, any>):
     Array<Type | Binding | any[]> {
   return [
+    compilerBindings(),
     Serializer,
     bind(MessageBus).toValue(bus),
     ClientMessageBrokerFactory,
     WebWorkerRenderer,
     bind(Renderer).toAlias(WebWorkerRenderer),
-    WebWorkerCompiler,
-    bind(RenderCompiler).toAlias(WebWorkerCompiler),
     bind(ON_WEB_WORKER).toValue(true),
     RenderViewWithFragmentsStore,
     RenderProtoViewRefStore,

modules/angular2/src/web_workers/worker/renderer.ts

@@ -10,9 +10,9 @@ import {
   RenderEventDispatcher,
   RenderProtoViewMergeMapping,
   RenderViewWithFragments,
-  RenderFragmentRef
+  RenderFragmentRef,
+  RenderTemplateCmd
 } from 'angular2/src/core/render/api';
-import {Promise, PromiseWrapper} from "angular2/src/core/facade/async";
 import {
   ClientMessageBroker,
   ClientMessageBrokerFactory,
@@ -21,69 +21,45 @@ import {
 } from "angular2/src/web_workers/shared/client_message_broker";
 import {isPresent, print} from "angular2/src/core/facade/lang";
 import {Injectable} from "angular2/src/core/di";
+import {RenderProtoViewRefStore} from 'angular2/src/web_workers/shared/render_proto_view_ref_store';
 import {
   RenderViewWithFragmentsStore,
   WebWorkerRenderViewRef
 } from 'angular2/src/web_workers/shared/render_view_with_fragments_store';
-import {WebWorkerElementRef} from 'angular2/src/web_workers/shared/api';
-import {
-  RENDER_COMPILER_CHANNEL,
-  RENDERER_CHANNEL
-} from 'angular2/src/web_workers/shared/messaging_api';
+import {WebWorkerElementRef, WebWorkerTemplateCmd} from 'angular2/src/web_workers/shared/api';
+import {RENDERER_CHANNEL} from 'angular2/src/web_workers/shared/messaging_api';
 import {WebWorkerEventDispatcher} from 'angular2/src/web_workers/worker/event_dispatcher';
 
-@Injectable()
-export class WebWorkerCompiler implements RenderCompiler {
-  private _messageBroker;
-  constructor(messageBrokerFactory: ClientMessageBrokerFactory) {
-    this._messageBroker = messageBrokerFactory.createMessageBroker(RENDER_COMPILER_CHANNEL);
-  }
-  /**
-   * Creates a ProtoViewDto that contains a single nested component with the given componentId.
-   */
-  compileHost(directiveMetadata: RenderDirectiveMetadata): Promise<ProtoViewDto> {
-    var fnArgs: FnArg[] = [new FnArg(directiveMetadata, RenderDirectiveMetadata)];
-    var args: UiArguments = new UiArguments("compileHost", fnArgs);
-    return this._messageBroker.runOnService(args, ProtoViewDto);
-  }
-
-  /**
-   * Compiles a single DomProtoView. Non recursive so that
-   * we don't need to serialize all possible components over the wire,
-   * but only the needed ones based on previous calls.
-   */
-  compile(view: ViewDefinition): Promise<ProtoViewDto> {
-    var fnArgs: FnArg[] = [new FnArg(view, ViewDefinition)];
-    var args: UiArguments = new UiArguments("compile", fnArgs);
-    return this._messageBroker.runOnService(args, ProtoViewDto);
-  }
-
-  /**
-   * Merges ProtoViews.
-   * The first entry of the array is the protoview into which all the other entries of the array
-   * should be merged.
-   * If the array contains other arrays, they will be merged before processing the parent array.
-   * The array must contain an entry for every component and embedded ProtoView of the first entry.
-   * @param protoViewRefs Array of ProtoViewRefs or nested
-   * @return the merge result for every input array in depth first order.
-   */
-  mergeProtoViewsRecursively(
-      protoViewRefs: Array<RenderProtoViewRef | any[]>): Promise<RenderProtoViewMergeMapping> {
-    var fnArgs: FnArg[] = [new FnArg(protoViewRefs, RenderProtoViewRef)];
-    var args: UiArguments = new UiArguments("mergeProtoViewsRecursively", fnArgs);
-    return this._messageBroker.runOnService(args, RenderProtoViewMergeMapping);
-  }
-}
-
-
 @Injectable()
 export class WebWorkerRenderer implements Renderer {
   private _messageBroker;
   constructor(messageBrokerFactory: ClientMessageBrokerFactory,
+              private _renderProtoViewRefStore: RenderProtoViewRefStore,
               private _renderViewStore: RenderViewWithFragmentsStore,
               private _eventDispatcher: WebWorkerEventDispatcher) {
     this._messageBroker = messageBrokerFactory.createMessageBroker(RENDERER_CHANNEL);
   }
+
+  registerComponentTemplate(templateId: number, commands: RenderTemplateCmd[], styles: string[]) {
+    var fnArgs = [
+      new FnArg(templateId, null),
+      new FnArg(commands, WebWorkerTemplateCmd),
+      new FnArg(styles, null)
+    ];
+    var args = new UiArguments("registerComponentTemplate", fnArgs);
+    this._messageBroker.runOnService(args, null);
+  }
+
+  createProtoView(cmds: RenderTemplateCmd[]): RenderProtoViewRef {
+    var renderProtoViewRef = this._renderProtoViewRefStore.allocate();
+
+    var fnArgs: FnArg[] =
+        [new FnArg(cmds, WebWorkerTemplateCmd), new FnArg(renderProtoViewRef, RenderProtoViewRef)];
+    var args: UiArguments = new UiArguments("createProtoView", fnArgs);
+    this._messageBroker.runOnService(args, null);
+    return renderProtoViewRef;
+  }
+
   /**
    * Creates a root host view that includes the given element.
    * Note that the fragmentCount needs to be passed in so that we can create a result