getContentType(req: ngRequest): string {
    let type = req.headers && req.headers.get('Content-Type');

    if (type) {
      switch (req.detectContentType()) {
        case ContentType.NONE:
          break;
        case ContentType.JSON:
          type = 'application/json';
          break;
        case ContentType.FORM:
          type = 'application/x-www-form-urlencoded;charset=UTF-8';
          break;
        case ContentType.TEXT:
          type = 'text/plain';
          break;
        case ContentType.BLOB:
          const blob = req.blob();
          if (blob.type) {
            type = blob.type;
          }
          break;
      }
    }

    return type;
  }

            (responseObserver: Observer<Response>) => {
                const headers = req.headers.toJSON();
                Object.keys(headers).map(function(key) {
                    if (headers[key].length > 1) {
                        throw `Header ${key} contains more than one value`;
                    }
                    headers[key] = headers[key][0];
                });

                let body;

                // 1 stands for ContentType.JSON. Angular doesn't export ContentType
                if (req.detectContentTypeFromBody() === 1) {
                    body = req.json();
                } else {
                    body = this.getBodyParams(req.getBody());
                }

                const requestMethod = this.detectRequestMethod(req);

                /**
                 * Request contains either encoded either decoded URL depended on the way
                 * parameters are passed to Http component. Even though XMLHttpRequest automatically
                 * converts unencoded URL, NativeHTTP requires it to be always encoded.
                 */
                const url = encodeURI(decodeURI(req.url)).replace('%252F', '%2F');

                nativeHttp.setDataSerializer(
                    this.detectDataSerializerType(req),
                );

                nativeHttp[requestMethod](url, body, headers)
                    .then((response: HTTPResponse) => {
                        this.fireResponse(
                            responseObserver,
                            new ResponseOptions({
                                body: response.data,
                                status: response.status,
                                headers: new Headers(response.headers),
                            }),
                            baseResponseOptions,
                        );
                    })
                    .catch((error: HTTPError) => {
                        this.fireResponse(
                            responseObserver,
                            new ResponseOptions({
                                body: error.error,
                                status: error.status || 599, // https://httpstatuses.com/599
                                headers: new Headers(error.headers),
                            }),
                            baseResponseOptions,
                        );
                    });
            },

    this.response = new Observable<ngResponse>((responseObserver: Observer<ngResponse>) => {
      // fetch
      var _fetch = browserFetch.build(),
        url = req.url,
        fetchOptions = {
          method: RequestMethod[req.method].toUpperCase(),
          //TODO req.headers.toJSON() (https://angular.io/docs/ts/latest/api/http/index/Headers-class.html)
          headers: {
            'Content-Type': this.getContentType(req)
          },
          body: req.getBody()
        };

      var fetchPromise = _fetch(url, fetchOptions);

      // response
      fetchPromise
        .then((fetchResponse) => this.onSuccess(fetchResponse, responseObserver, baseResponseOptions))
        .catch((error) => this.onError(error, responseObserver, baseResponseOptions));

      // cleanup
      return () => {
        // nothing can be aborted ¯\_(ツ)_/¯
      }
    });

    private detectDataSerializerType(req: Request): DataSerializerType {
        if (
            req.method === RequestMethod.Post ||
            req.method === RequestMethod.Put
        ) {
            // 1 stands for ContentType.JSON. Angular doesn't export ContentType
            if (req.detectContentTypeFromBody() === 1) {
                return 'json';
            }
        }

        return 'urlencoded';
    }

    this.response = new Observable((responseObserver: any) => {
      let _xhr: XMLHttpRequest = browserXHR.build();
      _xhr.open(RequestMethod[req.method].toUpperCase(), req.url);
      // load event handler
      let onLoad = () => {
        // responseText is the old-school way of retrieving response (supported by IE8 & 9)
        // response/responseType properties were introduced in XHR Level2 spec (supported by
        // IE10)
        let body = _xhr.response ? _xhr.response : _xhr.responseText;
        let headers = Headers.fromResponseHeaderString(_xhr.getAllResponseHeaders() || "");
        let url = getResponseURL(_xhr);
        let status: number = _xhr.status;

        var responseOptions = new ResponseOptions({body, status, headers, url});
        if (baseResponseOptions) {
          responseOptions = baseResponseOptions.merge(responseOptions);
        }
        let response = new Response(responseOptions);
        if (isSuccess(status)) {
          responseObserver.next(response);
          // TODO(gdi2290): defer complete if array buffer until done
          responseObserver.complete();
          return;
        }
        responseObserver.error(response);
      };

      _xhr.onload = () => this.zone.run(() => onLoad());
      var body = this.request.text();
      if (body && body.length > 0) {
        _xhr.send(body);
      } else {
        _xhr.send();
      }

      return () => {
        _xhr.onload = null;
        _xhr.abort();
      };
    });