fix(WebWorker): remove the platform-browser dependency on compiler

modules/@angular/platform-browser/src/web_workers/shared/api.ts

@@ -1,3 +1,3 @@
-import {OpaqueToken} from '@angular/core/src/di';
+import {OpaqueToken} from '@angular/core';
 
 export const ON_WEB_WORKER = /*@ts2dart_const*/ new OpaqueToken('WebWorker.onWebWorker');

modules/@angular/platform-browser/src/web_workers/shared/message_bus.ts

@@ -1,6 +1,5 @@
 import {EventEmitter} from '../../../src/facade/async';
-import {NgZone} from '@angular/core/src/zone/ng_zone';
-export {EventEmitter, Observable} from '../../../src/facade/async';
+import {NgZone} from '@angular/core';
 
 /**
  * Message Bus is a low level API used to communicate between the UI and the background.

modules/@angular/platform-browser/src/web_workers/shared/messaging_api.ts

@@ -3,6 +3,5 @@
  * You should not use these channels in your application code.
  */
 export const RENDERER_CHANNEL = "ng-Renderer";
-export const XHR_CHANNEL = "ng-XHR";
 export const EVENT_CHANNEL = "ng-Events";
 export const ROUTER_CHANNEL = "ng-Router";

modules/@angular/platform-browser/src/web_workers/shared/post_message_bus.ts

@@ -2,8 +2,7 @@ import {MessageBus, MessageBusSource, MessageBusSink} from './message_bus';
 import {BaseException} from '../../../src/facade/exceptions';
 import {EventEmitter, ObservableWrapper} from '../../../src/facade/async';
 import {StringMapWrapper} from '../../../src/facade/collection';
-import {Injectable} from '@angular/core/src/di';
-import {NgZone} from '@angular/core/src/zone/ng_zone';
+import {Injectable, NgZone} from '@angular/core';
 
 // TODO(jteplitz602) Replace this with the definition in lib.webworker.d.ts(#3492)
 export interface PostMessageTarget { postMessage: (message: any, transfer?:[ArrayBuffer]) => void; }

modules/@angular/platform-browser/src/web_workers/shared/render_store.ts

