third_party/WebKit/LayoutTests/imported/wpt/service-workers/service-worker/fetch-event-redirect.https.html - chromium/src.git - Git at Google

 <!DOCTYPE html>
 <title>Service Worker: Fetch Event Redirect Handling</title>
 <meta name=timeout content=long>
 <script src="/resources/testharness.js"></script>
 <script src="resources/testharness-helpers.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="resources/get-host-info.sub.js"></script>
 <script src="resources/test-helpers.sub.js"></script>
 <body>
 <script>

 // ------------------------
 // Utilities for testing non-navigation requests that are intercepted with
 // a redirect.

 var host_info = get_host_info();
 var worker = 'resources/fetch-rewrite-worker.js';
 var frameURL = host_info['HTTPS_ORIGIN'] + base_path() +
                'resources/fetch-event-redirect-iframe.html';
 var baseScope = 'resources/';
 var redirect = 'redirect.py';
 var success = base_path() + 'resources/success.py';

 function redirect_fetch_test(t, test) {
   var scope = baseScope + test.name;
   service_worker_unregister_and_register(t, worker, scope).then(function(reg) {
     return wait_for_state(t, reg.installing, 'activated');
   }).then(function() {
     return with_iframe(scope + '?url=' + encodeURIComponent(frameURL));
   }).then(function(frame) {
     var hostKeySuffix = test['url_credentials'] ? '_WITH_CREDS' : '';

     var acaorigin = '';
     var host = host_info['HTTPS_ORIGIN' + hostKeySuffix];
     if (test['redirect_dest'] === 'no-cors') {
       host = host_info['HTTPS_REMOTE_ORIGIN' + hostKeySuffix]
     } else if (test['redirect_dest'] === 'cors') {
       acaorigin = '?ACAOrigin=' + encodeURIComponent(host_info['HTTPS_ORIGIN']);
       host = host_info['HTTPS_REMOTE_ORIGIN' + hostKeySuffix]
     }

     var dest = '?Redirect=' + encodeURIComponent(host + success + acaorigin);

     var expectedTypeParam = test['expected_type']
                           ?  '&expected_type=' + test['expected_type']
                           : '';

     var expectedRedirectedParam = test['expected_redirected']
                                 ?  '&expected_redirected=' + test['expected_redirected']
                                 : '';

     var url = scope +
               '?url=' + encodeURIComponent(redirect + dest) +
               expectedTypeParam + expectedRedirectedParam

     var p = new Promise(function(resolve, reject) {
       var channel = new MessageChannel();
       channel.port1.onmessage = function(e) {
         frame.remove();
         if (e.data.result === 'reject') {
           reject(e.data.detail);
         } else if (e.data.result === 'success') {
           resolve(e.data.result);
         } else {
           resolve(e.data.detail);
         }
       };
       frame.contentWindow.postMessage({
         url: url,
         request_init: test.request_init,
         redirect_dest: test.redirect_dest,
         expected_type: test.expected_type,
         expected_redirected: test.expected_redirected,
       }, '*', [channel.port2]);
     });

     if (test.should_reject) {
       return assert_promise_rejects(p);
     }

     return p.then(function(result) {
       if (result !== 'success') {
         throw(new Error(result));
       }
     });
   }).then(function() {
     return service_worker_unregister_and_done(t, scope);
   }).catch(unreached_rejection(t));
 }

 // ------------------------
 // Test every combination of:
 //  - RequestMode (same-origin, cors, no-cors)
 //  - RequestRedirect (manual, follow, error)
 //  - redirect destination origin (same-origin, cors, no-cors)
 //  - redirect destination credentials (no user/pass, user/pass)
 //
 // TODO: add navigation requests
 // TODO: add redirects to data URI and verify same-origin data-URL flag behavior
 // TODO: add test where original redirect URI is cross-origin
 // TODO: verify final method is correct for 301, 302, and 303
 // TODO: verify CORS redirect results in all further redirects being
 //       considered cross origin

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-cors-redirects-to-sameorigin-nocreds',
     redirect_dest: 'same-origin',
     url_credentials: false,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'cors'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
    'same-origin without credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-cors-redirects-to-nocors-nocreds',
     redirect_dest: 'no-cors',
     url_credentials: false,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'cors'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
    'no-cors without credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-cors-redirects-to-cors-nocreds',
     redirect_dest: 'cors',
     url_credentials: false,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'cors'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
    'cors without credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-sameorigin-redirects-to-sameorigin-nocreds',
     redirect_dest: 'same-origin',
     url_credentials: false,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'same-origin'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
    'same-origin without credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-sameorigin-redirects-to-nocors-nocreds',
     redirect_dest: 'no-cors',
     url_credentials: false,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'same-origin'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
    'no-cors without credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-sameorigin-redirects-to-cors-nocreds',
     redirect_dest: 'cors',
     url_credentials: false,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'same-origin'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
    'cors without credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-nocors-redirects-to-sameorigin-nocreds',
     redirect_dest: 'same-origin',
     url_credentials: false,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'no-cors'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, no-cors mode Request redirected to ' +
    'same-origin without credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-nocors-redirects-to-nocors-nocreds',
     redirect_dest: 'no-cors',
     url_credentials: false,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'no-cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, manual redirect, no-cors mode Request redirected to ' +
    'no-cors without credentials should succeed interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-nocors-redirects-to-cors-nocreds',
     redirect_dest: 'cors',
     url_credentials: false,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'no-cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, manual redirect, no-cors mode Request redirected to ' +
    'cors without credentials should succeed interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-cors-redirects-to-sameorigin-creds',
     redirect_dest: 'same-origin',
     url_credentials: true,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'cors'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
    'same-origin with credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-cors-redirects-to-nocors-creds',
     redirect_dest: 'no-cors',
     url_credentials: true,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'cors'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
    'no-cors with credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-cors-redirects-to-cors-creds',
     redirect_dest: 'cors',
     url_credentials: true,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'cors'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, cors mode Request redirected to ' +
    'cors with credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-sameorigin-redirects-to-sameorigin-creds',
     redirect_dest: 'same-origin',
     url_credentials: true,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'same-origin'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
    'same-origin with credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-sameorigin-redirects-to-nocors-creds',
     redirect_dest: 'no-cors',
     url_credentials: true,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'same-origin'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
    'no-cors with credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-sameorigin-redirects-to-cors-creds',
     redirect_dest: 'cors',
     url_credentials: true,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'same-origin'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, same-origin mode Request redirected to ' +
    'cors with credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-nocors-redirects-to-sameorigin-creds',
     redirect_dest: 'same-origin',
     url_credentials: true,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'no-cors'
     },
     // should reject because only navigations can be intercepted with
     // opaqueredirect responses
     should_reject: true
   });
 }, 'Non-navigation, manual redirect, no-cors mode Request redirected to ' +
    'same-origin with credentials should fail opaqueredirect interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-nocors-redirects-to-nocors-creds',
     redirect_dest: 'no-cors',
     url_credentials: true,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'no-cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, manual redirect, no-cors mode Request redirected to ' +
    'no-cors with credentials should succeed interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-manual-nocors-redirects-to-cors-creds',
     redirect_dest: 'cors',
     url_credentials: true,
     expected_type: 'opaqueredirect',
     expected_redirected: false,
     request_init: {
       redirect: 'manual',
       mode: 'no-cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, manual redirect, no-cors mode Request redirected to ' +
    'cors with credentials should succeed interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-cors-redirects-to-sameorigin-nocreds',
     redirect_dest: 'same-origin',
     url_credentials: false,
     expected_type: 'basic',
     expected_redirected: true,
     request_init: {
       redirect: 'follow',
       mode: 'cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
    'same-origin without credentials should succeed interception ' +
    'and response should be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-cors-redirects-to-nocors-nocreds',
     redirect_dest: 'no-cors',
     url_credentials: false,
     expected_type: 'should-not-get-a-response',
     expected_redirected: false,
     request_init: {
       redirect: 'follow',
       mode: 'cors'
     },
     // should reject because CORS requests require CORS headers on cross-origin
     // resources
     should_reject: true
   });
 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
    'no-cors without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-cors-redirects-to-cors-nocreds',
     redirect_dest: 'cors',
     url_credentials: false,
     expected_type: 'cors',
     expected_redirected: true,
     request_init: {
       redirect: 'follow',
       mode: 'cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
    'cors without credentials should succeed interception ' +
    'and response should be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-sameorigin-redirects-to-sameorigin-nocreds',
     redirect_dest: 'same-origin',
     url_credentials: false,
     expected_type: 'basic',
     expected_redirected: true,
     request_init: {
       redirect: 'follow',
       mode: 'same-origin'
     },
     should_reject: false
   });
 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
    'same-origin without credentials should succeed interception ' +
    'and response should be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-sameorigin-redirects-to-nocors-nocreds',
     redirect_dest: 'no-cors',
     url_credentials: false,
     expected_type: 'should-not-get-a-response',
     expected_redirected: false,
     request_init: {
       redirect: 'follow',
       mode: 'same-origin'
     },
     // should reject because same-origin requests cannot load cross-origin
     // resources
     should_reject: true
   });
 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
    'no-cors without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-sameorigin-redirects-to-cors-nocreds',
     redirect_dest: 'cors',
     url_credentials: false,
     expected_type: 'should-not-get-a-response',
     expected_redirected: false,
     request_init: {
       redirect: 'follow',
       mode: 'same-origin'
     },
     // should reject because same-origin requests cannot load cross-origin
     // resources
     should_reject: true
   });
 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
    'cors without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-nocors-redirects-to-sameorigin-nocreds',
     redirect_dest: 'same-origin',
     url_credentials: false,
     expected_type: 'basic',
     expected_redirected: true,
     request_init: {
       redirect: 'follow',
       mode: 'no-cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
    'same-origin without credentials should succeed interception ' +
    'and response should be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-nocors-redirects-to-nocors-nocreds',
     redirect_dest: 'no-cors',
     url_credentials: false,
     expected_type: 'opaque',
     expected_redirected: false,
     request_init: {
       redirect: 'follow',
       mode: 'no-cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
    'no-cors without credentials should succeed interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-nocors-redirects-to-cors-nocreds',
     redirect_dest: 'cors',
     url_credentials: false,
     expected_type: 'opaque',
     expected_redirected: false,
     request_init: {
       redirect: 'follow',
       mode: 'no-cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
    'cors without credentials should succeed interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-cors-redirects-to-sameorigin-creds',
     redirect_dest: 'same-origin',
     url_credentials: true,
     expected_type: 'basic',
     expected_redirected: true,
     request_init: {
       redirect: 'follow',
       mode: 'cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
    'same-origin with credentials should succeed interception ' +
    'and response should be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-cors-redirects-to-nocors-creds',
     redirect_dest: 'no-cors',
     url_credentials: true,
     expected_type: 'should-not-get-a-response',
     expected_redirected: false,
     request_init: {
       redirect: 'follow',
       mode: 'cors'
     },
     // should reject because CORS requests require CORS headers on cross-origin
     // resources
     should_reject: true
   });
 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
    'no-cors with credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-cors-redirects-to-cors-creds',
     redirect_dest: 'cors',
     url_credentials: true,
     expected_type: 'cors',
     expected_redirected: true,
     request_init: {
       redirect: 'follow',
       mode: 'cors'
     },
     // should reject because CORS requests do not allow user/pass entries in
     // cross-origin URLs
     // NOTE: https://github.com/whatwg/fetch/issues/112
     should_reject: true
   });
 }, 'Non-navigation, follow redirect, cors mode Request redirected to ' +
    'cors with credentials should fail interception ' +
    'and response should be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-sameorigin-redirects-to-sameorigin-creds',
     redirect_dest: 'same-origin',
     url_credentials: true,
     expected_type: 'basic',
     expected_redirected: true,
     request_init: {
       redirect: 'follow',
       mode: 'same-origin'
     },
     should_reject: false
   });
 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
    'same-origin with credentials should succeed interception ' +
    'and response should be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-sameorigin-redirects-to-nocors-creds',
     redirect_dest: 'no-cors',
     url_credentials: true,
     expected_type: 'should-not-get-a-response',
     expected_redirected: false,
     request_init: {
       redirect: 'follow',
       mode: 'same-origin'
     },
     // should reject because same-origin requests cannot load cross-origin
     // resources
     should_reject: true
   });
 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
    'no-cors with credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-sameorigin-redirects-to-cors-creds',
     redirect_dest: 'cors',
     url_credentials: true,
     expected_type: 'should-not-get-a-response',
     expected_redirected: false,
     request_init: {
       redirect: 'follow',
       mode: 'same-origin'
     },
     // should reject because same-origin requests cannot load cross-origin
     // resources
     should_reject: true
   });
 }, 'Non-navigation, follow redirect, same-origin mode Request redirected to ' +
    'cors with credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-nocors-redirects-to-sameorigin-creds',
     redirect_dest: 'same-origin',
     url_credentials: true,
     expected_type: 'basic',
     expected_redirected: true,
     request_init: {
       redirect: 'follow',
       mode: 'no-cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
    'same-origin with credentials should succeed interception ' +
    'and response should be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-nocors-redirects-to-nocors-creds',
     redirect_dest: 'no-cors',
     url_credentials: true,
     expected_type: 'opaque',
     expected_redirected: false,
     request_init: {
       redirect: 'follow',
       mode: 'no-cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
    'no-cors with credentials should succeed interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-follow-nocors-redirects-to-cors-creds',
     redirect_dest: 'cors',
     url_credentials: true,
     expected_type: 'opaque',
     expected_redirected: false,
     request_init: {
       redirect: 'follow',
       mode: 'no-cors'
     },
     should_reject: false
   });
 }, 'Non-navigation, follow redirect, no-cors mode Request redirected to ' +
    'cors with credentials should succeed interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-cors-redirects-to-sameorigin-nocreds',
     redirect_dest: 'same-origin',
     url_credentials: false,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
    'same-origin without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-cors-redirects-to-nocors-nocreds',
     redirect_dest: 'no-cors',
     url_credentials: false,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
    'no-cors without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-cors-redirects-to-cors-nocreds',
     redirect_dest: 'cors',
     url_credentials: false,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
    'cors without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-sameorigin-redirects-to-sameorigin-nocreds',
     redirect_dest: 'same-origin',
     url_credentials: false,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'same-origin'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
    'same-origin without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-sameorigin-redirects-to-nocors-nocreds',
     redirect_dest: 'no-cors',
     url_credentials: false,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'same-origin'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
    'no-cors without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-sameorigin-redirects-to-cors-nocreds',
     redirect_dest: 'cors',
     url_credentials: false,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'same-origin'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
    'cors without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-nocors-redirects-to-sameorigin-nocreds',
     redirect_dest: 'same-origin',
     url_credentials: false,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'no-cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, no-cors mode Request redirected to ' +
    'same-origin without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-nocors-redirects-to-nocors-nocreds',
     redirect_dest: 'no-cors',
     url_credentials: false,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'no-cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, no-cors mode Request redirected to ' +
    'no-cors without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-nocors-redirects-to-cors-nocreds',
     redirect_dest: 'cors',
     url_credentials: false,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'no-cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, no-cors mode Request redirected to ' +
    'cors without credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-cors-redirects-to-sameorigin-creds',
     redirect_dest: 'same-origin',
     url_credentials: true,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
    'same-origin with credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-cors-redirects-to-nocors-creds',
     redirect_dest: 'no-cors',
     url_credentials: true,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
    'no-cors with credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-cors-redirects-to-cors-creds',
     redirect_dest: 'cors',
     url_credentials: true,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, cors mode Request redirected to ' +
    'cors with credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-sameorigin-redirects-to-sameorigin-creds',
     redirect_dest: 'same-origin',
     url_credentials: true,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'same-origin'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
    'same-origin with credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-sameorigin-redirects-to-nocors-creds',
     redirect_dest: 'no-cors',
     url_credentials: true,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'same-origin'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
    'no-cors with credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-sameorigin-redirects-to-cors-creds',
     redirect_dest: 'cors',
     url_credentials: true,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'same-origin'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, same-origin mode Request redirected to ' +
    'cors with credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-nocors-redirects-to-sameorigin-creds',
     redirect_dest: 'same-origin',
     url_credentials: true,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'no-cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, no-cors mode Request redirected to ' +
    'same-origin with credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-nocors-redirects-to-nocors-creds',
     redirect_dest: 'no-cors',
     url_credentials: true,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'no-cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, no-cors mode Request redirected to ' +
    'no-cors with credentials should fail interception ' +
    'and response should not be redirected');

 async_test(function(t) {
   redirect_fetch_test(t, {
     name: 'nonav-error-nocors-redirects-to-cors-creds',
     redirect_dest: 'cors',
     url_credentials: true,
     expected_type: 'error',
     expected_redirected: false,
     request_init: {
       redirect: 'error',
       mode: 'no-cors'
     },
     // should reject because requests with 'error' RequestRedirect cannot be
     // redirected.
     should_reject: true
   });
 }, 'Non-navigation, error redirect, no-cors mode Request redirected to ' +
    'cors with credentials should fail interception and response should not ' +
    'be redirected');
 </script>
 </body>