initCallbacks({onTurnStart,
   onTurnDone,
   onScheduleMicrotask,
   onErrorHandler} = {}) {
   this._onTurnStart = normalizeBlank(onTurnStart);
   this._onTurnDone = normalizeBlank(onTurnDone);
   this._onErrorHandler = normalizeBlank(onErrorHandler);
 }

 generate(params: StringMap<string, string>): string {
   if (!StringMapWrapper.contains(params, this.name)) {
     throw new BaseException(
         `Route generator for '${this.name}' was not included in parameters passed.`)
   }
   return normalizeBlank(StringMapWrapper.get(params, this.name));
 }

 set value(value) {
   this._emptyAllActiveViewContainers();
   this._useDefault = false;
   var containers = MapWrapper.get(this._valueViewContainers, value);
   if (isBlank(containers)) {
     this._useDefault = true;
     containers = normalizeBlank(MapWrapper.get(this._valueViewContainers, _whenDefault));
   }
   this._activateViewContainers(containers);
   this._switchValue = value;
 }

 _onError(zone, e) {
   if (isPresent(this._onErrorHandler)) {
     var trace = [normalizeBlank(e.stack)];
     while (zone && zone.constructedAtException) {
       trace.push(zone.constructedAtException.get());
       zone = zone.parent;
     }
     this._onErrorHandler(e, trace);
   } else {
     throw e;
   }
 }

 _processRequest(request) {
   var url = request.url;
   if (this._expectations.length > 0) {
     var expectation = this._expectations[0];
     if (expectation.url == url) {
       ListWrapper.remove(this._expectations, expectation);
       request.complete(expectation.response);
       return ;
     }
   }
   if (MapWrapper.contains(this._definitions, url)) {
     var response = MapWrapper.get(this._definitions, url);
     request.complete(normalizeBlank(response));
     return ;
   }
   throw new BaseException(`Unexpected request ${url}`);
 }

 /**
  * Gets an attribute from the underlying DOM element.
  * (DEPRECATED way of accessing the DOM, replacement coming)
  */
 // TODO(tbosch): Here we expose the real DOM element.
 // We need a more general way to read/write to the DOM element
 // via a proper abstraction in the render layer
 getAttribute(name: string): string {
   return normalizeBlank(DOM.getAttribute(this.domElement, name));
 }

 get(param: string): string { return normalizeBlank(StringMapWrapper.get(this.params, param)); }

 overrideOnEventDone(onEventDoneFn: Function, waitForAsync: boolean = false): void {
   this._onEventDone = normalizeBlank(onEventDoneFn);
 }

 overrideOnTurnStart(onTurnStartFn: Function): void {
   this._onTurnStart = normalizeBlank(onTurnStartFn);
 }