@@ -1,4 +1,4 @@
-import {Injectable} from '@angular/core/src/di';
+import {Injectable} from '@angular/core';
 
 @Injectable()
 export class RenderStore {

modules/@angular/platform-browser/src/web_workers/shared/service_message_broker.ts

@@ -1,4 +1,4 @@
-import {Injectable} from '@angular/core/src/di';
+import {Injectable} from '@angular/core';
 import {ListWrapper, Map} from '../../../src/facade/collection';
 import {Serializer} from '../shared/serializer';
 import {isPresent, Type, FunctionWrapper} from '../../../src/facade/lang';

modules/@angular/platform-browser/src/web_workers/ui/bind.dart

@@ -1,11 +0,0 @@
-library angular2.src.web_workers.ui.bind;
-
-/**
- * Binding is not necessary in dart.
- * This method just returns the passed function regardless of scope.
- * It's only here to match the TypeScript implementation.
- * TODO(jteplitz602) Have ts2dart remove calls to bind(#3820)
- */
-Function bind(Function fn, dynamic scope) {
-  return fn;
-}

modules/@angular/platform-browser/src/web_workers/ui/bind.ts

@@ -1,3 +0,0 @@
-export function bind(fn: Function, scope: any): Function {
-  return fn.bind(scope);
-}

modules/@angular/platform-browser/src/web_workers/ui/location_providers.ts

@@ -0,0 +1,21 @@
+import {MessageBasedPlatformLocation} from './platform_location';
+import {BrowserPlatformLocation} from '../../browser/location/browser_platform_location';
+import {APP_INITIALIZER, Injector, NgZone} from '@angular/core';
+
+/**
+ * A list of {@link Provider}s. To use the router in a Worker enabled application you must
+ * include these providers when setting up the render thread.
+ */
+export const WORKER_RENDER_LOCATION_PROVIDERS = /*@ts2dart_const*/[
+  MessageBasedPlatformLocation,
+  BrowserPlatformLocation,
+  /* @ts2dart_Provider */ {provide: APP_INITIALIZER, useFactory: initUiLocation, multi: true, deps: [Injector]}
+];
+
+function initUiLocation(injector: Injector): () => void {
+  return () => {
+    let zone = injector.get(NgZone);
+
+    zone.runGuarded(() => injector.get(MessageBasedPlatformLocation).start());
+  };
+}

modules/@angular/platform-browser/src/web_workers/ui/platform_location.ts

@@ -1,15 +1,13 @@
-import {
-  BrowserPlatformLocation
-} from '@angular/platform-browser/src/browser/location/browser_platform_location';
+import {BrowserPlatformLocation} from '../../browser/location/browser_platform_location';
 import {UrlChangeListener} from '@angular/common';
-import {Injectable} from '@angular/core/src/di';
+import {Injectable} from '@angular/core';
 import {ROUTER_CHANNEL} from '../shared/messaging_api';
 import {ServiceMessageBrokerFactory, ServiceMessageBroker} from '../shared/service_message_broker';
 import {PRIMITIVE, Serializer} from '../shared/serializer';
-import {bind} from './bind';
 import {LocationType} from '../shared/serialized_types';
 import {MessageBus} from '../shared/message_bus';
 import {EventEmitter, ObservableWrapper, PromiseWrapper} from '../../../src/facade/async';
+import {FunctionWrapper} from '../../../src/facade/lang';
 
 @Injectable()
 export class MessageBasedPlatformLocation {
@@ -19,23 +17,30 @@ export class MessageBasedPlatformLocation {
   constructor(private _brokerFactory: ServiceMessageBrokerFactory,
               private _platformLocation: BrowserPlatformLocation, bus: MessageBus,
               private _serializer: Serializer) {
-    this._platformLocation.onPopState(<UrlChangeListener>bind(this._sendUrlChangeEvent, this));
-    this._platformLocation.onHashChange(<UrlChangeListener>bind(this._sendUrlChangeEvent, this));
+    this._platformLocation.onPopState(
+        <UrlChangeListener>FunctionWrapper.bind(this._sendUrlChangeEvent, this));
+    this._platformLocation.onHashChange(
+        <UrlChangeListener>FunctionWrapper.bind(this._sendUrlChangeEvent, this));
     this._broker = this._brokerFactory.createMessageBroker(ROUTER_CHANNEL);
     this._channelSink = bus.to(ROUTER_CHANNEL);
   }
 
   start(): void {
-    this._broker.registerMethod("getLocation", null, bind(this._getLocation, this), LocationType);
-    this._broker.registerMethod("setPathname", [PRIMITIVE], bind(this._setPathname, this));
-    this._broker.registerMethod("pushState", [PRIMITIVE, PRIMITIVE, PRIMITIVE],
-                                bind(this._platformLocation.pushState, this._platformLocation));
-    this._broker.registerMethod("replaceState", [PRIMITIVE, PRIMITIVE, PRIMITIVE],
-                                bind(this._platformLocation.replaceState, this._platformLocation));
-    this._broker.registerMethod("forward", null,
-                                bind(this._platformLocation.forward, this._platformLocation));
-    this._broker.registerMethod("back", null,
-                                bind(this._platformLocation.back, this._platformLocation));
+    this._broker.registerMethod("getLocation", null, FunctionWrapper.bind(this._getLocation, this),
+                                LocationType);
+    this._broker.registerMethod("setPathname", [PRIMITIVE],
+                                FunctionWrapper.bind(this._setPathname, this));
+    this._broker.registerMethod(
+        "pushState", [PRIMITIVE, PRIMITIVE, PRIMITIVE],
+        FunctionWrapper.bind(this._platformLocation.pushState, this._platformLocation));
+    this._broker.registerMethod(
+        "replaceState", [PRIMITIVE, PRIMITIVE, PRIMITIVE],
+        FunctionWrapper.bind(this._platformLocation.replaceState, this._platformLocation));
+    this._broker.registerMethod(
+        "forward", null,
+        FunctionWrapper.bind(this._platformLocation.forward, this._platformLocation));
+    this._broker.registerMethod(
+        "back", null, FunctionWrapper.bind(this._platformLocation.back, this._platformLocation));
   }
 
   private _getLocation(): Promise<Location> {

modules/@angular/platform-browser/src/web_workers/ui/renderer.ts

@@ -1,12 +1,11 @@
-import {Injectable} from '@angular/core/src/di';
+import {Injectable, RootRenderer, Renderer, RenderComponentType} from '@angular/core';
 import {MessageBus} from '../shared/message_bus';
 import {Serializer, PRIMITIVE, RenderStoreObject} from '../shared/serializer';
-import {RootRenderer, Renderer, RenderComponentType} from '@angular/core/src/render/api';
 import {EVENT_CHANNEL, RENDERER_CHANNEL} from '../shared/messaging_api';
-import {bind} from './bind';
 import {EventDispatcher} from '../ui/event_dispatcher';
 import {RenderStore} from '../shared/render_store';
 import {ServiceMessageBrokerFactory} from '../shared/service_message_broker';
+import {FunctionWrapper} from '../../facade/lang';
 
 @Injectable()
 export class MessageBasedRenderer {
@@ -22,55 +21,55 @@ export class MessageBasedRenderer {
     this._eventDispatcher = new EventDispatcher(this._bus.to(EVENT_CHANNEL), this._serializer);
 
     broker.registerMethod("renderComponent", [RenderComponentType, PRIMITIVE],
-                          bind(this._renderComponent, this));
+                          FunctionWrapper.bind(this._renderComponent, this));
 
     broker.registerMethod("selectRootElement", [RenderStoreObject, PRIMITIVE, PRIMITIVE],
-                          bind(this._selectRootElement, this));
+                          FunctionWrapper.bind(this._selectRootElement, this));
     broker.registerMethod("createElement",
                           [RenderStoreObject, RenderStoreObject, PRIMITIVE, PRIMITIVE],
-                          bind(this._createElement, this));
+                          FunctionWrapper.bind(this._createElement, this));
     broker.registerMethod("createViewRoot", [RenderStoreObject, RenderStoreObject, PRIMITIVE],
-                          bind(this._createViewRoot, this));
+                          FunctionWrapper.bind(this._createViewRoot, this));
     broker.registerMethod("createTemplateAnchor", [RenderStoreObject, RenderStoreObject, PRIMITIVE],
-                          bind(this._createTemplateAnchor, this));
+                          FunctionWrapper.bind(this._createTemplateAnchor, this));
     broker.registerMethod("createText",
                           [RenderStoreObject, RenderStoreObject, PRIMITIVE, PRIMITIVE],
-                          bind(this._createText, this));
+                          FunctionWrapper.bind(this._createText, this));
     broker.registerMethod("projectNodes", [RenderStoreObject, RenderStoreObject, RenderStoreObject],
-                          bind(this._projectNodes, this));
+                          FunctionWrapper.bind(this._projectNodes, this));
     broker.registerMethod("attachViewAfter",
                           [RenderStoreObject, RenderStoreObject, RenderStoreObject],
-                          bind(this._attachViewAfter, this));
+                          FunctionWrapper.bind(this._attachViewAfter, this));
     broker.registerMethod("detachView", [RenderStoreObject, RenderStoreObject],
-                          bind(this._detachView, this));
+                          FunctionWrapper.bind(this._detachView, this));
     broker.registerMethod("destroyView", [RenderStoreObject, RenderStoreObject, RenderStoreObject],
-                          bind(this._destroyView, this));
+                          FunctionWrapper.bind(this._destroyView, this));
     broker.registerMethod("setElementProperty",
                           [RenderStoreObject, RenderStoreObject, PRIMITIVE, PRIMITIVE],
-                          bind(this._setElementProperty, this));
+                          FunctionWrapper.bind(this._setElementProperty, this));
     broker.registerMethod("setElementAttribute",
                           [RenderStoreObject, RenderStoreObject, PRIMITIVE, PRIMITIVE],
-                          bind(this._setElementAttribute, this));
+                          FunctionWrapper.bind(this._setElementAttribute, this));
     broker.registerMethod("setBindingDebugInfo",
                           [RenderStoreObject, RenderStoreObject, PRIMITIVE, PRIMITIVE],
-                          bind(this._setBindingDebugInfo, this));
+                          FunctionWrapper.bind(this._setBindingDebugInfo, this));
     broker.registerMethod("setElementClass",
                           [RenderStoreObject, RenderStoreObject, PRIMITIVE, PRIMITIVE],
-                          bind(this._setElementClass, this));
+                          FunctionWrapper.bind(this._setElementClass, this));
     broker.registerMethod("setElementStyle",
                           [RenderStoreObject, RenderStoreObject, PRIMITIVE, PRIMITIVE],
-                          bind(this._setElementStyle, this));
+                          FunctionWrapper.bind(this._setElementStyle, this));
     broker.registerMethod("invokeElementMethod",
                           [RenderStoreObject, RenderStoreObject, PRIMITIVE, PRIMITIVE],
-                          bind(this._invokeElementMethod, this));
+                          FunctionWrapper.bind(this._invokeElementMethod, this));
     broker.registerMethod("setText", [RenderStoreObject, RenderStoreObject, PRIMITIVE],
-                          bind(this._setText, this));
+                          FunctionWrapper.bind(this._setText, this));
     broker.registerMethod("listen", [RenderStoreObject, RenderStoreObject, PRIMITIVE, PRIMITIVE],
-                          bind(this._listen, this));
+                          FunctionWrapper.bind(this._listen, this));
     broker.registerMethod("listenGlobal", [RenderStoreObject, PRIMITIVE, PRIMITIVE, PRIMITIVE],
-                          bind(this._listenGlobal, this));
+                          FunctionWrapper.bind(this._listenGlobal, this));
     broker.registerMethod("listenDone", [RenderStoreObject, RenderStoreObject],
-                          bind(this._listenDone, this));
+                          FunctionWrapper.bind(this._listenDone, this));
   }
 
   private _renderComponent(renderComponentType: RenderComponentType, rendererId: number) {

modules/@angular/platform-browser/src/web_workers/ui/router_providers.ts

@@ -1,19 +0,0 @@
-import {MessageBasedPlatformLocation} from './platform_location';
-import {
-  BrowserPlatformLocation
-} from '@angular/platform-browser/src/browser/location/browser_platform_location';
-import {APP_INITIALIZER, Provider, Injector, NgZone} from '@angular/core';
-
-export const WORKER_RENDER_ROUTER = /*@ts2dart_const*/[
-  MessageBasedPlatformLocation,
-  BrowserPlatformLocation,
-  /* @ts2dart_Provider */ {provide: APP_INITIALIZER, useFactory: initRouterListeners, multi: true, deps: [Injector]}
-];
-
-function initRouterListeners(injector: Injector): () => void {
-  return () => {
-    let zone = injector.get(NgZone);
-
-    zone.runGuarded(() => injector.get(MessageBasedPlatformLocation).start());
-  };
-}

modules/@angular/platform-browser/src/web_workers/ui/xhr_impl.ts

@@ -1,16 +0,0 @@
-import {Injectable} from '@angular/core';
-import {PRIMITIVE} from '../shared/serializer';
-import {XHR_CHANNEL} from '../shared/messaging_api';
-import {XHR} from '@angular/compiler';
-import {ServiceMessageBrokerFactory} from '../shared/service_message_broker';
-import {bind} from './bind';
-
-@Injectable()
-export class MessageBasedXHRImpl {
-  constructor(private _brokerFactory: ServiceMessageBrokerFactory, private _xhr: XHR) {}
-
-  start(): void {
-    var broker = this._brokerFactory.createMessageBroker(XHR_CHANNEL);
-    broker.registerMethod("get", [PRIMITIVE], bind(this._xhr.get, this._xhr), PRIMITIVE);
-  }
-}

modules/@angular/platform-browser/src/web_workers/worker/location_providers.ts

@@ -0,0 +1,22 @@
+import {NgZone, APP_INITIALIZER} from '@angular/core';
+import {PlatformLocation} from '@angular/common';
+import {WebWorkerPlatformLocation} from './platform_location';
+
+/**
+ * Those providers should be added when the router is used in a worker context in addition to the
+ * {@link ROUTER_PROVIDERS} and after them.
+ */
+export const WORKER_APP_LOCATION_PROVIDERS = /*@ts2dart_const*/[
+  /* @ts2dart_Provider */ {provide: PlatformLocation, useClass: WebWorkerPlatformLocation},
+  {
+    provide: APP_INITIALIZER,
+    useFactory: (platformLocation: WebWorkerPlatformLocation, zone: NgZone) => () =>
+                    initWorkerLocation(platformLocation, zone),
+    multi: true,
+    deps: [PlatformLocation, NgZone]
+  }
+];
+
+function initWorkerLocation(platformLocation: WebWorkerPlatformLocation, zone: NgZone): Promise<boolean> {
+  return zone.runGuarded(() => platformLocation.init());
+}

modules/@angular/platform-browser/src/web_workers/worker/platform_location.ts

@@ -1,11 +1,11 @@
-import {Injectable} from '@angular/core/src/di';
+import {Injectable} from '@angular/core';
 import {
   FnArg,
   UiArguments,
   ClientMessageBroker,
   ClientMessageBrokerFactory
 } from '../shared/client_message_broker';
-import {PlatformLocation, UrlChangeEvent, UrlChangeListener} from '@angular/common';
+import {PlatformLocation, UrlChangeListener} from '@angular/common';
 import {ROUTER_CHANNEL} from '../shared/messaging_api';
 import {LocationType} from '../shared/serialized_types';
 import {PromiseWrapper, EventEmitter, ObservableWrapper} from '../../../src/facade/async';

modules/@angular/platform-browser/src/web_workers/worker/renderer.ts

@@ -2,24 +2,19 @@ import {
   Renderer,
   RootRenderer,
   RenderComponentType,
-  RenderDebugInfo
-} from '@angular/core/src/render/api';
-import {
-  ClientMessageBroker,
-  ClientMessageBrokerFactory,
-  FnArg,
-  UiArguments
-} from '../shared/client_message_broker';
-import {isPresent, isBlank, print} from '../../../src/facade/lang';
+  Injectable,
+  ViewEncapsulation
+} from '@angular/core';
+import {RenderDebugInfo} from '../../../core_private';
+
+import {ClientMessageBrokerFactory, FnArg, UiArguments} from '../shared/client_message_broker';
+import {isPresent, isBlank} from '../../../src/facade/lang';
 import {ListWrapper} from '../../../src/facade/collection';
