Refactor(WebWorker): Unify WebWorker naming

Closes angular#3205

Author: jteplitz

modules/angular2/src/web-workers/shared/api.ts

@@ -2,8 +2,8 @@ import {CONST_EXPR} from "angular2/src/facade/lang";
 import {OpaqueToken} from "angular2/di";
 import {RenderElementRef, RenderViewRef} from "angular2/src/render/api";
 
-export const ON_WEBWORKER = CONST_EXPR(new OpaqueToken('WebWorker.onWebWorker'));
+export const ON_WEB_WORKER = CONST_EXPR(new OpaqueToken('WebWorker.onWebWorker'));
 
-export class WorkerElementRef implements RenderElementRef {
+export class WebWorkerElementRef implements RenderElementRef {
   constructor(public renderView: RenderViewRef, public renderBoundElementIndex: number) {}
 }

modules/angular2/src/web-workers/shared/message_bus.ts

@@ -17,7 +17,7 @@ export interface MessageBusSource {
   /**
    * Attaches the SourceListener to this source.
    * The SourceListener will get called whenever the bus receives a message
-   * Returns a listener id that can be passed to {@link removeListener}
+   * Returns a listener id that can be passed to {removeListener}
    */
   addListener(fn: SourceListener): number;
   removeListener(index: number);

modules/angular2/src/web-workers/shared/render_proto_view_ref_store.ts

@@ -1,6 +1,6 @@
 import {Injectable, Inject} from "angular2/di";
 import {RenderProtoViewRef} from "angular2/src/render/api";
-import {ON_WEBWORKER} from "angular2/src/web-workers/shared/api";
+import {ON_WEB_WORKER} from "angular2/src/web-workers/shared/api";
 
 @Injectable()
 export class RenderProtoViewRefStore {
@@ -10,7 +10,7 @@ export class RenderProtoViewRefStore {
   private _nextIndex: number = 0;
   private _onWebworker: boolean;
 
-  constructor(@Inject(ON_WEBWORKER) onWebworker) { this._onWebworker = onWebworker; }
+  constructor(@Inject(ON_WEB_WORKER) onWebworker) { this._onWebworker = onWebworker; }
 
   storeRenderProtoViewRef(ref: RenderProtoViewRef): number {
     if (this._lookupByProtoView.has(ref)) {
@@ -32,7 +32,7 @@ export class RenderProtoViewRefStore {
     }
 
     if (this._onWebworker) {
-      return new WebworkerRenderProtoViewRef(index);
+      return new WebWorkerRenderProtoViewRef(index);
     } else {
       return this.retreiveRenderProtoViewRef(index);
     }
@@ -44,13 +44,13 @@ export class RenderProtoViewRefStore {
     }
 
     if (this._onWebworker) {
-      return (<WebworkerRenderProtoViewRef>ref).refNumber;
+      return (<WebWorkerRenderProtoViewRef>ref).refNumber;
     } else {
       return this.storeRenderProtoViewRef(ref);
     }
   }
 }
 
-export class WebworkerRenderProtoViewRef extends RenderProtoViewRef {
+export class WebWorkerRenderProtoViewRef extends RenderProtoViewRef {
   constructor(public refNumber: number) { super(); }
 }

modules/angular2/src/web-workers/shared/render_view_with_fragments_store.ts

@@ -1,6 +1,6 @@
 import {Injectable, Inject} from "angular2/di";
 import {RenderViewRef, RenderFragmentRef, RenderViewWithFragments} from "angular2/src/render/api";
-import {ON_WEBWORKER} from "angular2/src/web-workers/shared/api";
+import {ON_WEB_WORKER} from "angular2/src/web-workers/shared/api";
 import {List, ListWrapper} from "angular2/src/facade/collection";
 
 @Injectable()
@@ -10,7 +10,7 @@ export class RenderViewWithFragmentsStore {
   private _lookupByIndex: Map<number, RenderViewRef | RenderFragmentRef>;
   private _lookupByView: Map<RenderViewRef | RenderFragmentRef, number>;
 
-  constructor(@Inject(ON_WEBWORKER) onWebWorker) {
+  constructor(@Inject(ON_WEB_WORKER) onWebWorker) {
     this._onWebWorker = onWebWorker;
     this._lookupByIndex = new Map<number, RenderViewRef | RenderFragmentRef>();
     this._lookupByView = new Map<RenderViewRef | RenderFragmentRef, number>();
@@ -19,11 +19,11 @@ export class RenderViewWithFragmentsStore {
   allocate(fragmentCount: number): RenderViewWithFragments {
     var initialIndex = this._nextIndex;
 
-    var viewRef = new WorkerRenderViewRef(this._nextIndex++);
+    var viewRef = new WebWorkerRenderViewRef(this._nextIndex++);
     var fragmentRefs = ListWrapper.createGrowableSize(fragmentCount);
 
     for (var i = 0; i < fragmentCount; i++) {
-      fragmentRefs[i] = new WorkerRenderFragmentRef(this._nextIndex++);
+      fragmentRefs[i] = new WebWorkerRenderFragmentRef(this._nextIndex++);
     }
     var renderViewWithFragments = new RenderViewWithFragments(viewRef, fragmentRefs);
     this.store(renderViewWithFragments, initialIndex);
@@ -79,7 +79,7 @@ export class RenderViewWithFragmentsStore {
     }
 
     if (this._onWebWorker) {
-      return (<WorkerRenderFragmentRef | WorkerRenderViewRef>ref).serialize();
+      return (<WebWorkerRenderFragmentRef | WebWorkerRenderViewRef>ref).serialize();
     } else {
       return this._lookupByView.get(ref);
     }
@@ -92,7 +92,7 @@ export class RenderViewWithFragmentsStore {
 
     if (this._onWebWorker) {
       return {
-        'viewRef': (<WorkerRenderViewRef>view.viewRef).serialize(),
+        'viewRef': (<WebWorkerRenderViewRef>view.viewRef).serialize(),
         'fragmentRefs': ListWrapper.map(view.fragmentRefs, (val) => val.serialize())
       };
     } else {
@@ -116,19 +116,21 @@ export class RenderViewWithFragmentsStore {
   }
 }
 
-export class WorkerRenderViewRef extends RenderViewRef {
+export class WebWorkerRenderViewRef extends RenderViewRef {
   constructor(public refNumber: number) { super(); }
   serialize(): number { return this.refNumber; }
 
-  static deserialize(ref: number): WorkerRenderViewRef { return new WorkerRenderViewRef(ref); }
+  static deserialize(ref: number): WebWorkerRenderViewRef {
+    return new WebWorkerRenderViewRef(ref);
+  }
 }
 
-export class WorkerRenderFragmentRef extends RenderFragmentRef {
+export class WebWorkerRenderFragmentRef extends RenderFragmentRef {
   constructor(public refNumber: number) { super(); }
 
   serialize(): number { return this.refNumber; }
 
-  static deserialize(ref: number): WorkerRenderFragmentRef {
-    return new WorkerRenderFragmentRef(ref);
+  static deserialize(ref: number): WebWorkerRenderFragmentRef {
+    return new WebWorkerRenderFragmentRef(ref);
   }
 }

modules/angular2/src/web-workers/shared/serializer.ts

@@ -31,7 +31,7 @@ import {
   ViewEncapsulation,
   PropertyBindingType
 } from "angular2/src/render/api";
-import {WorkerElementRef} from 'angular2/src/web-workers/shared/api';
+import {WebWorkerElementRef} from 'angular2/src/web-workers/shared/api';
 import {AST, ASTWithSource} from 'angular2/src/change_detection/change_detection';
 import {Parser} from "angular2/src/change_detection/parser/parser";
 import {Injectable} from "angular2/di";
@@ -99,7 +99,7 @@ export class Serializer {
       return this._renderViewStore.serializeRenderViewRef(obj);
     } else if (type == RenderFragmentRef) {
       return this._renderViewStore.serializeRenderFragmentRef(obj);
-    } else if (type == WorkerElementRef) {
+    } else if (type == WebWorkerElementRef) {
       return this._serializeWorkerElementRef(obj);
     } else if (type == ElementPropertyBinding) {
       return this._serializeElementPropertyBinding(obj);
@@ -143,7 +143,7 @@ export class Serializer {
       return this._renderViewStore.deserializeRenderViewRef(map);
     } else if (type == RenderFragmentRef) {
       return this._renderViewStore.deserializeRenderFragmentRef(map);
-    } else if (type == WorkerElementRef) {
+    } else if (type == WebWorkerElementRef) {
       return this._deserializeWorkerElementRef(map);
     } else if (type == EventBinding) {
       return this._deserializeEventBinding(map);
@@ -219,8 +219,8 @@ export class Serializer {
   }
 
   private _deserializeWorkerElementRef(map: StringMap<string, any>): RenderElementRef {
-    return new WorkerElementRef(this.deserialize(map['renderView'], RenderViewRef),
-                                map['renderBoundElementIndex']);
+    return new WebWorkerElementRef(this.deserialize(map['renderView'], RenderViewRef),
+                                   map['renderBoundElementIndex']);
   }
 
   private _serializeRenderProtoViewMergeMapping(mapping: RenderProtoViewMergeMapping): Object {

modules/angular2/src/web-workers/ui/application.dart

@@ -14,7 +14,7 @@ import 'package:angular2/src/web-workers/ui/impl.dart' show bootstrapUICommon;
  * Note: The WebWorker script must call bootstrapWebworker once it is set up to complete the bootstrapping process
  */
 Future<MessageBus> bootstrap(String uri) {
-  return spawnWorker(Uri.parse(uri)).then((bus) {
+  return spawnWebWorker(Uri.parse(uri)).then((bus) {
     bootstrapUICommon(bus);
     return bus;
   });
@@ -23,7 +23,7 @@ Future<MessageBus> bootstrap(String uri) {
 /**
  * To be called from the main thread to spawn and communicate with the worker thread
  */
-Future<UIMessageBus> spawnWorker(Uri uri) {
+Future<UIMessageBus> spawnWebWorker(Uri uri) {
   var receivePort = new ReceivePort();
   var isolateEndSendPort = receivePort.sendPort;
   return Isolate.spawnUri(uri, const [], isolateEndSendPort).then((_) {

modules/angular2/src/web-workers/ui/application.ts

@@ -16,34 +16,34 @@ import {bootstrapUICommon} from "angular2/src/web-workers/ui/impl";
  * bootstrapping process
  */
 export function bootstrap(uri: string): MessageBus {
-  var messageBus = spawnWorker(uri);
+  var messageBus = spawnWebWorker(uri);
   bootstrapUICommon(messageBus);
   return messageBus;
 }
 
-export function spawnWorker(uri: string): MessageBus {
-  var worker: Worker = new Worker(uri);
-  return new UIMessageBus(new UIMessageBusSink(worker), new UIMessageBusSource(worker));
+export function spawnWebWorker(uri: string): MessageBus {
+  var webWorker: Worker = new Worker(uri);
+  return new UIMessageBus(new UIMessageBusSink(webWorker), new UIMessageBusSource(webWorker));
 }
 
 export class UIMessageBus implements MessageBus {
   constructor(public sink: UIMessageBusSink, public source: UIMessageBusSource) {}
 }
 
 export class UIMessageBusSink implements MessageBusSink {
-  constructor(private _worker: Worker) {}
+  constructor(private _webWorker: Worker) {}
 
-  send(message: Object): void { this._worker.postMessage(message); }
+  send(message: Object): void { this._webWorker.postMessage(message); }
 }
 
 export class UIMessageBusSource implements MessageBusSource {
   private _listenerStore: Map<int, SourceListener> = new Map<int, SourceListener>();
   private _numListeners: int = 0;
 
-  constructor(private _worker: Worker) {}
+  constructor(private _webWorker: Worker) {}
 
   public addListener(fn: SourceListener): int {
-    this._worker.addEventListener("message", fn);
+    this._webWorker.addEventListener("message", fn);
     this._listenerStore[++this._numListeners] = fn;
     return this._numListeners;
   }

modules/angular2/src/web-workers/ui/di_bindings.ts

@@ -56,7 +56,7 @@ import {Testability} from 'angular2/src/core/testability/testability';
 import {XHR} from 'angular2/src/render/xhr';
 import {XHRImpl} from 'angular2/src/render/xhr_impl';
 import {Serializer} from 'angular2/src/web-workers/shared/serializer';
-import {ON_WEBWORKER} from 'angular2/src/web-workers/shared/api';
+import {ON_WEB_WORKER} from 'angular2/src/web-workers/shared/api';
 import {RenderProtoViewRefStore} from 'angular2/src/web-workers/shared/render_proto_view_ref_store';
 import {
   RenderViewWithFragmentsStore
@@ -101,7 +101,7 @@ function _injectorBindings(): List<Type | Binding | List<any>> {
     DomSharedStylesHost,
     bind(SharedStylesHost).toAlias(DomSharedStylesHost),
     Serializer,
-    bind(ON_WEBWORKER).toValue(false),
+    bind(ON_WEB_WORKER).toValue(false),
     bind(ElementSchemaRegistry).toValue(new DomElementSchemaRegistry()),
     RenderViewWithFragmentsStore,
     RenderProtoViewRefStore,

modules/angular2/src/web-workers/ui/impl.ts

@@ -27,7 +27,7 @@ import {
   RenderViewWithFragmentsStore
 } from 'angular2/src/web-workers/shared/render_view_with_fragments_store';
 import {createNgZone} from 'angular2/src/core/application_common';
-import {WorkerElementRef} from 'angular2/src/web-workers/shared/api';
+import {WebWorkerElementRef} from 'angular2/src/web-workers/shared/api';
 import {AnchorBasedAppRootUrl} from 'angular2/src/services/anchor_based_app_root_url';
 import {Injectable} from 'angular2/di';
 import {BrowserDomAdapter} from 'angular2/src/dom/browser_adapter';
@@ -50,7 +50,7 @@ export function bootstrapUICommon(bus: MessageBus) {
   zone.run(() => {
     var injector = createInjector(zone);
     var webWorkerMain = injector.get(WebWorkerMain);
-    webWorkerMain.attachToWorker(bus);
+    webWorkerMain.attachToWebWorker(bus);
   });
 }
 
@@ -70,21 +70,21 @@ export class WebWorkerMain {
    * This instance will now listen for all messages from the worker and handle them appropriately
    * Note: Don't attach more than one WebWorkerMain instance to the same MessageBus.
    */
-  attachToWorker(bus: MessageBus) {
+  attachToWebWorker(bus: MessageBus) {
     this._bus = bus;
-    this._bus.source.addListener((message) => { this._handleWorkerMessage(message); });
+    this._bus.source.addListener((message) => { this._handleWebWorkerMessage(message); });
   }
 
-  private _sendInitMessage() { this._sendWorkerMessage("init", {"rootUrl": this._rootUrl}); }
+  private _sendInitMessage() { this._sendWebWorkerMessage("init", {"rootUrl": this._rootUrl}); }
 
   /*
    * Sends an error back to the worker thread in response to an opeartion on the UI thread
    */
-  private _sendWorkerError(id: string, error: any) {
-    this._sendWorkerMessage("error", {"error": error}, id);
+  private _sendWebWorkerError(id: string, error: any) {
+    this._sendWebWorkerMessage("error", {"error": error}, id);
   }
 
-  private _sendWorkerMessage(type: string, value: StringMap<string, any>, id?: string) {
+  private _sendWebWorkerMessage(type: string, value: StringMap<string, any>, id?: string) {
     this._bus.sink.send({'type': type, 'id': id, 'value': value});
   }
 
@@ -95,17 +95,17 @@ export class WebWorkerMain {
       case "compileHost":
         var directiveMetadata = this._serializer.deserialize(data.args[0], DirectiveMetadata);
         promise = this._renderCompiler.compileHost(directiveMetadata);
-        this._wrapWorkerPromise(data.id, promise, ProtoViewDto);
+        this._wrapWebWorkerPromise(data.id, promise, ProtoViewDto);
         break;
       case "compile":
         var view = this._serializer.deserialize(data.args[0], ViewDefinition);
         promise = this._renderCompiler.compile(view);
-        this._wrapWorkerPromise(data.id, promise, ProtoViewDto);
+        this._wrapWebWorkerPromise(data.id, promise, ProtoViewDto);
         break;
       case "mergeProtoViewsRecursively":
         var views = this._serializer.deserialize(data.args[0], RenderProtoViewRef);
         promise = this._renderCompiler.mergeProtoViewsRecursively(views);
-        this._wrapWorkerPromise(data.id, promise, RenderProtoViewMergeMapping);
+        this._wrapWebWorkerPromise(data.id, promise, RenderProtoViewMergeMapping);
         break;
       default:
         throw new BaseException("not implemented");
@@ -145,7 +145,7 @@ export class WebWorkerMain {
         this._renderer.attachFragmentAfterFragment(previousFragment, fragment);
         break;
       case "attachFragmentAfterElement":
-        var element = this._serializer.deserialize(args[0], WorkerElementRef);
+        var element = this._serializer.deserialize(args[0], WebWorkerElementRef);
         var fragment = this._serializer.deserialize(args[1], RenderFragmentRef);
         this._renderer.attachFragmentAfterElement(element, fragment);
         break;
@@ -168,31 +168,31 @@ export class WebWorkerMain {
         this._renderer.setText(viewRef, textNodeIndex, text);
         break;
       case "setElementProperty":
-        var elementRef = this._serializer.deserialize(args[0], WorkerElementRef);
+        var elementRef = this._serializer.deserialize(args[0], WebWorkerElementRef);
         var propName = args[1];
         var propValue = args[2];
         this._renderer.setElementProperty(elementRef, propName, propValue);
         break;
       case "setElementAttribute":
-        var elementRef = this._serializer.deserialize(args[0], WorkerElementRef);
+        var elementRef = this._serializer.deserialize(args[0], WebWorkerElementRef);
         var attributeName = args[1];
         var attributeValue = args[2];
         this._renderer.setElementAttribute(elementRef, attributeName, attributeValue);
         break;
       case "setElementClass":
-        var elementRef = this._serializer.deserialize(args[0], WorkerElementRef);
+        var elementRef = this._serializer.deserialize(args[0], WebWorkerElementRef);
         var className = args[1];
         var isAdd = args[2];
         this._renderer.setElementClass(elementRef, className, isAdd);
         break;
       case "setElementStyle":
-        var elementRef = this._serializer.deserialize(args[0], WorkerElementRef);
+        var elementRef = this._serializer.deserialize(args[0], WebWorkerElementRef);
         var styleName = args[1];
         var styleValue = args[2];
         this._renderer.setElementStyle(elementRef, styleName, styleValue);
         break;
       case "invokeElementMethod":
-        var elementRef = this._serializer.deserialize(args[0], WorkerElementRef);
+        var elementRef = this._serializer.deserialize(args[0], WebWorkerElementRef);
         var methodName = args[1];
         var methodArgs = args[2];
         this._renderer.invokeElementMethod(elementRef, methodName, methodArgs);
@@ -208,7 +208,7 @@ export class WebWorkerMain {
   }
 
   // TODO(jteplitz602): Create message type enum #3044
-  private _handleWorkerMessage(message: StringMap<string, any>) {
+  private _handleWebWorkerMessage(message: StringMap<string, any>) {
     var data: ReceivedMessage = new ReceivedMessage(message['data']);
     switch (data.type) {
       case "ready":
@@ -220,14 +220,14 @@ export class WebWorkerMain {
     }
   }
 
-  private _wrapWorkerPromise(id: string, promise: Promise<any>, type: Type): void {
+  private _wrapWebWorkerPromise(id: string, promise: Promise<any>, type: Type): void {
     PromiseWrapper.then(promise, (result: any) => {
       try {
-        this._sendWorkerMessage("result", this._serializer.serialize(result, type), id);
+        this._sendWebWorkerMessage("result", this._serializer.serialize(result, type), id);
       } catch (e) {
         print(e);
       }
-    }, (error: any) => { this._sendWorkerError(id, error); });
+    }, (error: any) => { this._sendWebWorkerError(id, error); });
   }
 }