Service Worker: Cache.put() consumes request/response bodies

LayoutTests/http/tests/serviceworker/resources/cache-put-worker.js

 importScripts('worker-testharness.js');
 importScripts('/resources/testharness-helpers.js');
 
 var test_url = 'https://example.com/foo';
-var test_response_body = 'Hello world!';
+var test_body = 'Hello world!';
 
 cache_test(function(cache) {
     var request = new Request(test_url);
-    var response = new Response(test_response_body);
+    var response = new Response(test_body);
     return cache.put(request, response)
       .then(function(result) {
           assert_equals(result, undefined,
                         'Cache.put should resolve with undefined on success.');
         });
   }, 'Cache.put called with simple Request and Response');
 
 cache_test(function(cache) {
     var test_url = new URL('simple.txt', location.href).href;
     var request = new Request(test_url);
@@ skipping 12 matching lines @@
                                'new request and response.');
           return result.text();
         })
       .then(function(body) {
           assert_equals(body, 'a simple text file\n',
                         'Cache.put should store response body.');
         });
   }, 'Cache.put called with Request and Response from fetch()');
 
 cache_test(function(cache) {
+    var request = new Request(test_url);
+    var response = new Response(test_body);
+    assert_false(request.bodyUsed,
+                 '[https://fetch.spec.whatwg.org/#dom-body-bodyused] ' +
+                 'Request.bodyUsed should be initially false.');
+    return cache.put(request, response)
+      .then(function() {
+        assert_false(request.bodyUsed,
+                     'Cache.put should not mark empty request\'s body used');
+      });
+  }, 'Cache.put with Request without a body');
+
+cache_test(function(cache) {
+    var request = new Request(test_url);
+    var response = new Response();
+    assert_false(response.bodyUsed,
+                 '[https://fetch.spec.whatwg.org/#dom-body-bodyused] ' +
+                 'Response.bodyUsed should be initially false.');
+    return cache.put(request, response)
+      .then(function() {
+        assert_false(response.bodyUsed,
+                     'Cache.put should not mark empty response\'s body used');
+      });
+  }, 'Cache.put with Response without a body');
+
+cache_test(function(cache) {
     var request = new Request(test_url, {
         method: 'GET',
         body: 'Hello'
       });
-    var response = new Response(test_response_body);
+    var response = new Response(test_body);
     assert_false(request.bodyUsed,
                  '[https://fetch.spec.whatwg.org/#dom-body-bodyused] ' +
                  'Request.bodyUsed should be initially false.');
-    return cache.put(request, response)
+    return cache.put(request, response.clone())
       .then(function() {
-          assert_false(request.bodyUsed,
-                       'Cache.put should not consume Request body.');
+          assert_true(request.bodyUsed,
+                       'Cache.put should consume Request body.');
         })
       .then(function() {
           return cache.match(request);
         })
       .then(function(result) {
           assert_object_equals(result, response,
                                'Cache.put should store response body.');
         });
   }, 'Cache.put with Request containing a body');
 
 cache_test(function(cache) {
     var request = new Request(test_url);
-    var response = new Response(test_response_body);
-    return cache.put(request, response)
+    var response = new Response(test_body);
+    return cache.put(request, response.clone())
       .then(function() {
           return cache.match(test_url);
         })
       .then(function(result) {
           assert_object_equals(result, response,
                                'Cache.put should update the cache with ' +
                                'new Request and Response.');
         });
   }, 'Cache.put with a Response containing an empty URL');
 
