refactor(http): remove default settings from RequestOptions constructor

The BaseRequestOptions class is responsible for declaring default values,
while the RequestOptions class is merely responsible for setting values
based on values provided in the constructor.

modules/angular2/test/http/backends/xhr_backend_spec.ts

@@ -1,5 +1,6 @@
 import {
   AsyncTestCompleter,
+  afterEach,
   beforeEach,
   ddescribe,
   describe,
@@ -10,35 +11,47 @@ import {
   xit,
   SpyObject
 } from 'angular2/test_lib';
-import {BrowserXHR} from 'angular2/src/http/backends/browser_xhr';
+import {ObservableWrapper} from 'angular2/src/facade/async';
+import {BrowserXhr} from 'angular2/src/http/backends/browser_xhr';
 import {XHRConnection, XHRBackend} from 'angular2/src/http/backends/xhr_backend';
 import {bind, Injector} from 'angular2/di';
 import {Request} from 'angular2/src/http/static_request';
-import {StringMapWrapper} from 'angular2/src/facade/collection';
-import {RequestOptions} from 'angular2/src/http/base_request_options';
+import {Map} from 'angular2/src/facade/collection';
+import {RequestOptions, BaseRequestOptions} from 'angular2/src/http/base_request_options';
+import {BaseResponseOptions, ResponseOptions} from 'angular2/src/http/base_response_options';
+import {ResponseTypes} from 'angular2/src/http/enums';
 
 var abortSpy;
 var sendSpy;
 var openSpy;
 var addEventListenerSpy;
+var existingXHRs = [];
 
-class MockBrowserXHR extends BrowserXHR {
+class MockBrowserXHR extends BrowserXhr {
   abort: any;
   send: any;
   open: any;
-  addEventListener: any;
   response: any;
   responseText: string;
+  callbacks: Map<string, Function>;
   constructor() {
     super();
     var spy = new SpyObject();
     this.abort = abortSpy = spy.spy('abort');
     this.send = sendSpy = spy.spy('send');
     this.open = openSpy = spy.spy('open');
-    this.addEventListener = addEventListenerSpy = spy.spy('addEventListener');
+    this.callbacks = new Map();
   }
 
-  build() { return new MockBrowserXHR(); }
+  addEventListener(type: string, cb: Function) { this.callbacks.set(type, cb); }
+
+  dispatchEvent(type: string) { this.callbacks.get(type)({}); }
+
+  build() {
+    var xhr = new MockBrowserXHR();
+    existingXHRs.push(xhr);
+    return xhr;
+  }
 }
 
 export function main() {
@@ -47,17 +60,35 @@ export function main() {
     var sampleRequest;
 
     beforeEach(() => {
-      var injector =
-          Injector.resolveAndCreate([bind(BrowserXHR).toClass(MockBrowserXHR), XHRBackend]);
+      var injector = Injector.resolveAndCreate([
+        bind(ResponseOptions)
+            .toClass(BaseResponseOptions),
+        bind(BrowserXhr).toClass(MockBrowserXHR),
+        XHRBackend
+      ]);
       backend = injector.get(XHRBackend);
-      sampleRequest = new Request(new RequestOptions({url: 'https://google.com'}));
+      var base = new BaseRequestOptions();
+      sampleRequest = new Request(base.merge(new RequestOptions({url: 'https://google.com'})));
     });
 
+    afterEach(() => { existingXHRs = []; });
+
     it('should create a connection',
        () => { expect(() => backend.createConnection(sampleRequest)).not.toThrow(); });
 
 
     describe('XHRConnection', () => {
+      it('should use the injected BaseResponseOptions to create the response',
+         inject([AsyncTestCompleter], async => {
+           var connection = new XHRConnection(sampleRequest, new MockBrowserXHR(),
+                                              new ResponseOptions({type: ResponseTypes.Error}));
+           ObservableWrapper.subscribe(connection.response, res => {
+             expect(res.type).toBe(ResponseTypes.Error);
+             async.done();
+           });
+           existingXHRs[0].dispatchEvent('load');
+         }));
+
       it('should call abort when disposed', () => {
         var connection = new XHRConnection(sampleRequest, new MockBrowserXHR());
         connection.dispose();
@@ -73,7 +104,9 @@ export function main() {
 
       it('should automatically call send on the backend with request body', () => {
         var body = 'Some body to love';
-        new XHRConnection(new Request(new RequestOptions({body: body})), new MockBrowserXHR());
+        var base = new BaseRequestOptions();
+        new XHRConnection(new Request(base.merge(new RequestOptions({body: body}))),
+                          new MockBrowserXHR());
         expect(sendSpy).toHaveBeenCalledWith(body);
       });
     });

modules/angular2/test/http/base_request_options_spec.ts

@@ -9,22 +9,22 @@ import {
   it,
   xit
 } from 'angular2/test_lib';
-import {BaseRequestOptions} from 'angular2/src/http/base_request_options';
+import {BaseRequestOptions, RequestOptions} from 'angular2/src/http/base_request_options';
 import {RequestMethods, RequestModesOpts} from 'angular2/src/http/enums';
 
 export function main() {
   describe('BaseRequestOptions', () => {
     it('should create a new object when calling merge', () => {
       var options1 = new BaseRequestOptions();
-      var options2 = options1.merge({method: RequestMethods.DELETE});
+      var options2 = options1.merge(new RequestOptions({method: RequestMethods.DELETE}));
       expect(options2).not.toBe(options1);
       expect(options2.method).toBe(RequestMethods.DELETE);
     });
 
     it('should retain previously merged values when merging again', () => {
       var options1 = new BaseRequestOptions();
-      var options2 = options1.merge({method: RequestMethods.DELETE});
-      var options3 = options2.merge({mode: RequestModesOpts.NoCors});
+      var options2 = options1.merge(new RequestOptions({method: RequestMethods.DELETE}));
+      var options3 = options2.merge(new RequestOptions({mode: RequestModesOpts.NoCors}));
       expect(options3.mode).toBe(RequestModesOpts.NoCors);
       expect(options3.method).toBe(RequestMethods.DELETE);
     });

modules/angular2/test/http/http_spec.ts

@@ -17,6 +17,7 @@ import {MockBackend} from 'angular2/src/http/backends/mock_backend';
 import {Response} from 'angular2/src/http/static_response';
 import {RequestMethods} from 'angular2/src/http/enums';
 import {BaseRequestOptions, RequestOptions} from 'angular2/src/http/base_request_options';
+import {ResponseOptions} from 'angular2/src/http/base_response_options';
 import {Request} from 'angular2/src/http/static_request';
 import {EventEmitter, ObservableWrapper} from 'angular2/src/facade/async';
 import {ConnectionBackend} from 'angular2/src/http/interfaces';
@@ -52,7 +53,7 @@ export function main() {
       ]);
       http = injector.get(Http);
       backend = injector.get(MockBackend);
-      baseResponse = new Response({body: 'base response'});
+      baseResponse = new Response(new ResponseOptions({body: 'base response'}));
     });
 
     afterEach(() => backend.verifyNoPendingRequests());
@@ -67,7 +68,7 @@ export function main() {
            inject([AsyncTestCompleter], (async) => {
              ObservableWrapper.subscribe(backend.connections, c => {
                expect(c.request.url).toBe('https://google.com');
-               c.mockRespond(new Response({body: 'Thank you'}));
+               c.mockRespond(new Response(new ResponseOptions({body: 'Thank you'})));
                async.done();
              });
              ObservableWrapper.subscribe(