[ServiceWorker] Make Request class better conformance with the spec.

LayoutTests/http/tests/serviceworker/resources/request-worker.js

 importScripts('worker-test-helpers.js');
 
-test(function() {
-    var headers = new HeaderMap;
+var url = 'https://www.example.com/test.html';

[falken, 2014/07/04 05:43:39]

name this to be a constant like var URL?

[horo, 2014/07/04 08:00:38]

Done.

+test(function() {
+    var headers = new Headers;
     headers.set('User-Agent', 'Mozilla/5.0');
     headers.set('Accept', 'text/html');
     headers.set('X-ServiceWorker-Test', 'request test field');
 
-    var request = new Request({
-        url: 'https://www.example.com/test.html',
-        method: 'GET',
-        headers: headers
-    });
-
-    assert_equals(request.url, 'https://www.example.com/test.html', 'Request.url should match');
+    var request = new Request(url, {method: 'GET', headers: headers});
+
+    assert_equals(request.url, url, 'Request.url should match');
     assert_equals(request.method, 'GET', 'Request.method should match');
-    assert_equals(request.origin, 'https://www.example.com', 'Request.origin should match');
-    assert_true(request.headers instanceof HeaderMap, 'Request.headers should be HeaderMap');
-    assert_equals(request.headers.size, 3, 'Request.headers.size should match');
-    // Note: detailed behavioral tests for HeaderMap are in another test,
-    // http/tests/serviceworker/headermap.html.
+    assert_equals(request.referrer, location.href, 'Request.referrer should match');
+    assert_true(request.headers instanceof Headers, 'Request.headers should be Headers');
+
+    // 'User-Agent' is a forbidden header.
+    assert_equals(request.headers.size, 2, 'Request.headers.size should match');
+    // Note: detailed behavioral tests for Headers are in another test,
+    // http/tests/serviceworker/headers.html.
 
     request.url = 'http://localhost/';
-    assert_equals(request.url, 'http://localhost/', 'Request.url should be writable');
-    request.url = 'http://localhost/\uD800'; // Unmatched lead surrogate.
+    assert_equals(request.url, 'https://www.example.com/test.html', 'Request.url should be readonly');
+    request = new Request('http://localhost/\uD800'); // Unmatched lead surrogate.
     assert_equals(request.url,
                   'http://localhost/' + encodeURIComponent('\uFFFD'),
                   'Request.url should have unmatched surrogates replaced.');
     request.method = 'POST';
-    assert_equals(request.method, 'POST', 'Request.method should be writable');
-    assert_throws({name: 'TypeError'}, function() { request.method = 'invalid \u0100'; },
-                  'Request.method should throw on invalid ByteString');
-
-}, 'Request in ServiceWorkerGlobalScope');
+    assert_equals(request.method, 'GET', 'Request.method should be readonly');
+},

[falken, 2014/07/04 05:43:39]

I think we typically don't line break here

[horo, 2014/07/04 08:00:37]

Done.

+'Request basic test in ServiceWorkerGlobalScope');
+
+test(function() {
+    [new Request(url),
+     new Request(url, {method: ''}),
+     new Request(url, {mode: ''}),
+     new Request(url, {mode: 'invalid mode'}),
+     new Request(url, {credentials: ''}),
+     new Request(url, {credentials: 'invalid credentials'})].forEach(function(request) {
+        assert_equals(request.url, url, 'Request.url should match');
+        assert_equals(request.method, 'GET', 'Default Request.method should be GET');
+        assert_equals(request.mode, 'cors', 'Default Request.mode should be cors');
+        assert_equals(request.credentials, 'omit', 'Default Request.credentials should be omit');
+    });
+},
+'Request default value test in ServiceWorkerGlobalScope');
+
+test(function() {
+    var request = new Request(url);
+    request.headers.append('X-ServiceWorker-Foo', 'foo1');
+    request.headers.append('X-ServiceWorker-Foo', 'foo2');
+    request.headers.append('X-ServiceWorker-Bar', 'bar');
+    var request2 = new Request(request);
+    assert_equals(request2.url, url, 'Request.url should match');
+    assert_equals(request2.method, 'GET', 'Request.method should match');
+    assert_equals(request2.mode, 'cors', 'Request.mode should match');
+    assert_equals(request2.credentials, 'omit', 'Request.credentials should match');
+    assert_equals(request2.headers.getAll('X-ServiceWorker-Foo')[0], 'foo1',
+                  'Request.headers should match');
+    assert_equals(request2.headers.getAll('X-ServiceWorker-Foo')[1], 'foo2',
+                  'Request.headers should match');
+    assert_equals(request2.headers.getAll('X-ServiceWorker-Bar')[0], 'bar',
+                  'Request.headers should match');
+},
+'Request header test in ServiceWorkerGlobalScope');
+
+test(function() {
+    var request1 = {};
+    var request2 = {};
+    var kMethods = ['GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'OPTIONS', '', undefined];
+    var kSimpleMethod = ['GET', 'HEAD', 'POST', '', undefined];
+    var kModes = ['same-origin', 'no-cors', 'cors', '', undefined];

[falken, 2014/07/04 05:43:39]

It looks uncommon to use kVariable to denote a constant in our JS codebase.
Google JS guide says use NAMES_LIKE_THIS, which is more common in Blink layout
tests as well.

[horo, 2014/07/04 08:00:38]

Done.

+    var isSimpleMethod = function (method) {

[falken, 2014/07/04 05:43:39]

This seems more readable as simply function isSimpleMethod(method) {

[falken, 2014/07/04 05:43:40]

Be consistent with "function (" vs "function(". I think we prefer no space.

[horo, 2014/07/04 08:00:38]

Done.

[horo, 2014/07/04 08:00:38]

Done.

+      return kSimpleMethod.indexOf(method) != -1;
+    };
+    var effectiveMethod = function (method1, method2) {
+      return method2 ? method2 : (method1 ? method1 : 'GET');
+    };
+    var effectiveMode = function (mode1, mode2) {
+      return mode2 ? mode2 : (mode1 ? mode1 : 'cors');
+    };
+    kMethods.forEach(function(method1) {
+        kModes.forEach(function(mode1) {
+            var init1 = {};
+            if (method1 != undefined) { init1['method'] = method1; }
+            if (mode1 != undefined) { init1['mode'] = mode1; }
+            if (!isSimpleMethod(method1) && mode1 == 'no-cors') {
+                assert_throws(
+                    {name:'TypeError'},
+                    function() { request1 = new Request(url, init1); },
+                    'new no-cors Request with non simple method (' + method1 +') should throw');
+                return;
+            }
+            request1 = new Request(url, init1);
+            assert_equals(request1.method, method1 ? method1 : 'GET', 'Request.method should match');
+            assert_equals(request1.mode, mode1 ? mode1 : 'cors', 'Request.mode should match');
+            request1 = new Request(request1);
+            assert_equals(request1.method, method1 ? method1 : 'GET', 'Request.method should match');
+            assert_equals(request1.mode, mode1 ? mode1 : 'cors', 'Request.mode should match');
+            kMethods.forEach(function(method2) {
+                kModes.forEach(function(mode2) {
+                    var init2 = {};
+                    if (method2 != undefined) { init2['method'] = method2; }
+                    if (mode2 != undefined) { init2['mode'] = mode2; }
+                    if (!isSimpleMethod(effectiveMethod(method1, method2)) &&
+                        effectiveMode(mode1,mode2) == 'no-cors') {

[falken, 2014/07/04 05:43:39]

If you want to wrap, this should be indented an additional 4 spaces. Seems fine
to just not wrap.

[falken, 2014/07/04 05:43:39]

spacing: mode1, mode2

[horo, 2014/07/04 08:00:38]

Done.

[horo, 2014/07/04 08:00:38]

Done.

+                        assert_throws(
+                            {name:'TypeError'},
+                            function() { request2 = new Request(request1, init2); },
+                            'new no-cors Request with non simple method should throw');
+                        return;
+                    }
+                    request2 = new Request(request1, init2);
+                    assert_equals(request2.method,
+                                  method2 ? method2 : request1.method,
+                                  'Request.method should be overridden');
+                    assert_equals(request2.mode,
+                                  mode2 ? mode2 : request1.mode,
+                                  'Request.mode should be overridden');
+                });
+            });
+        });
+    });
+},
+'Request header test in ServiceWorkerGlobalScope');
+
+test(function() {
+    var request1 = {};
+    var request2 = {};
+    var kCredentials = ['omit', 'same-origin', 'include', '', undefined];
+    kCredentials.forEach(function(credentials1) {
+        var init1 = {};
+        if (credentials1 != undefined) { init1['credentials'] = credentials1; }
+        request1 = new Request(url, init1);
+        assert_equals(request1.credentials, credentials1 ? credentials1 : 'omit', 'Request.credentials should match');
+        request1 = new Request(request1);
+        assert_equals(request1.credentials, credentials1 ? credentials1 : 'omit', 'Request.credentials should match');
+        kCredentials.forEach(function(credentials2) {
+            var init2 = {};
+            if (credentials2 != undefined) { init2['credentials'] = credentials2; }
+            request2 = new Request(request1, init2);
+            assert_equals(request2.credentials,
+                          credentials2 ? credentials2 : request1.credentials,
+                          'Request.credentials should be overridden');
+        });
+    });
+},
+'Request credentials test in ServiceWorkerGlobalScope');
+
+test(function() {
+    ['same-origin', 'cors', 'no-cors'].forEach(function(mode) {
+        var forbiddenMethods = ['TRACE', 'TRACK', 'CONNECT'];
+        forbiddenMethods.forEach(function(method) {
+            assert_throws(
+                {name:'TypeError'},
+                function() { var request = new Request(url, {mode: mode, method: method}); },
+                'new Request with a forbidden method (' + method +') should throw');
+        });
+        var invalidNames = ['(', ')', '<', '>', '@', ',', ';', ':', '\\', '"',
+                            '/', '[', ']', '?', '=', '{', '}', '\u3042', 'a(b',
+                            'invalid name'];
+        invalidNames.forEach(function(name) {
+            assert_throws(
+                {name:'TypeError'},
+                function() { var request = new Request(url, {mode: mode, method: name}); },
+                'new Request with an invalid method (' + name +') should throw');
+        });
+    });
+},
+'Request method name test in ServiceWorkerGlobalScope');
+
+test(function() {
+    var kForbiddenHeaders =
+        ['Accept-Charset', 'Accept-Encoding', 'Access-Control-Request-Headers',
+         'Access-Control-Request-Method', 'Connection', 'Content-Length', 'Cookie',
+         'Cookie2', 'Date', 'DNT', 'Expect', 'Host', 'Keep-Alive', 'Origin',
+         'Referer', 'TE', 'Trailer', 'Transfer-Encoding', 'Upgrade', 'User-Agent',
+         'Via', 'Proxy-', 'Sec-', 'Proxy-FooBar', 'Sec-FooBar'];
+    var kSimpleHeaders =
+        [['Accept', '*'], ['Accept-Language', 'ru'], ['Content-Language', 'ru'],
+         ['Content-Type', 'application/x-www-form-urlencoded'],
+         ['Content-Type', 'multipart/form-data'],
+         ['Content-Type', 'text/plain']];
+    var kNonSimpleHeaders =
+        [['X-ServiceWorker-Test', 'test'],
+         ['X-ServiceWorker-Test2', 'test2'],
+         ['Content-Type', 'foo/bar']];
+
+    ['same-origin', 'cors'].forEach(function(mode) {
+        var request = new Request(url, {mode: mode});
+        kForbiddenHeaders.forEach(function(header) {
+            request.headers.append(header, 'test');
+            assert_equals(request.headers.size, 0,
+                          'Request.headers.append should ignore the forbidden headers');
+            request.headers.set(header, 'test');
+            assert_equals(request.headers.size, 0,
+                          'Request.headers.set should ignore the forbidden headers');
+        });
+        var request = new Request(url, {mode: mode});
+        assert_equals(request.headers.size, 0);
+        kNonSimpleHeaders.forEach(function(header) {
+            request.headers.append(header[0], header[1]);
+        });
+        assert_equals(request.headers.size, kNonSimpleHeaders.length);
+        kNonSimpleHeaders.forEach(function(header) {
+            assert_equals(request.headers.get(header[0]), header[1]);
+        });
+        request = new Request(url, {mode: mode});
+        assert_equals(request.headers.size, 0);
+        kNonSimpleHeaders.forEach(function(header) {
+            request.headers.set(header[0], header[1]);
+        });
+        assert_equals(request.headers.size, kNonSimpleHeaders.length);
+        kNonSimpleHeaders.forEach(function(header) {
+            assert_equals(request.headers.get(header[0]), header[1]);
+        });
+    });
+    request = new Request(url, {mode: 'no-cors'});
+    kForbiddenHeaders.forEach(function(header) {
+        request.headers.set(header, 'test');
+        request.headers.append(header, 'test');
+    });
+    kNonSimpleHeaders.forEach(function(header) {
+        request.headers.set(header[0], header[1]);
+        request.headers.append(header[0], header[1]);
+    });
+    assert_equals(request.headers.size, 0,
+                  'no-cors request should only accept simple headers');
+
+    kSimpleHeaders.forEach(function(header) {
+        request = new Request(url, {mode: 'no-cors'});
+        request.headers.append(header[0], header[1]);
+        assert_equals(request.headers.size, 1,
+                      'no-cors request should accept simple headers');
+        request = new Request(url, {mode: 'no-cors'});
+        request.headers.set(header[0], header[1]);
+        assert_equals(request.headers.size, 1,
+                      'no-cors request should accept simple headers');
+        request.headers.delete(header[0]);
+        if (header[0] == 'Content-Type') {
+            assert_equals(
+                request.headers.size, 1,
+                'Content-Type header of no-cors request shouldn\'t be deleted');
+        } else {
+            assert_equals(request.headers.size, 0);
+        }
+    });
+
+    kSimpleHeaders.forEach(function(header) {
+        var headers = {};
+        kNonSimpleHeaders.forEach(function(header2) {
+            headers[header2[0]] = header2[1];
+        });
+        kForbiddenHeaders.forEach(function(header) { headers[header] = 'foo';});

[falken, 2014/07/04 05:43:40]

space between ; and } for consistency with rest of file

[horo, 2014/07/04 08:00:38]

Done.

+        headers[header[0]] = header[1];
+        var expectedSize = kNonSimpleHeaders.length;
+        if (header[0] != 'Content-Type') {
+            ++expectedSize;
+        }
+        ['same-origin', 'cors'].forEach(function(mode) {
+          request = new Request(url, {mode: mode, headers: headers});
+          assert_equals(request.headers.size, expectedSize,
+                        'Request should not support the forbidden headers');
+        });
+        request = new Request(url, {mode: 'no-cors', headers: headers});
+        assert_equals(request.headers.size, 1,
+                      'No-CORS Request.headers should only support simple headers');
+    });
+},
+'Request headers test in ServiceWorkerGlobalScope');