@@ skipping 45 matching lines @@
         });
   }, 'Cache.put with HTTP 500 response');
 
 cache_test(function(cache) {
     var alternate_response_body = 'New body';
     var alternate_response = new Response(alternate_response_body,
                                           { statusText: 'New status' });
     return cache.put(new Request(test_url),
                      new Response('Old body', { statusText: 'Old status' }))
       .then(function() {
-          return cache.put(new Request(test_url), alternate_response);
+          return cache.put(new Request(test_url), alternate_response.clone());
         })
       .then(function() {
           return cache.match(test_url);
         })
       .then(function(result) {
           assert_object_equals(result, alternate_response,
                                'Cache.put should replace existing ' +
                                'response with new response.');
           return result.text();
         })
       .then(function(body) {
           assert_equals(body, alternate_response_body,
                         'Cache put should store new response body.');
         });
   }, 'Cache.put called twice with matching Requests and different Responses');
 
 cache_test(function(cache) {
     var first_url = test_url;
     var second_url = first_url + '#(O_o)';
     var alternate_response_body = 'New body';
     var alternate_response = new Response(alternate_response_body,
                                           { statusText: 'New status' });
     return cache.put(new Request(first_url),
                      new Response('Old body', { statusText: 'Old status' }))
       .then(function() {
-          return cache.put(new Request(second_url), alternate_response);
+          return cache.put(new Request(second_url), alternate_response.clone());
         })
       .then(function() {
           return cache.match(test_url);
         })
       .then(function(result) {
           assert_object_equals(result, alternate_response,
                                'Cache.put should replace existing ' +
                                'response with new response.');
           return result.text();
         })
@@ skipping 53 matching lines @@
 cache_test(function(cache) {
     return assert_promise_rejects(
       cache.put(new Request(test_url), 'Hello world!'),
       new TypeError(),
       'Cache.put should only accept a Response object as the response.');
   }, 'Cache.put with an invalid response');
 
 cache_test(function(cache) {
     return assert_promise_rejects(
       cache.put(new Request('file:///etc/passwd'),
-                new Response(test_response_body)),
+                new Response(test_body)),
       new TypeError(),
       'Cache.put should reject non-HTTP/HTTPS requests with a TypeError.');
   }, 'Cache.put with a non-HTTP/HTTPS request');
 
 cache_test(function(cache) {
-    var response = new Response(test_response_body);
-    return cache.put(new Request('relative-url'), response)
+    var response = new Response(test_body);
+    return cache.put(new Request('relative-url'), response.clone())
       .then(function() {
           return cache.match(new URL('relative-url', location.href).href);
         })
       .then(function(result) {
           assert_object_equals(result, response,
                                'Cache.put should accept a relative URL ' +
                                'as the request.');
         });
   }, 'Cache.put with a relative URL');
 
 cache_test(function(cache) {
     var request = new Request('http://example.com/foo', { method: 'HEAD' });
     return assert_promise_rejects(
-      cache.put(request, new Response(test_response_body)),
+      cache.put(request, new Response(test_body)),
       new TypeError(),
       'Cache.put should throw a TypeError for non-GET requests.');
   }, 'Cache.put with a non-GET request');
 
 cache_test(function(cache) {
     return assert_promise_rejects(
       cache.put(new Request(test_url), null),
       new TypeError(),
-      'Cache.put should throw a TypeError for an empty response.');
-  }, 'Cache.put with an empty response');
+      'Cache.put should throw a TypeError for a null response.');
+  }, 'Cache.put with a null response');
+
+cache_test(function(cache) {
+    var request = new Request(test_url, {body: test_body});
+    assert_false(request.bodyUsed,
+                 '[https://fetch.spec.whatwg.org/#dom-body-bodyused] ' +
+                 'Request.bodyUsed should be initially false.');
+    var copy = new Request(request);
+    assert_true(request.bodyUsed,
+                '[https://fetch.spec.whatwg.org/#dom-request] ' +
+                'Request constructor should set input\'s used flag.');
+    return assert_promise_rejects(
+      cache.put(request, new Response(test_body)),
+      new TypeError(),
+      'Cache.put should throw a TypeError for a request with used body.');
+  }, 'Cache.put with a used request body');
+
+cache_test(function(cache) {
+    var response = new Response(test_body);
+    assert_false(response.bodyUsed,
+                 '[https://fetch.spec.whatwg.org/#dom-body-bodyused] ' +
+                 'Response.bodyUsed should be initially false.');
+    response.text().then(function() {
+      assert_true(
+        response.bodyUsed,
+        '[https://fetch.spec.whatwg.org/#concept-body-consume-body] ' +
+          'The text() method should consume the body of the response.');
+      return assert_promise_rejects(
+        cache.put(new Request(test_url), response),
+        new TypeError(),
+        'Cache.put should throw a TypeError for a response with used body.');
+    });
+  }, 'Cache.put with a used response body');