[Fetch API] Reflect spec changes of bodyUsed property

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

 if (self.importScripts) {
   importScripts('../resources/fetch-test-helpers.js');
 }
 
 var URL = 'https://www.example.com/test.html';
 
 test(function() {
     var headers = new Headers;
     headers.set('User-Agent', 'Mozilla/5.0');
     headers.set('Accept', 'text/html');
@@ skipping 317 matching lines @@
                       'method should not be changed when normalized: ' +
                       method);
       });
   }, 'Request: valid method names and normalize test');
 
 test(function() {
     var req = new Request(URL);
     assert_false(req.bodyUsed,
                  'Request should not be flagged as used if it has not been ' +
                  'consumed.');
-    // See https://crbug.com/501195.
     var req2 = new Request(req);
-    assert_true(req.bodyUsed,
-                'Request should be flagged as used if it does not have' +
-                'body.');
+    assert_false(req.bodyUsed,
+                 'Request should not be flagged as used if it does not ' +
+                 'have body.');
     assert_false(req2.bodyUsed,
                  'Request should not be flagged as used if it has not been ' +
                  'consumed.');
   }, 'Request construction without body behavior regardning "bodyUsed"');
 
 test(function() {
     var req = new Request(URL, {method: 'POST', body: 'hello'});
     assert_false(req.bodyUsed,
                  'Request should not be flagged as used if it has not been ' +
                  'consumed.');
@@ skipping 119 matching lines @@
           function() {
             new Request(URL,
                         {method: method,
                          body: new Blob(['Test Blob'], {type: 'test/type'})
                         });
           },
           'Request of GET/HEAD method cannot have RequestInit body.');
       });
   }, 'Request of GET/HEAD method cannot have RequestInit body.');
 
+test(() => {
+    var req = new Request(URL, {method: 'POST', body: 'hello'});
+    req.text();
+    assert_true(req.bodyUsed);
+    assert_throws({name: 'TypeError'}, () => { req.clone(); });
+  }, 'Used => clone');
+
 promise_test(function() {
     var headers = new Headers;
     headers.set('Content-Language', 'ja');
     var req = new Request(URL, {
         method: 'POST',
         headers: headers,
         body: new Blob(['Test Blob'], {type: 'test/type'})
       });
     var req2 = req.clone();
+    assert_false(req.bodyUsed);
+    assert_false(req2.bodyUsed);
     // Change headers and of original request.
     req.headers.set('Content-Language', 'en');
     assert_equals(req2.headers.get('Content-Language'), 'ja',
                   'Headers of cloned request should not change when ' +
                   'original request headers are changed.');
 
     return req.text().then(function(text) {
         assert_equals(text, 'Test Blob', 'Body of request should match.');
         return req2.text();
       }).then(function(text) {
         assert_equals(text, 'Test Blob', 'Cloned request body should match.');
-        return Promise.all([req.text(), req2.text()]);
-      }).then(function(texts) {
-        assert_equals(texts[0], '', 'The body is consumed.');
-        assert_equals(texts[1], '', 'The body is consumed.');
-        return req.clone().text();
-      }).then(function(text) {
-        assert_equals(text, '', 'The body was consumed before cloned.');
       });
   }, 'Test clone behavior with loading content from Request.');
 
 async_test(function(t) {
     var request =
       new Request(URL,
                   {
                     method: 'POST',
                     body: new Blob(['Test Blob'], {type: 'test/type'})
                   });
@@ skipping 145 matching lines @@
   }, 'MIME type for Blob');
 
 promise_test(function(t) {
     var req = new Request('http://localhost/',
                           {method: 'POST',
                            body: new Blob([''], {type: 'Text/Plain'})});
     return req.blob()
       .then(function(blob) {
           assert_equals(blob.type, 'text/plain');
           assert_equals(req.headers.get('Content-Type'), 'text/plain');
-          return new Request(req).blob();
-        }).then(function(blob) {
-          assert_equals(blob.type, 'text/plain');
         });
   }, 'MIME type for Blob with non-empty type');
 
 promise_test(function(t) {
     var req = new Request('http://localhost/',
                           {method: 'POST', body: new FormData()});
     return req.blob()
       .then(function(blob) {
           assert_equals(blob.type.indexOf('multipart/form-data; boundary='),
                         0);
@@ skipping 47 matching lines @@
                           {method: 'POST',
                            body: new Blob([''], {type: 'Text/Plain'}),
                            headers: [['Content-Type', 'Text/Html']]});
     return req.blob()
       .then(function(blob) {
           assert_equals(blob.type, 'text/html');
           assert_equals(req.headers.get('Content-Type'), 'Text/Html');
         });
   }, 'Extract a MIME type (1)');
 
-promise_test(function(t) {
-    var req = new Request('http://localhost/', {method: 'POST', body: 'hello'});
-    return req.text().then(function(text) {
-        assert_equals(text, 'hello');
-        var req2 = new Request(req);
-        assert_true(req.bodyUsed);
-        assert_false(req2.bodyUsed);
-        return req2.text();
-      }).then(function(text) {
-        assert_equals(text, '');
-      });
-  }, 'Consume and pass');
-
 done();