-import {Injectable} from '@angular/core/src/di';
 import {RenderStore} from '../shared/render_store';
-import {RENDERER_CHANNEL} from '../shared/messaging_api';
+import {RENDERER_CHANNEL, EVENT_CHANNEL} from '../shared/messaging_api';
 import {Serializer, RenderStoreObject} from '../shared/serializer';
-import {EVENT_CHANNEL} from '../shared/messaging_api';
 import {MessageBus} from '../shared/message_bus';
 import {ObservableWrapper} from '../../../src/facade/async';
-import {ViewEncapsulation} from '@angular/core';
 import {deserializeGenericEvent} from './event_deserializer';
 
 @Injectable()

modules/@angular/platform-browser/src/web_workers/worker/router_providers.ts

@@ -1,20 +0,0 @@
-import {Provider, NgZone, APP_INITIALIZER} from '@angular/core';
-import {PlatformLocation} from '@angular/common';
-import {WebWorkerPlatformLocation} from './platform_location';
-import {ROUTER_PROVIDERS} from '@angular/router';
-
-export var WORKER_APP_ROUTER = [
-  ROUTER_PROVIDERS,
-  /* @ts2dart_Provider */ {provide: PlatformLocation, useClass: WebWorkerPlatformLocation},
-  {
-    provide: APP_INITIALIZER,
-    useFactory: (platformLocation: WebWorkerPlatformLocation, zone: NgZone) => () =>
-                    initRouter(platformLocation, zone),
-    multi: true,
-    deps: [PlatformLocation, NgZone]
-  }
-];
-
-function initRouter(platformLocation: WebWorkerPlatformLocation, zone: NgZone): Promise<boolean> {
-  return zone.runGuarded(() => { return platformLocation.init(); });
-}

