Replace assert_promise_rejects with upstream promise_rejects.

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

 if (self.importScripts) {
     importScripts('/resources/testharness.js');
     importScripts('/resources/testharness-helpers.js');
     importScripts('../resources/test-helpers.js');
 }
 
-cache_test(function(cache) {
-    return assert_promise_rejects(
+cache_test(function(cache, test) {
+    return promise_rejects(

[jsbell, 2016/04/29 17:39:07]

I don't suppose you want to make the same changes to the copies of these in
web-platform-tests?

https://github.com/w3c/web-platform-tests/blob/master/service-workers/cache-s...

(etc)

+      test,
+      new TypeError(),
       cache.add(),
-      new TypeError(),
       'Cache.add should throw a TypeError when no arguments are given.');
   }, 'Cache.add called with no arguments');
 
 cache_test(function(cache) {
     return cache.add('../resources/simple.txt')
       .then(function(result) {
           assert_equals(result, undefined,
                         'Cache.add should resolve with undefined on success.');
           return cache.match('../resources/simple.txt');
         })
         .then(function(response) {
           assert_class_string(response, 'Response',
                               'Cache.add should put a resource in the cache.');
           return response.text();
         })
         .then(function(body) {
           assert_equals(body, 'a simple text file\n',
                         'Cache.add should retrieve the correct body.');
         });
   }, 'Cache.add called with relative URL specified as a string');
 
-cache_test(function(cache) {
-    return assert_promise_rejects(
+cache_test(function(cache, test) {
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.add('javascript://this-is-not-http-mmkay'),
-      new TypeError(),
       'Cache.add should throw a TypeError for non-HTTP/HTTPS URLs.');
   }, 'Cache.add called with non-HTTP/HTTPS URL');
 
 cache_test(function(cache) {
     var request = new Request('../resources/simple.txt');
     return cache.add(request)
       .then(function(result) {
           assert_equals(result, undefined,
                         'Cache.add should resolve with undefined on success.');
         });
   }, 'Cache.add called with Request object');
 
-cache_test(function(cache) {
+cache_test(function(cache, test) {
     var request = new Request('../resources/simple.txt',
                               {method: 'POST', body: 'This is a body.'});
-    return assert_promise_rejects(
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.add(request),
-      new TypeError(),
       'Cache.add should throw a TypeError for non-GET requests.');
   }, 'Cache.add called with POST request');
 
 cache_test(function(cache) {
     var request = new Request('../resources/simple.txt');
     return cache.add(request)
       .then(function(result) {
           assert_equals(result, undefined,
                         'Cache.add should resolve with undefined on success.');
         })
@@ skipping 10 matching lines @@
     var request = new Request('../resources/simple.txt');
     return request.text()
       .then(function() {
           assert_false(request.bodyUsed);
         })
       .then(function() {
           return cache.add(request);
         });
   }, 'Cache.add called with Request object with a used body');
 
-cache_test(function(cache) {
-    return assert_promise_rejects(
+cache_test(function(cache, test) {
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.add('this-does-not-exist-please-dont-create-it'),
-      new TypeError(),
       'Cache.add should reject if response is !ok');
   }, 'Cache.add with request that results in a status of 404');
 
-cache_test(function(cache) {
-    return assert_promise_rejects(
+cache_test(function(cache, test) {
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.add('../resources/fetch-status.php?status=500'),
-      new TypeError(),
       'Cache.add should reject if response is !ok');
   }, 'Cache.add with request that results in a status of 500');
 
-cache_test(function(cache) {
-    return assert_promise_rejects(
+cache_test(function(cache, test) {
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.addAll(),
-      new TypeError(),
       'Cache.addAll with no arguments should throw TypeError.');
   }, 'Cache.addAll with no arguments');
 
-cache_test(function(cache) {
+cache_test(function(cache, test) {
     // Assumes the existence of ../resources/simple.txt and ../resources/blank.html
     var urls = ['../resources/simple.txt', undefined, '../resources/blank.html'];
-    return assert_promise_rejects(
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.addAll(),
-      new TypeError(),
       'Cache.addAll should throw TypeError for an undefined argument.');
   }, 'Cache.addAll with a mix of valid and undefined arguments');
 
 cache_test(function(cache) {
     return cache.addAll([])
       .then(function(result) {
           assert_equals(result, undefined,
                         'Cache.addAll should resolve with undefined on ' +
                         'success.');
           return cache.keys();
@@ skipping 74 matching lines @@
       .then(function(bodies) {
           assert_equals(
             bodies[0], 'a simple text file\n',
             'Cache.add should retrieve the correct body.');
           assert_equals(
             bodies[2], '<!DOCTYPE html>\n<title>Empty doc</title>\n',
             'Cache.add should retrieve the correct body.');
         });
   }, 'Cache.addAll with Request arguments');
 
-cache_test(function(cache) {
+cache_test(function(cache, test) {
     // Assumes that ../resources/simple.txt and ../resources/blank.html exist.
     // The second resource does not.
     var urls = ['../resources/simple.txt',
                 'this-resource-should-not-exist',
                 '../resources/blank.html'];
     var requests = urls.map(function(url) {
         return new Request(url);
       });
-    return assert_promise_rejects(
+    return promise_rejects(
+      test,
+      new TypeError(),
       cache.addAll(requests),
-      new TypeError(),
       'Cache.addAll should reject with TypeError if any request fails')
       .then(function() {
           return Promise.all(urls.map(function(url) {
               return cache.match(url);
             }));
         })
       .then(function(matches) {
           assert_array_equals(
             matches,
             [undefined, undefined, undefined],
             'If any response fails, no response should be added to cache');
         });
   }, 'Cache.addAll with a mix of succeeding and failing requests');
 
-cache_test(function(cache) {
+cache_test(function(cache, test) {
     var request = new Request('../resources/simple.txt');
-    return assert_promise_rejects(
+    return promise_rejects(
+      test,
+      'InvalidStateError',
       cache.addAll([request, request]),
-      'InvalidStateError',
       'Cache.addAll should throw InvalidStateError if the same request is added ' +
       'twice.');
   }, 'Cache.addAll called with the same Request object specified twice');
 
 done();