[WIP] Expose Request.body 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 19 matching lines @@
     request.url = 'http://localhost/';
     assert_equals(request.url, 'https://www.example.com/test.html',
                   'Request.url should be readonly');
 
     // Unmatched lead surrogate.
     request = new Request('http://localhost/\uD800');
     assert_equals(request.url,
                   'http://localhost/' + encodeURIComponent('\uFFFD'),
                   'Request.url should have unmatched surrogates replaced.');
 
+    assert_equals(request.body, null, 'null body');
     request.method = 'POST';
     assert_equals(request.method, 'GET', 'Request.method should be readonly');
   }, 'Request basic test');
 
 test(function() {
     [new Request(URL),
      // All mode/credentials below are invalid and thus ignored.
      new Request(URL, {mode: null}),
      new Request(URL, {mode: undefined}),
      new Request(URL, {mode: 'sameorigin'}),
@@ skipping 298 matching lines @@
                  'consumed.');
     var req2 = new Request(req);
     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() {
+promise_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.');
+    const originalBody = req.body;
+    assert_not_equals(req.body, null, 'Request body');
     var req2 = new Request(req);
     assert_true(req.bodyUsed,
                 'Request should be flagged as used if it has been consumed.');
     assert_false(req2.bodyUsed,
                  'Request should not be flagged as used if it has not been ' +
                  'consumed.');
+    assert_equals(req.body, originalBody,
+                  'The body property must not change.');
+    assert_not_equals(req.body, req2.body,
+                      'A new Request has a new body property');
     // See https://crbug.com/501195.
     assert_throws(
       {name: 'TypeError'},
       function() { new Request(req); },
       'Request construction should throw if used.');
-  }, 'Request construction without body behavior regardning "bodyUsed"');
+  }, 'Request construction regarding "body" and "bodyUsed"');
 
 test(function() {
     var req = new Request(URL, {method: 'POST', body: 'hello'});
+    const originalBody = req.body;
+    assert_not_equals(req.body, null, 'Request body');
     assert_false(req.bodyUsed,
                  'Request should not be flagged as used if it has not been ' +
                  'consumed.');
     assert_throws(
       {name: 'TypeError'},
       function() { new Request(req, {method: 'GET'}); },
       'A get request may not have body.');
 
     assert_false(req.bodyUsed, 'After the GET case');
+    assert_equals(req.body, originalBody,
+                  'After the GET case: The body property must not change.');
 
     assert_throws(
       {name: 'TypeError'},
       function() { new Request(req, {method: 'CONNECT'}); },
       'Request() with a forbidden method must throw.');
 
     assert_false(req.bodyUsed, 'After the forbidden method case');
+    assert_equals(req.body, originalBody,
+                  'After the forbidden method case: ' +
+                  'The body property must not change.');
 
     var req2 = new Request(req);
     assert_true(req.bodyUsed,
                 'Request should be flagged as used if it has been consumed.');
   }, 'Request construction failure should not set "bodyUsed"');
 
 test(function() {
     assert_equals(new Request(URL).referrer, 'about:client');
     assert_equals(new Request(URL).referrerPolicy, '');
   }, 'Request without RequestInit.');
@@ skipping 331 matching lines @@
 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');
         });
   }, '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);
           assert_equals(req.headers.get('Content-Type')
                           .indexOf('multipart/form-data; boundary='),
                         0);
@@ skipping 56 matching lines @@
                           {method: 'POST',
                            credentials: 'include',
                            body: 'this is a body'});
 
     return req.text()
         .then(t => {
            assert_equals(t, 'this is a body');
         });
   }, 'Credentials and body can both be set.');
 
+promise_test(() => {
+    var controller;
+    var stream = new ReadableStream({start: c => controller = c});
+    controller.enqueue(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f]));
+    controller.enqueue(new Uint8Array([0x77, 0x6f, 0x72, 0x6c, 0x64]));
+    controller.close();
+    assert_false(stream.locked);
+    var request = new Request(URL, {method: 'POST', body: stream});
+    assert_equals(request.body, stream, 'body property');
+    var p = request.text().then(t => {
+        assert_equals(t, 'helloworld');
+      });
+    assert_true(stream.locked);
+    return p;
+  }, 'Request constructed with a stream');
+
+promise_test(() => {
+    const request = new Request(URL, {method: 'POST', body: 'hello'});
+    return readableStreamToArray(request.body).then(chunks => {
+        const decoder = new TextDecoder('utf-8');
+        let r = '';
+        for (const chunk of chunks) {
+          r += decoder.decode(chunk, {stream: true});
+        }
+        r += decoder.decode();
+        assert_equals(r, 'hello');
+      });
+  }, 'Request constructed with a String / Read from body stream');
+
+promise_test(() => {
+    var controller;
+    var stream = new ReadableStream({start: c => controller = c});
+    controller.enqueue(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f]));
+    controller.enqueue(new Uint8Array([0x77, 0x6f, 0x72, 0x6c, 0x64]));
+    controller.close();
+
+    var request = new Request(URL, {method: 'POST', body: stream});
+    return readableStreamToArray(request.body).then(chunks => {
+        var decoder = new TextDecoder('utf-8');
+        var r = '';
+        for (var chunk of chunks) {
+          r += decoder.decode(chunk, {stream: true});
+        }
+        r += decoder.decode();
+        assert_equals(r, 'helloworld');
+      });
+  }, 'Request constructed with a stream / Read from body stream');
+
+promise_test(t => {
+    var controller;
+    var stream = new ReadableStream({start: c => controller = c});
+    setTimeout(() => {
+        controller.enqueue(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f]));
+        controller.enqueue(new Uint8Array([0x77, 0x6f, 0x72, 0x6c, 0x64]));
+        controller.error();
+    }, 1);
+    var request = new Request(URL, {method: 'POST', body: stream});
+    return promise_rejects(t, TypeError(), request.text());
+  }, 'Response constructed with an errored stream');
+
+promise_test(t => {
+    var controller;
+    var stream = new ReadableStream({start: c => controller = c});
+    stream.getReader();
+    var request = new Request(URL, {method: 'POST', body: stream});
+    return promise_rejects(t, TypeError(), request.text());
+  }, 'Request constructed with a locked stream');
+
+promise_test(t => {
+    var controller;
+    var stream = new ReadableStream({start: c => controller = c});
+    setTimeout(() => controller.enqueue(), 1);
+    var request = new Request(URL, {method: 'POST', body: stream});
+    return promise_rejects(t, TypeError(), request.text());
+  }, 'Request constructed stream with an undefined chunk');
+
+promise_test(t => {
+    var controller;
+    var stream = new ReadableStream({start: c => controller = c});
+    setTimeout(() => controller.enqueue(null), 1);
+    var request = new Request(URL, {method: 'POST', body: stream});
+    return promise_rejects(t, TypeError(), request.text());
+  }, 'Request constructed stream with a null chunk');
+
+promise_test(t => {
+    var controller;
+    var stream = new ReadableStream({start: c => controller = c});
+    setTimeout(() => controller.enqueue('hello'), 1);
+    var request = new Request(URL, {method: 'POST', body: stream});
+    return promise_rejects(t, TypeError(), request.text());
+  }, 'Request constructed stream with a string chunk');
+
+
 done();