Replace assert_promise_rejects with upstream promise_rejects.

third_party/WebKit/LayoutTests/http/tests/cachestorage/script-tests/cache-put.js

 if (self.importScripts) {
     importScripts('/resources/testharness.js');
     importScripts('/resources/testharness-helpers.js');
     importScripts('../resources/test-helpers.js');
 }
 
 var test_url = 'https://example.com/foo';
 var test_body = 'Hello world!';
 
 cache_test(function(cache) {
@@ skipping 172 matching lines @@
     var url = 'http://example.com/foo';
     return cache.put(url, new Response('some body'))
       .then(function() { return cache.match(url); })
       .then(function(response) { return response.text(); })
       .then(function(body) {
           assert_equals(body, 'some body',
                         'Cache.put should accept a string as request.');
         });
   }, 'Cache.put with a string request');
 
-cache_test(function(cache) {
-    return assert_promise_rejects(
+cache_test(function(cache, test) {
+    return promise_rejects(
+      test,
+      new TypeError(),
       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_test(function(cache, test) {
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.put(new Request('file:///etc/passwd'),
                 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_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_response_equals(result, response,
                                  'Cache.put should accept a relative URL ' +
                                  'as the request.');
         });
   }, 'Cache.put with a relative URL');
 
-cache_test(function(cache) {
+cache_test(function(cache, test) {
     var request = new Request('http://example.com/foo', { method: 'HEAD' });
-    return assert_promise_rejects(
+    return promise_rejects(
+      test,
+      new TypeError(),
       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_test(function(cache, test) {
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.put(new Request(test_url), null),
-      new TypeError(),
       'Cache.put should throw a TypeError for a null response.');
   }, 'Cache.put with a null response');
 
-cache_test(function(cache) {
+cache_test(function(cache, test) {
     var request = new Request(test_url, {method: 'POST', body: test_body});
-    return assert_promise_rejects(
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.put(request, new Response(test_body)),
-      new TypeError(),
       'Cache.put should throw a TypeError for a POST request.');
   }, 'Cache.put with a POST request');
 
 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.');
     return response.text().then(function() {
       assert_true(
         response.bodyUsed,
         '[https://fetch.spec.whatwg.org/#concept-body-consume-body] ' +
           'The text() method should make the body disturbed.');
       var request = new Request(test_url);
       return cache.put(request, response).then(() => {
           assert_unreached('cache.put should be rejected');
         }, () => {});
     });
   }, 'Cache.put with a used response body');
 
 cache_test(function(cache) {
     var response = new Response(test_body);
     return cache.put(new Request(test_url), response)
       .then(function() {
           assert_throws(new TypeError(), () => response.body.getReader());
       });
   }, 'getReader() after Cache.put');
 
-cache_test(function(cache) {
-    return assert_promise_rejects(
+cache_test(function(cache, test) {
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.put(new Request(test_url),
                 new Response(test_body, { headers: { VARY: '*' }})),
-      new TypeError(),
       'Cache.put should reject VARY:* Responses with a TypeError.');
   }, 'Cache.put with a VARY:* Response');
 
-cache_test(function(cache) {
-    return assert_promise_rejects(
+cache_test(function(cache, test) {
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.put(new Request(test_url),
                 new Response(test_body,
                              { headers: { VARY: 'Accept-Language,*' }})),
-      new TypeError(),
       'Cache.put should reject Responses with an embedded VARY:* with a ' +
       'TypeError.');
   }, 'Cache.put with an embedded VARY:* Response');
 
 done();