Introduce Response.redirect attribute and add LayoutTest.

third_party/WebKit/LayoutTests/http/tests/fetch/script-tests/fetch.js

 if (self.importScripts) {
   importScripts('../resources/fetch-test-helpers.js');
 }
 
 promise_test(function(t) {
     return fetch('http://')
       .then(
         t.unreached_func('fetch of invalid URL must fail'),
         function() {});
   }, 'Fetch invalid URL');
@@ skipping 11 matching lines @@
 
 // Tests for data: scheme.
 promise_test(function(t) {
     return fetch('data:,Foobar')
       .then(function(response) {
           assert_equals(response.status, 200);
           assert_equals(response.statusText, 'OK');
           assert_equals(response.headers.get('Content-Type'),
                         'text/plain;charset=US-ASCII');
           assert_equals(size(response.headers), 1);
+          assert_false(response.redirected);
           if (self.internals) {
             assert_array_equals(
                 self.internals.getInternalResponseURLList(response),
                 ['data:,Foobar']);
           }
           return response.text();
         })
       .then(function(text) {
           assert_equals(text, 'Foobar');
         });
@@ skipping 19 matching lines @@
   }, 'fetch data: URL with the POST method');
 
 promise_test(function(t) {
     return fetch('data:text/html;charset=utf-8;base64,5paH5a2X')
       .then(function(response) {
           assert_equals(response.status, 200);
           assert_equals(response.statusText, 'OK');
           assert_equals(response.headers.get('Content-Type'),
                         'text/html;charset=utf-8');
           assert_equals(size(response.headers), 1);
+          assert_false(response.redirected);
           if (self.internals) {
             assert_array_equals(
                 self.internals.getInternalResponseURLList(response),
                 ['data:text/html;charset=utf-8;base64,5paH5a2X']);
           }
           return response.text();
         })
       .then(function(text) {
           assert_equals(text, '\u6587\u5b57');
         });
@@ skipping 11 matching lines @@
   // Tests for blob: scheme.
   promise_test(function(t) {
       var url = URL.createObjectURL(new Blob(['fox'], {type: 'text/fox'}));
       return fetch(url)
         .then(function(response) {
             assert_equals(response.status, 200);
             assert_equals(response.statusText, 'OK');
             assert_equals(response.headers.get('Content-Type'), 'text/fox');
             assert_equals(response.headers.get('Content-Length'), '3');
             assert_equals(size(response.headers), 2);
+            assert_false(response.redirected);
             if (self.internals) {
               assert_array_equals(
                   self.internals.getInternalResponseURLList(response), [url]);
             }
             return response.text();
           })
         .then(function(text) {
             assert_equals(text, 'fox');
           });
     }, 'fetch blob: URL');
@@ skipping 17 matching lines @@
         t.unreached_func('scheme not listed in basic fetch spec must fail'),
         function() {});
   }, 'fetch of scheme not listed in basic fetch spec');
 
 promise_test(function(t) {
     var request = new Request('/fetch/resources/fetch-status.php?status=200');
     return fetch(request)
       .then(function(response) {
           assert_equals(response.status, 200);
           assert_equals(response.statusText, 'OK');
+          assert_false(response.redirected);
           if (self.internals) {
             assert_array_equals(
                 self.internals.getInternalResponseURLList(response),
                 [request.url]);
           }
         });
   }, 'Fetch result of 200 response');
 
 promise_test(function(t) {
     var request = new Request('/fetch/resources/fetch-status.php?status=404');
     return fetch(request)
       .then(function(response) {
           assert_equals(response.status, 404);
           assert_equals(response.statusText, 'Not Found');
+          assert_false(response.redirected);
           if (self.internals) {
             assert_array_equals(
                 self.internals.getInternalResponseURLList(response),
                 [request.url]);
           }
         });
   }, 'Fetch result of 404 response');
 
 promise_test(function(t) {
     var request = new Request(
       '/fetch/resources/fetch-status.php?status=200#fragment');
 
     // The url attribute's getter must return request's url,
     // serialized with the exclude fragment flag set.
     assert_equals(request.url,
       BASE_ORIGIN + '/fetch/resources/fetch-status.php?status=200');
 
     return fetch(request)
       .then(function(response) {
           assert_equals(response.status, 200);
           assert_equals(response.statusText, 'OK');
           // The url attribute's getter must return the empty string
           // if response's url is null and response's url,
           // serialized with the exclude fragment flag set, otherwise.
           assert_equals(response.url,
             BASE_ORIGIN + '/fetch/resources/fetch-status.php?status=200');
+          assert_false(response.redirected);
           if (self.internals) {
             assert_array_equals(
                 self.internals.getInternalResponseURLList(response),
                 [BASE_ORIGIN +
                  '/fetch/resources/fetch-status.php?status=200#fragment']);
           }
         });
   }, 'Request/response url attribute getter with fragment');
 
 promise_test(function(t) {
     var redirect_target_url =
       BASE_ORIGIN + '/fetch/resources/fetch-status.php?status=200';
     var redirect_original_url =
       BASE_ORIGIN + '/serviceworker/resources/redirect.php?Redirect=' +
       redirect_target_url;
 
     var request = new Request(redirect_original_url);
     assert_equals(request.url, redirect_original_url,
       'Request\'s url is the original URL');
     assert_equals(request.redirect, 'follow');
 
     return fetch(request)
       .then(function(response) {
           assert_equals(response.status, 200);
           assert_equals(response.statusText, 'OK');
           assert_equals(response.url, redirect_target_url,
             'Response\'s url is locationURL');
           assert_equals(request.url, redirect_original_url,
             'Request\'s url remains the original URL');
+          assert_true(response.redirected);
           if (self.internals) {
             assert_array_equals(
                 self.internals.getInternalResponseURLList(response),
                 [request.url, response.url]);
           }
         });
   }, 'Request/response url attribute getter with redirect');
 
 promise_test(function(t) {
     var redirect_target_url =
       BASE_ORIGIN + '/fetch/resources/fetch-status.php?status=200';
     var redirect_original_url =
       BASE_ORIGIN + '/serviceworker/resources/redirect.php?Redirect=' +
       redirect_target_url;
 
     var request = new Request(redirect_original_url, {redirect: 'manual'});
     assert_equals(request.url, redirect_original_url,
       'Request\'s url is the original URL');
     assert_equals(request.redirect, 'manual');
 
     return fetch(request)
       .then(function(response) {
           assert_equals(response.status, 0);
           assert_equals(response.type, 'opaqueredirect');
           assert_equals(response.url, request.url);
+          assert_false(response.redirected);
           if (self.internals) {
             assert_array_equals(
                 self.internals.getInternalResponseURLList(response),
                 [redirect_original_url]);
           }
         });
   }, 'Manual redirect fetch returns opaque redirect response');
 
 promise_test(function(t) {
     var redirect_target_url =
@@ skipping 35 matching lines @@
         function() {});
   }, 'Redirect response must cause an error when redirect mode is error.');
 
 promise_test(function(test) {
     var url = BASE_ORIGIN + '/fetch/resources/doctype.html';
     return fetch(new Request(url, {redirect: 'manual'}))
       .then(function(response) {
           assert_equals(response.status, 200);
           assert_equals(response.statusText, 'OK');
           assert_equals(response.url, url);
+          assert_false(response.redirected);
           if (self.internals) {
             assert_array_equals(
                 self.internals.getInternalResponseURLList(response), [url]);
           }
           return response.text();
         })
       .then(function(text) { assert_equals(text, '<!DOCTYPE html>\n'); })
     }, 'No-redirect fetch completes normally even if redirect mode is manual');
 
 promise_test(function(test) {
     var url = BASE_ORIGIN + '/fetch/resources/doctype.html';
     return fetch(new Request(url, {redirect: 'error'}))
       .then(function(response) {
           assert_equals(response.status, 200);
           assert_equals(response.statusText, 'OK');
           assert_equals(response.url, url);
+          assert_false(response.redirected);
           if (self.internals) {
             assert_array_equals(
                 self.internals.getInternalResponseURLList(response), [url]);
           }
           return response.text();
         })
       .then(function(text) { assert_equals(text, '<!DOCTYPE html>\n'); })
     }, 'No-redirect fetch completes normally even if redirect mode is error');
 
 function evalJsonp(text) {
@@ skipping 119 matching lines @@
     assert_true(req.bodyUsed);
 }, 'Calling fetch() disturbs body if not null');
 
 test(t => {
     var req = new Request('/', {method: 'POST'});
     fetch(req);
     assert_false(req.bodyUsed);
 }, 'Calling fetch() doesn\'t disturb body if null');
 
 done();