Replace assert_promise_rejects with upstream promise_rejects.

third_party/WebKit/LayoutTests/http/tests/serviceworker/resources/registration-tests.js

 function registration_tests(register_method, check_error_types) {
   // The navigator.serviceWorker.register() method guarantees that the newly
   // installing worker is available as registration.installing when its promise
   // resolves. However these tests are also used to test installation using a
   // <link> element where it is possible for the installing worker to have
   // already become the waiting or active worker. So This method is used to get
   // the newest worker when these tests need access to the ServiceWorker itself.
   function get_newest_worker(registration) {
     if (registration.installing)
       return registration.installing;
@@ skipping 39 matching lines @@
             assert_equals(registration.constructor.name,
                           'ServiceWorkerRegistration',
                           'Successfully registered.');
             service_worker_unregister_and_done(t, scope);
           })
     }, 'Registering same scope as the script directory');
 
   promise_test(function(t) {
       var script = 'resources/registration-worker.js';
       var scope = 'resources';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'SecurityError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'SecurityError' : null,
           'Registering same scope as the script directory without the last ' +
               'slash should fail with SecurityError.');
     }, 'Registering same scope as the script directory without the last slash');
 
   promise_test(function(t) {
       var script = 'resources/registration-worker.js';
       var scope = 'different-directory/';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'SecurityError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'SecurityError' : null,
           'Registration scope outside the script directory should fail ' +
               'with SecurityError.');
     }, 'Registration scope outside the script directory');
 
   promise_test(function(t) {
       var script = 'resources/registration-worker.js';
       var scope = 'http://example.com/';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'SecurityError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'SecurityError' : null,
           'Registration scope outside domain should fail with SecurityError.');
     }, 'Registering scope outside domain');
 
   promise_test(function(t) {
       var script = 'http://example.com/worker.js';
       var scope = 'http://example.com/scope/';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'SecurityError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'SecurityError' : null,
           'Registration script outside domain should fail with SecurityError.');
     }, 'Registering script outside domain');
 
   promise_test(function(t) {
       var script = 'resources/no-such-worker.js';
       var scope = 'resources/scope/no-such-worker';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'NetworkError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'NetworkError' : null,
           navigator.serviceWorker.register(script, {scope: scope}),
           'Registration of non-existent script should fail.');
     }, 'Registering non-existent script');
 
   promise_test(function(t) {
       var script = 'resources/invalid-chunked-encoding.php';
       var scope = 'resources/scope/invalid-chunked-encoding/';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'NetworkError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'NetworkError' : null,
           'Registration of invalid chunked encoding script should fail.');
     }, 'Registering invalid chunked encoding script');
 
   promise_test(function(t) {
       var script = 'resources/invalid-chunked-encoding-with-flush.php';
       var scope = 'resources/scope/invalid-chunked-encoding-with-flush/';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'NetworkError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'NetworkError' : null,
           'Registration of invalid chunked encoding script should fail.');
     }, 'Registering invalid chunked encoding script with flush');
 
   promise_test(function(t) {
       var script = 'resources/mime-type-worker.php';
       var scope = 'resources/scope/no-mime-type-worker/';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'SecurityError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'SecurityError' : null,
           'Registration of no MIME type script should fail.');
     }, 'Registering script with no MIME type');
 
   promise_test(function(t) {
       var script = 'resources/mime-type-worker.php?mime=text/plain';
       var scope = 'resources/scope/bad-mime-type-worker/';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'SecurityError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'SecurityError' : null,
           'Registration of plain text script should fail.');
     }, 'Registering script with bad MIME type');
 
   promise_test(function(t) {
       var script = 'resources/redirect.php?Redirect=' +
                     encodeURIComponent('/resources/registration-worker.js');
       var scope = 'resources/scope/redirect/';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'SecurityError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'SecurityError' : null,
           'Registration of redirected script should fail.');
     }, 'Registering redirected script');
 
   promise_test(function(t) {
       var script = 'resources/malformed-worker.php?parse-error';
       var scope = 'resources/scope/parse-error';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'AbortError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'AbortError' : null,
           'Registration of script including parse error should fail.');
     }, 'Registering script including parse error');
 
   promise_test(function(t) {
       var script = 'resources/malformed-worker.php?undefined-error';
       var scope = 'resources/scope/undefined-error';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'AbortError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'AbortError' : null,
           'Registration of script including undefined error should fail.');
     }, 'Registering script including undefined error');
 
   promise_test(function(t) {
       var script = 'resources/malformed-worker.php?uncaught-exception';
       var scope = 'resources/scope/uncaught-exception';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'AbortError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'AbortError' : null,
           'Registration of script including uncaught exception should fail.');
     }, 'Registering script including uncaught exception');
 
   promise_test(function(t) {
       var script = 'resources/malformed-worker.php?caught-exception';
       var scope = 'resources/scope/caught-exception';
       return register_method(script, {scope: scope})
           .then(function(registration) {
               assert_equals(registration.constructor.name,
                             'ServiceWorkerRegistration',
                             'Successfully registered.');
               service_worker_unregister_and_done(t, scope);
             })
     }, 'Registering script including caught exception');
 
   promise_test(function(t) {
       var script = 'resources/malformed-worker.php?import-malformed-script';
       var scope = 'resources/scope/import-malformed-script';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'AbortError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'AbortError' : null,
           'Registration of script importing malformed script should fail.');
     }, 'Registering script importing malformed script');
 
   promise_test(function(t) {
       var script = 'resources/malformed-worker.php?import-no-such-script';
       var scope = 'resources/scope/import-no-such-script';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'AbortError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'AbortError' : null,
           'Registration of script importing non-existent script should fail.');
     }, 'Registering script importing non-existent script');
 
   promise_test(function(t) {
       // URL-encoded full-width 'scope'.
       var name = '%ef%bd%93%ef%bd%83%ef%bd%8f%ef%bd%90%ef%bd%85';
       var script = 'resources/empty-worker.js';
       var scope = 'resources/' + name + '/escaped-multibyte-character-scope';
       return register_method(script, {scope: scope})
         .then(function(registration) {
@@ skipping 16 matching lines @@
               registration.scope,
               normalizeURL(scope),
               'Non-URL-encoded multibyte characters should be available.');
             service_worker_unregister_and_done(t, scope);
           });
     }, 'Scope including non-escaped multibyte characters');
 
   promise_test(function(t) {
       var script = 'resources%2fempty-worker.js';
       var scope = 'resources/scope/encoded-slash-in-script-url';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? new TypeError : null,
           register_method(script, {scope: scope}),
-          check_error_types ? new TypeError : null,
           'URL-encoded slash in the script URL should be rejected.');
     }, 'Script URL including URL-encoded slash');
 
   promise_test(function(t) {
       var script = 'resources%2Fempty-worker.js';
       var scope = 'resources/scope/encoded-slash-in-script-url';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? new TypeError : null,
           register_method(script, {scope: scope}),
-          check_error_types ? new TypeError : null,
           'URL-encoded slash in the script URL should be rejected.');
     }, 'Script URL including uppercase URL-encoded slash');
 
   promise_test(function(t) {
       var script = 'resources/empty-worker.js';
       var scope = 'resources/scope%2fencoded-slash-in-scope';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? new TypeError : null,
           register_method(script, {scope: scope}),
-          check_error_types ? new TypeError : null,
           'URL-encoded slash in the scope should be rejected.');
     }, 'Scope including URL-encoded slash');
 
   promise_test(function(t) {
       var script = 'resources%5cempty-worker.js';
       var scope = 'resources/scope/encoded-slash-in-script-url';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? new TypeError : null,
           register_method(script, {scope: scope}),
-          check_error_types ? new TypeError : null,
           'URL-encoded backslash in the script URL should be rejected.');
     }, 'Script URL including URL-encoded backslash');
 
   promise_test(function(t) {
       var script = 'resources%5Cempty-worker.js';
       var scope = 'resources/scope/encoded-slash-in-script-url';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? new TypeError : null,
           register_method(script, {scope: scope}),
-          check_error_types ? new TypeError : null,
           'URL-encoded backslash in the script URL should be rejected.');
     }, 'Script URL including uppercase URL-encoded backslash');
 
   promise_test(function(t) {
       var script = 'resources/empty-worker.js';
       var scope = 'resources/scope%5cencoded-slash-in-scope';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? new TypeError : null,
           register_method(script, {scope: scope}),
-          check_error_types ? new TypeError : null,
           'URL-encoded backslash in the scope should be rejected.');
     }, 'Scope including URL-encoded backslash');
 
   promise_test(function(t) {
       var script = 'resources/././empty-worker.js';
       var scope = 'resources/scope/parent-reference-in-script-url';
       return register_method(script, {scope: scope})
         .then(function(registration) {
             assert_equals(
               get_newest_worker(registration).scriptURL,
@@ skipping 38 matching lines @@
               registration.scope,
               normalizeURL('resources/scope/parent-reference-in-scope'),
               'Scope including parent-reference should be normalized.');
             service_worker_unregister_and_done(t, scope);
           });
     }, 'Scope including parent-reference');
 
   promise_test(function(t) {
       var script = 'resources/empty-worker.js';
       var scope = 'resources/../scope/parent-reference-in-scope';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'SecurityError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'SecurityError' : null,
           'Scope not under the script directory should be rejected.');
     }, 'Scope including parent-reference and not under the script directory');
 
   promise_test(function(t) {
       var script = 'resources////empty-worker.js';
       var scope = 'resources/scope/consecutive-slashes-in-script-url';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'SecurityError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'SecurityError' : null,
           'Consecutive slashes in the script url should not be unified.');
     }, 'Script URL including consecutive slashes');
 
   promise_test(function(t) {
       var script = 'resources/empty-worker.js';
       var scope = 'resources/scope////consecutive-slashes-in-scope';
       return register_method(script, {scope: scope})
         .then(function(registration) {
             // Although consecutive slashes in the scope are not unified, the
             // scope is under the script directory and registration should
             // succeed.
             assert_equals(
               registration.scope,
               normalizeURL(scope),
               'Should successfully be registered.');
             service_worker_unregister_and_done(t, scope);
           })
     }, 'Scope including consecutive slashes');
 
   promise_test(function(t) {
       var script = 'filesystem:' + normalizeURL('resources/empty-worker.js');
       var scope = 'resources/scope/filesystem-script-url';
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'SecurityError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'SecurityError' : null,
           'Registering a script which has same-origin filesystem: URL should ' +
               'fail with SecurityError.');
     }, 'Script URL is same-origin filesystem: URL');
 
   promise_test(function(t) {
       var script = 'resources/empty-worker.js';
       var scope = 'filesystem:' + normalizeURL('resources/scope/filesystem-scope-url');
-      return assert_promise_rejects(
+      return promise_rejects(t,
+          check_error_types ? 'SecurityError' : null,
           register_method(script, {scope: scope}),
-          check_error_types ? 'SecurityError' : null,
           'Registering with the scope that has same-origin filesystem: URL ' +
               'should fail with SecurityError.');
     }, 'Scope URL is same-origin filesystem: URL');
 }