modules/@angular/platform-browser/src/web_workers/worker/worker_adapter.dart

@@ -0,0 +1,390 @@
+library angular2.dom.webWorkerAdapter;
+
+import 'abstract_html_adapter.dart';
+import 'package:angular2/platform/common_dom.dart';
+
+/**
+ * This adapter is required to log error messages.
+ *
+ * Note: other methods all throw as the DOM is not accessible directly
+ * in web worker context.
+ */
+class WebWorkerDomAdapter implements DomAdapter {
+  static void makeCurrent() {
+    setRootDomAdapter(new WebWorkerDomAdapter());
+  }
+
+  logError(error) {
+    print('${error}');
+  }
+
+  log(error) {
+    print('${error}');
+  }
+
+  logGroup(error) {
+    print('${error}');
+  }
+
+  logGroupEnd() {}
+
+  hasProperty(element, String name) {
+    throw 'not implemented';
+  }
+
+  void setProperty(Element element, String name, Object value) =>
+      throw 'not implemented';
+
+  getProperty(Element element, String name) => throw 'not implemented';
+
+  invoke(Element element, String methodName, List args) =>
+      throw 'not implemented';
+
+  get attrToPropMap => throw 'not implemented';
+
+  set attrToPropMap(value) {
+    throw 'readonly';
+  }
+
+  getGlobalEventTarget(String target) {
+    throw 'not implemented';
+  }
+
+  getTitle() {
+    throw 'not implemented';
+  }
+
+  setTitle(String newTitle) {
+    throw 'not implemented';
+  }
+
+  String getEventKey(event) {
+    throw 'not implemented';
+  }
+
+  void replaceChild(el, newNode, oldNode) {
+    throw 'not implemented';
+  }
+
+  dynamic getBoundingClientRect(el) {
+    throw 'not implemented';
+  }
+
+  Type getXHR() => throw 'not implemented';
+
+  Element parse(String templateHtml) => throw 'not implemented';
+  query(selector) {
+    throw 'not implemented';
+  }
+
+  querySelector(el, String selector) {
+    throw 'not implemented';
+  }
+
+  List querySelectorAll(el, String selector) {
+    throw 'not implemented';
+  }
+
+  on(el, evt, listener) {
+    throw 'not implemented';
+  }
+
+  Function onAndCancel(el, evt, listener) {
+    throw 'not implemented';
+  }
+
+  dispatchEvent(el, evt) {
+    throw 'not implemented';
+  }
+
+  createMouseEvent(eventType) {
+    throw 'not implemented';
+  }
+
+  createEvent(eventType) {
+    throw 'not implemented';
+  }
+
+  preventDefault(evt) {
+    throw 'not implemented';
+  }
+
+  isPrevented(evt) {
+    throw 'not implemented';
+  }
+
+  getInnerHTML(el) => throw 'not implemented';
+
+  getOuterHTML(el) => throw 'not implemented';
+
+  String nodeName(node) => throw 'not implemented';
+
+  String nodeValue(node) => throw 'not implemented';
+
+  String type(node) {
+    throw 'not implemented';
+  }
+
+  content(node) => throw 'not implemented';
+
+  firstChild(el) => throw 'not implemented';
+
+  nextSibling(el) => throw 'not implemented';
+
+  parentElement(el) => throw 'not implemented';
+
+  List childNodes(el) => throw 'not implemented';
+  List childNodesAsList(el) => throw 'not implemented';
+  clearNodes(el) {
+    throw 'not implemented';
+  }
+
+  appendChild(el, node) => throw 'not implemented';
+  removeChild(el, node) {
+    throw 'not implemented';
+  }
+
+  remove(el) => throw 'not implemented';
+  insertBefore(el, node) {
+    throw 'not implemented';
+  }
+
+  insertAllBefore(el, nodes) {
+    throw 'not implemented';
+  }
+
+  insertAfter(el, node) {
+    throw 'not implemented';
+  }
+
+  setInnerHTML(el, value) {
+    throw 'not implemented';
+  }
+
+  getText(el) => throw 'not implemented';
+
+  setText(el, String value) => throw 'not implemented';
+
+  getValue(el) {
+    throw 'not implemented';
+  }
+
+  setValue(el, String value) {
+    throw 'not implemented';
+  }
+
+  getChecked(el) {
+    throw 'not implemented';
+  }
+
+  setChecked(el, bool value) {
+    throw 'not implemented';
+  }
+
+  createComment(String text) => throw 'not implemented';
+  createTemplate(String html) => throw 'not implemented';
+  createElement(tagName, [doc]) => throw 'not implemented';
+
+  createElementNS(ns, tagName, [doc]) {
+    throw 'not implemented';
+  }
+
+  createTextNode(String text, [doc]) => throw 'not implemented';
+
+  createScriptTag(String attrName, String attrValue, [doc]) {
+    throw 'not implemented';
+  }
+
+  createStyleElement(String css, [doc]) {
+    throw 'not implemented';
+  }
+
+  createShadowRoot(el) {
+    throw 'not implemented';
+  }
+
+  getShadowRoot(el) {
+    throw 'not implemented';
+  }
+
+  getHost(el) {
+    throw 'not implemented';
+  }
+
+  clone(node) => throw 'not implemented';
+  getElementsByClassName(element, String name) {
+    throw 'not implemented';
+  }
+
+  getElementsByTagName(element, String name) {
+    throw 'not implemented';
+  }
+
+  List classList(element) => throw 'not implemented';
+
+  addClass(element, String className) {
+    throw 'not implemented';
+  }
+
+  removeClass(element, String className) {
+    throw 'not implemented';
+  }
+
+  hasClass(element, String className) => throw 'not implemented';
+
+  setStyle(element, String styleName, String styleValue) {
+    throw 'not implemented';
+  }
+
+  bool hasStyle(Element element, String styleName, [String styleValue]) {
+    throw 'not implemented';
+  }
+
+  removeStyle(element, String styleName) {
+    throw 'not implemented';
+  }
+
+  getStyle(element, String styleName) {
+    throw 'not implemented';
+  }
+
+  String tagName(element) => throw 'not implemented';
+
+  attributeMap(element) => throw 'not implemented';
+
+  hasAttribute(element, String attribute) => throw 'not implemented';
+
+  hasAttributeNS(element, String ns, String attribute) {
+    throw 'not implemented';
+  }
+
+  getAttribute(element, String attribute) => throw 'not implemented';
+
+  getAttributeNS(element, String ns, String attribute) {
+    throw 'not implemented';
+  }
+
+  setAttribute(element, String name, String value) {
+    throw 'not implemented';
+  }
+
+  setAttributeNS(element, String ns, String name, String value) {
+    throw 'not implemented';
+  }
+
+  removeAttribute(element, String attribute) {
+    throw 'not implemented';
+  }
+
+  removeAttributeNS(element, String ns, String attribute) {
+    throw 'not implemented';
+  }
+
+  templateAwareRoot(el) => throw 'not implemented';
+
+  createHtmlDocument() {
+    throw 'not implemented';
+  }
+
+  defaultDoc() {
+    throw 'not implemented';
+  }
+
+  bool elementMatches(n, String selector) {
+    throw 'not implemented';
+  }
+
+  bool isTemplateElement(Element el) => throw 'not implemented';
+
+  bool isTextNode(node) => throw 'not implemented';
+  bool isCommentNode(node) => throw 'not implemented';
+
+  bool isElementNode(node) => throw 'not implemented';
+
+  bool hasShadowRoot(node) {
+    throw 'not implemented';
+  }
+
+  bool isShadowRoot(node) {
+    throw 'not implemented';
+  }
+
+  importIntoDoc(node) {
+    throw 'not implemented';
+  }
+
+  adoptNode(node) {
+    throw 'not implemented';
+  }
+
+  String getHref(element) {
+    throw 'not implemented';
+  }
+
+  void resolveAndSetHref(element, baseUrl, href) {
+    throw 'not implemented';
+  }
+
+  List getDistributedNodes(Node) {
+    throw 'not implemented';
+  }
+
+  bool supportsDOMEvents() => throw 'not implemented';
+
+  bool supportsNativeShadowDOM() => throw 'not implemented';
+
+  getHistory() => throw 'not implemented';
+
+  getLocation() {
+    throw 'not implemented';
+  }
+
+  getBaseHref() {
+    throw 'not implemented';
+  }
+
+  resetBaseElement() {
+    throw 'not implemented';
+  }
+
+  String getUserAgent() => throw 'not implemented';
+
+  void setData(Element element, String name, String value) {
+    throw 'not implemented';
+  }
+
+  getComputedStyle(element) {
+    throw 'not implemented';
+  }
+
+  String getData(Element element, String name) => throw 'not implemented';
+
+  // TODO(tbosch): move this into a separate environment class once we have it
+  setGlobalVar(String name, value) {
+    throw 'not implemented';
+  }
+
+  requestAnimationFrame(callback) {
+    throw 'not implemented';
+  }
+
+  cancelAnimationFrame(id) {
+    throw 'not implemented';
+  }
+
+  performanceNow() {
+    throw 'not implemented';
+  }
+
+  getAnimationPrefix() {
+    throw 'not implemented';
+  }
+
+  getTransitionEnd() {
+    throw 'not implemented';
+  }
+
+  supportsAnimation() {
+    throw 'not implemented';
+  }
+}

modules/@angular/platform-browser/src/web_workers/worker/worker_adapter.ts

@@ -0,0 +1,155 @@
+import {Type} from '../../../src/facade/lang';
+import {DomAdapter, setRootDomAdapter} from '../../dom/dom_adapter';
+
+/**
+ * This adapter is required to log error messages.
+ *
+ * Note: other methods all throw as the DOM is not accessible directly in web worker context.
+ */
+export class WorkerDomAdapter extends DomAdapter {
+  static makeCurrent() { setRootDomAdapter(new WorkerDomAdapter()); }
+
+  logError(error) {
+    if (console.error) {
+      console.error(error);
+    } else {
+      console.log(error);
+    }
+  }
+
+  log(error) { console.log(error); }
+
+  logGroup(error) {
+    if (console.group) {
+      console.group(error);
+      this.logError(error);
+    } else {
+      console.log(error);
+    }
+  }
+
+  logGroupEnd() {
+    if (console.groupEnd) {
+      console.groupEnd();
+    }
+  }
+
+  hasProperty(element, name: string): boolean { throw "not implemented"; }
+  setProperty(el: Element, name: string, value: any) { throw "not implemented"; }
+  getProperty(el: Element, name: string): any { throw "not implemented"; }
+  invoke(el: Element, methodName: string, args: any[]): any { throw "not implemented"; }
+
+  getXHR(): Type { throw "not implemented"; }
+
+  get attrToPropMap(): {[key: string]: string} { throw "not implemented"; }
+  set attrToPropMap(value: {[key: string]: string}) { throw "not implemented"; }
+
+  parse(templateHtml: string) { throw "not implemented"; }
+  query(selector: string): any { throw "not implemented"; }
+  querySelector(el, selector: string): HTMLElement { throw "not implemented"; }
+  querySelectorAll(el, selector: string): any[] { throw "not implemented"; }
+  on(el, evt, listener) { throw "not implemented"; }
+  onAndCancel(el, evt, listener): Function { throw "not implemented"; }
+  dispatchEvent(el, evt) { throw "not implemented"; }
+  createMouseEvent(eventType): any { throw "not implemented"; }
+  createEvent(eventType: string): any { throw "not implemented"; }
+  preventDefault(evt) { throw "not implemented"; }
+  isPrevented(evt): boolean { throw "not implemented"; }
+  getInnerHTML(el): string { throw "not implemented"; }
+  getTemplateContent(el): any { throw "not implemented"; }
+  getOuterHTML(el): string { throw "not implemented"; }
+  nodeName(node): string { throw "not implemented"; }
+  nodeValue(node): string { throw "not implemented"; }
+  type(node): string { throw "not implemented"; }
+  content(node): any { throw "not implemented"; }
+  firstChild(el): Node { throw "not implemented"; }
+  nextSibling(el): Node { throw "not implemented"; }
+  parentElement(el): Node { throw "not implemented"; }
+  childNodes(el): Node[] { throw "not implemented"; }
+  childNodesAsList(el): Node[] { throw "not implemented"; }
+  clearNodes(el) { throw "not implemented"; }
+  appendChild(el, node) { throw "not implemented"; }
+  removeChild(el, node) { throw "not implemented"; }
+  replaceChild(el, newNode, oldNode) { throw "not implemented"; }
+  remove(el): Node { throw "not implemented"; }
+  insertBefore(el, node) { throw "not implemented"; }
+  insertAllBefore(el, nodes) { throw "not implemented"; }
+  insertAfter(el, node) { throw "not implemented"; }
+  setInnerHTML(el, value) { throw "not implemented"; }
+  getText(el): string { throw "not implemented"; }
+  setText(el, value: string) { throw "not implemented"; }
+  getValue(el): string { throw "not implemented"; }
+  setValue(el, value: string) { throw "not implemented"; }
+  getChecked(el): boolean { throw "not implemented"; }
+  setChecked(el, value: boolean) { throw "not implemented"; }
+  createComment(text: string): any { throw "not implemented"; }
+  createTemplate(html): HTMLElement { throw "not implemented"; }
+  createElement(tagName, doc?): HTMLElement { throw "not implemented"; }
+  createElementNS(ns: string, tagName: string, doc?): Element { throw "not implemented"; }
+  createTextNode(text: string, doc?): Text { throw "not implemented"; }
+  createScriptTag(attrName: string, attrValue: string, doc?): HTMLElement {
+    throw "not implemented";
+  }
+  createStyleElement(css: string, doc?): HTMLStyleElement { throw "not implemented"; }
+  createShadowRoot(el): any { throw "not implemented"; }
+  getShadowRoot(el): any { throw "not implemented"; }
+  getHost(el): any { throw "not implemented"; }
+  getDistributedNodes(el): Node[] { throw "not implemented"; }
+  clone(node: Node): Node { throw "not implemented"; }
+  getElementsByClassName(element, name: string): HTMLElement[] { throw "not implemented"; }
+  getElementsByTagName(element, name: string): HTMLElement[] { throw "not implemented"; }
+  classList(element): any[] { throw "not implemented"; }
+  addClass(element, className: string) { throw "not implemented"; }
+  removeClass(element, className: string) { throw "not implemented"; }
+  hasClass(element, className: string): boolean { throw "not implemented"; }
+  setStyle(element, styleName: string, styleValue: string) { throw "not implemented"; }
+  removeStyle(element, styleName: string) { throw "not implemented"; }
+  getStyle(element, styleName: string): string { throw "not implemented"; }
+  hasStyle(element, styleName: string, styleValue?: string): boolean { throw "not implemented"; }
+  tagName(element): string { throw "not implemented"; }
+  attributeMap(element): Map<string, string> { throw "not implemented"; }
+  hasAttribute(element, attribute: string): boolean { throw "not implemented"; }
+  hasAttributeNS(element, ns: string, attribute: string): boolean { throw "not implemented"; }
+  getAttribute(element, attribute: string): string { throw "not implemented"; }
+  getAttributeNS(element, ns: string, attribute: string): string { throw "not implemented"; }
+  setAttribute(element, name: string, value: string) { throw "not implemented"; }
+  setAttributeNS(element, ns: string, name: string, value: string) { throw "not implemented"; }
+  removeAttribute(element, attribute: string) { throw "not implemented"; }
+  removeAttributeNS(element, ns: string, attribute: string) { throw "not implemented"; }
+  templateAwareRoot(el) { throw "not implemented"; }
+  createHtmlDocument(): HTMLDocument { throw "not implemented"; }
+  defaultDoc(): HTMLDocument { throw "not implemented"; }
+  getBoundingClientRect(el) { throw "not implemented"; }
+  getTitle(): string { throw "not implemented"; }
+  setTitle(newTitle: string) { throw "not implemented"; }
+  elementMatches(n, selector: string): boolean { throw "not implemented"; }
+  isTemplateElement(el: any): boolean { throw "not implemented"; }
+  isTextNode(node): boolean { throw "not implemented"; }
+  isCommentNode(node): boolean { throw "not implemented"; }
+  isElementNode(node): boolean { throw "not implemented"; }
+  hasShadowRoot(node): boolean { throw "not implemented"; }
+  isShadowRoot(node): boolean { throw "not implemented"; }
+  importIntoDoc(node: Node): Node { throw "not implemented"; }
+  adoptNode(node: Node): Node { throw "not implemented"; }
+  getHref(element): string { throw "not implemented"; }
+  getEventKey(event): string { throw "not implemented"; }
+  resolveAndSetHref(element, baseUrl: string, href: string) { throw "not implemented"; }
+  supportsDOMEvents(): boolean { throw "not implemented"; }
+  supportsNativeShadowDOM(): boolean { throw "not implemented"; }
+  getGlobalEventTarget(target: string): any { throw "not implemented"; }
+  getHistory(): History { throw "not implemented"; }
+  getLocation(): Location { throw "not implemented"; }
+  getBaseHref(): string { throw "not implemented"; }
+  resetBaseElement(): void { throw "not implemented"; }
+  getUserAgent(): string { throw "not implemented"; }
+  setData(element, name: string, value: string) { throw "not implemented"; }
+  getComputedStyle(element): any { throw "not implemented"; }
+  getData(element, name: string): string { throw "not implemented"; }
+  setGlobalVar(name: string, value: any) { throw "not implemented"; }
+  requestAnimationFrame(callback): number { throw "not implemented"; }
+  cancelAnimationFrame(id) { throw "not implemented"; }
+  performanceNow(): number { throw "not implemented"; }
+  getAnimationPrefix(): string { throw "not implemented"; }
+  getTransitionEnd(): string { throw "not implemented"; }
+  supportsAnimation(): boolean { throw "not implemented"; }
+}

modules/@angular/platform-browser/src/web_workers/worker/xhr_impl.ts

@@ -1,29 +0,0 @@
-import {Injectable} from '@angular/core/src/di';
-import {XHR} from '@angular/compiler/src/xhr';
-import {
-  FnArg,
-  UiArguments,
-  ClientMessageBroker,
-  ClientMessageBrokerFactory
-} from '../shared/client_message_broker';
-import {XHR_CHANNEL} from '../shared/messaging_api';
-
-/**
- * Implementation of compiler/xhr that relays XHR requests to the UI side where they are sent
- * and the result is proxied back to the worker
- */
-@Injectable()
-export class WebWorkerXHRImpl extends XHR {
-  private _messageBroker: ClientMessageBroker;
-
-  constructor(messageBrokerFactory: ClientMessageBrokerFactory) {
-    super();
-    this._messageBroker = messageBrokerFactory.createMessageBroker(XHR_CHANNEL);
-  }
-
-  get(url: string): Promise<string> {
-    var fnArgs: FnArg[] = [new FnArg(url, null)];
-    var args: UiArguments = new UiArguments("get", fnArgs);
-    return this._messageBroker.runOnService(args, String);
-  }
-}