Replace some "assert_throws({'name': 'jserror'}, stuff)" with assert_throws_js

This diff was generated by running:

  find . -type f -print0 | xargs -0 perl -pi -e "BEGIN { \$/ = undef; } s/assert_throws\(([ \n]*)\{ *[\"']?name[\"']? *: *['\"](TypeError|Error)[\"'] *\} *(, *.)/assert_throws_js(\1\2\3/gs"

And then manually fixing up whitespace.

Bug: 1051932
Change-Id: I36cd1e17f36e92fe4a28461189f058f0fb11885e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2080432
Auto-Submit: Stephen McGruer <smcgruer@chromium.org>
Reviewed-by: Luke Z <lpz@chromium.org>
Commit-Queue: Stephen McGruer <smcgruer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#746022}

third_party/blink/web_tests/animations/stability/unstringable-keyframe-value-crash.html

@@ -3,7 +3,7 @@
 <script src="../../resources/testharnessreport.js"></script>
 <script>
 test(() => {
-  assert_throws({name: 'TypeError'}, () => {
+  assert_throws_js(TypeError, () => {
     document.body.animate({left: [{toString:null}]});
   });
 }, 'Do not crash when passing an unstringable value in a property indexed keyframe');

third_party/blink/web_tests/animations/web-animations/element-animate-iterable-keyframes.html

@@ -121,7 +121,7 @@ test(() => {
 }, 'Custom iterator with offset specified.');
 
 test(() => {
-  assert_throws({name: 'TypeError'}, () => {
+  assert_throws_js(TypeError, () => {
     assertAnimationEffect({
       keyframes: createIterable([
         {done: false, value: {left: '100px'}},
@@ -135,7 +135,7 @@ test(() => {
 }, 'Custom iterator with non object keyframe should throw.');
 
 test(() => {
-  assert_throws({name: 'TypeError'}, () => {
+  assert_throws_js(TypeError, () => {
     assertAnimationEffect({
       keyframes: {
         left: createIterable([

third_party/blink/web_tests/fast/dom/HTMLElement/class-list-feature-detection-throwing.html

@@ -5,8 +5,8 @@
     test(function() {
         var div = document.createElement("div");
         // Test that "supports()" is throwing TypeError
-        assert_throws(
-            {name: 'TypeError'}, function() { div.classList.supports("bogus"); },
+        assert_throws_js(
+            TypeError, function() { div.classList.supports("bogus"); },
             'supports method should throw if called on an DOMTokenList with no supported tokens, such as classList');
     }, "Make sure that classList throws when supports() is called");
 </script>

third_party/blink/web_tests/fast/dom/domstringlist.html

@@ -47,8 +47,8 @@ promise_test(function(t) {
             assert_equals(dsl.item(1), 'b', 'item method');
             assert_equals(dsl.item(2), 'c', 'item method');
             assert_equals(dsl.item(3), null, 'item method out of range');
-            assert_throws(
-                {name: 'TypeError'}, function() { dsl.item(); },
+            assert_throws_js(
+                TypeError, function() { dsl.item(); },
                 'item method should throw if called without enough args');
 
             assert_equals(dsl[0], 'a', 'indexed getter');
@@ -66,8 +66,8 @@ promise_test(function(t) {
                          'contains method unmatched');
             assert_false(dsl.contains('d'),
                          'contains method unmatched');
-            assert_throws(
-                {name: 'TypeError'}, function(){ dsl.contains(); },
+            assert_throws_js(
+                TypeError, function(){ dsl.contains(); },
                 'contains method should throw if called without enough args');
         });
 }, 'DOMStringList interface');

third_party/blink/web_tests/fast/events/constructors/input-event-constructor.html

@@ -5,9 +5,9 @@
 <div id="log"></div>
 <script>
 test(function() {
-    assert_throws({name: 'TypeError'},
-                  function() { new InputEvent(); },
-                  "Construct InputEvent with no argument.");
+    assert_throws_js(TypeError,
+                     function() { new InputEvent(); },
+                     "Construct InputEvent with no argument.");
 }, "Checks for InputEvent constructor with not enough argument");
 
 test(function() {

third_party/blink/web_tests/fast/media/mq-append-delete.html

@@ -86,9 +86,9 @@ test(function () {
 
 test(function () {
     mediaList.mediaText = "screen, tv";
-    assert_throws({ name: "TypeError" },
-                  function () { document.appendMedium(); },
-                  "Not enough arguments");
+    assert_throws_js(TypeError,
+                     function () { document.appendMedium(); },
+                     "Not enough arguments");
 }, "Add without argument");
 
 // - deleteMedium()
@@ -165,8 +165,8 @@ test(function () {
 
 test(function () {
     mediaList.mediaText = "tv, print, screen";
-    assert_throws({ name: "TypeError" },
-                  function () { document.deleteMedium(); },
-                  "Not enough arguments");
+    assert_throws_js(TypeError,
+                     function () { document.deleteMedium(); },
+                     "Not enough arguments");
 }, "Remove without argument");
 </script>

third_party/blink/web_tests/fast/peerconnection/RTCIceCandidate.html

@@ -28,10 +28,10 @@ test(function() {
 }, 'Constructor can be initialized with output from another constructor');
 
 test(function() {
-    assert_throws({name: 'TypeError'}, () => new RTCIceCandidate({}));
-    assert_throws({name: 'TypeError'}, () => new RTCIceCandidate(5));
-    assert_throws({name: 'TypeError'}, () => new RTCIceCandidate('foobar'));
-    assert_throws({name: 'TypeError'}, () => new RTCIceCandidate({candidate: ''}));
+    assert_throws_js(TypeError, () => new RTCIceCandidate({}));
+    assert_throws_js(TypeError, () => new RTCIceCandidate(5));
+    assert_throws_js(TypeError, () => new RTCIceCandidate('foobar'));
+    assert_throws_js(TypeError, () => new RTCIceCandidate({candidate: ''}));
 }, 'Constructor throws on invalid input');
 
 test(function() {

third_party/blink/web_tests/fast/speech/scripted/speechgrammar-basics.html

@@ -24,8 +24,8 @@ test(() => {
   var g = new webkitSpeechGrammar();
   g.weight = 2;
   assert_equals(g.weight, 2.0);
-  assert_throws({name: "TypeError"}, () => g.weight = NaN);
-  assert_throws({name: "TypeError"}, () => g.weight = Infinity);
+  assert_throws_js(TypeError, () => g.weight = NaN);
+  assert_throws_js(TypeError, () => g.weight = Infinity);
   assert_equals(g.weight, 2.0);
   g.src = "grammar.xml";
   assert_equals(g.src, base + "grammar.xml");
@@ -70,14 +70,14 @@ test(() => {
                 "data:application/xml,%3Cgrammar%3Efoo%3C/grammar%3E");
   assert_equals(gs[2].weight, 4);
 
-  assert_throws({name: "TypeError"},
-                () => gs.addFromUri("http://foo.tld/grammar.xml", NaN));
-  assert_throws({name: "TypeError"},
-                () => gs.addFromUri("http://foo.tld/grammar.xml", Infinity));
-  assert_throws({name: "TypeError"},
-                () => gs.addFromString("foo", NaN));
-  assert_throws({name: "TypeError"},
-                () => gs.addFromString("foo", Infinity));
+  assert_throws_js(TypeError,
+                   () => gs.addFromUri("http://foo.tld/grammar.xml", NaN));
+  assert_throws_js(TypeError,
+                   () => gs.addFromUri("http://foo.tld/grammar.xml", Infinity));
+  assert_throws_js(TypeError,
+                   () => gs.addFromString("foo", NaN));
+  assert_throws_js(TypeError,
+                   () => gs.addFromString("foo", Infinity));
 }, "Creating a grammar list");
 
 </script>

third_party/blink/web_tests/http/tests/fetch/script-tests/headers-guard.js

@@ -5,38 +5,38 @@ if (self.importScripts) {
 // Tests that invalid names/values throw TypeError.
 function testInvalidNamesAndValues(headers) {
   INVALID_HEADER_NAMES.forEach(function(name) {
-      assert_throws({name: 'TypeError'},
-                    function() { headers.append(name, 'a'); },
-                    'Headers.append with an invalid name (' + name +
-                    ') must throw');
-      assert_throws({name: 'TypeError'},
-                    function() { headers.delete(name); },
-                    'Headers.delete with an invalid name (' + name +
-                    ') must throw');
-      assert_throws({name: 'TypeError'},
-                    function() { headers.get(name); },
-                    'Headers.get with an invalid name (' + name +
-                    ') must throw');
-      assert_throws({name: 'TypeError'},
-                    function() { headers.getAll(name); },
-                    'Headers.getAll with an invalid name (' + name +
-                    ') must throw');
-      assert_throws({name: 'TypeError'},
-                    function() { headers.has(name); },
-                    'Headers.has with an invalid name (' + name +
-                    ') must throw');
-      assert_throws({name: 'TypeError'},
-                    function() { headers.set(name, 'a'); },
-                    'Headers.set with an invalid name (' + name +
-                    ') must throw');
+      assert_throws_js(TypeError,
+                       function() { headers.append(name, 'a'); },
+                       'Headers.append with an invalid name (' + name +
+                       ') must throw');
+      assert_throws_js(TypeError,
+                       function() { headers.delete(name); },
+                       'Headers.delete with an invalid name (' + name +
+                       ') must throw');
+      assert_throws_js(TypeError,
+                       function() { headers.get(name); },
+                       'Headers.get with an invalid name (' + name +
+                       ') must throw');
+      assert_throws_js(TypeError,
+                       function() { headers.getAll(name); },
+                       'Headers.getAll with an invalid name (' + name +
+                       ') must throw');
+      assert_throws_js(TypeError,
+                       function() { headers.has(name); },
+                       'Headers.has with an invalid name (' + name +
+                       ') must throw');
+      assert_throws_js(TypeError,
+                       function() { headers.set(name, 'a'); },
+                       'Headers.set with an invalid name (' + name +
+                       ') must throw');
     });
   INVALID_HEADER_VALUES.forEach(function(value) {
-      assert_throws({name: 'TypeError'},
-                    function() { headers.append('a', value); },
-                    'Headers.append with an invalid value must throw');
-      assert_throws({name: 'TypeError'},
-                    function() { headers.set('a', value); },
-                    'Headers.set with an invalid value must throw');
+      assert_throws_js(TypeError,
+                       function() { headers.append('a', value); },
+                       'Headers.append with an invalid value must throw');
+      assert_throws_js(TypeError,
+                       function() { headers.set('a', value); },
+                       'Headers.set with an invalid value must throw');
     });
 }
 
@@ -383,21 +383,21 @@ promise_test(function(t) {
               .forEach(function(header) {
                   var value = headers.get(header);
 
-                  assert_throws({name: 'TypeError'},
-                                function() { headers.append(header, 'test'); },
-                                'Headers.append(' + header + ') must throw');
+                  assert_throws_js(TypeError,
+                                   function() { headers.append(header, 'test'); },
+                                   'Headers.append(' + header + ') must throw');
                   assert_equals(headers.get(header), value,
                     'header ' + header + ' must be unchanged by append()');
 
-                  assert_throws({name: 'TypeError'},
-                                function() { headers.set(header, 'test'); },
-                                    'Headers.set(' + header + ') must throw');
+                  assert_throws_js(TypeError,
+                                   function() { headers.set(header, 'test'); },
+                                   'Headers.set(' + header + ') must throw');
                   assert_equals(headers.get(header), value,
                     'header ' + header + ' must be unchanged by set()');
 
-                  assert_throws({name: 'TypeError'},
-                                function() { headers.delete(header); },
-                                'Headers.delete(' + header + ') must throw');
+                  assert_throws_js(TypeError,
+                                   function() { headers.delete(header); },
+                                   'Headers.delete(' + header + ') must throw');
                   assert_equals(headers.get(header), value,
                     'header ' + header + ' must be unchanged by delete()');
                 });

third_party/blink/web_tests/http/tests/fetch/script-tests/headers.js

@@ -191,47 +191,47 @@ test(function() {
 
     // Throw errors
     INVALID_HEADER_NAMES.forEach(function(name) {
-        assert_throws({name: 'TypeError'},
-                      function() {
-                        var obj = {};
-                        obj[name] = 'a';
-                        var headers = new Headers(obj);
-                      },
-                      'new Headers with an invalid name (' + name +
-                      ') should throw');
-        assert_throws({name: 'TypeError'},
-                      function() { var headers = new Headers([[name, 'a']]); },
-                      'new Headers with an invalid name (' + name +
-                      ') should throw');
+        assert_throws_js(TypeError,
+                         function() {
+                           var obj = {};
+                           obj[name] = 'a';
+                           var headers = new Headers(obj);
+                         },
+                         'new Headers with an invalid name (' + name +
+                         ') should throw');
+        assert_throws_js(TypeError,
+                         function() { var headers = new Headers([[name, 'a']]); },
+                         'new Headers with an invalid name (' + name +
+                         ') should throw');
       });
 
 
     INVALID_HEADER_VALUES.forEach(function(value) {
-        assert_throws({name: 'TypeError'},
-                      function() { var headers = new Headers({'a': value}); },
-                      'new Headers with an invalid value should throw');
-        assert_throws({name: 'TypeError'},
-                      function() { var headers = new Headers([['a', value]]); },
-                      'new Headers with an invalid value should throw');
+        assert_throws_js(TypeError,
+                         function() { var headers = new Headers({'a': value}); },
+                         'new Headers with an invalid value should throw');
+        assert_throws_js(TypeError,
+                         function() { var headers = new Headers([['a', value]]); },
+                         'new Headers with an invalid value should throw');
       });
 
-    assert_throws({name: 'TypeError'},
-                  function() { var headers = new Headers([[]]); },
-                  'new Headers with a sequence with less than two strings ' +
-                  'should throw');
-    assert_throws({name: 'TypeError'},
-                  function() { var headers = new Headers([['a']]); },
-                  'new Headers with a sequence with less than two strings ' +
-                  'should throw');
-    assert_throws({name: 'TypeError'},
-                  function() { var headers = new Headers([['a', 'b'], []]); },
-                  'new Headers with a sequence with less than two strings ' +
-                  'should throw');
-    assert_throws({name: 'TypeError'},
-                  function() { var headers = new Headers([['a', 'b'],
-                                                          ['x', 'y', 'z']]); },
-                  'new Headers with a sequence with more than two strings ' +
-                  'should throw');
+    assert_throws_js(TypeError,
+                     function() { var headers = new Headers([[]]); },
+                     'new Headers with a sequence with less than two strings ' +
+                     'should throw');
+    assert_throws_js(TypeError,
+                     function() { var headers = new Headers([['a']]); },
+                     'new Headers with a sequence with less than two strings ' +
+                     'should throw');
+    assert_throws_js(TypeError,
+                     function() { var headers = new Headers([['a', 'b'], []]); },
+                     'new Headers with a sequence with less than two strings ' +
+                     'should throw');
+    assert_throws_js(TypeError,
+                     function() { var headers = new Headers([['a', 'b'],
+                                                             ['x', 'y', 'z']]); },
+                     'new Headers with a sequence with more than two strings ' +
+                     'should throw');
   }, 'Headers');
 
 test(function(t) {

third_party/blink/web_tests/http/tests/fetch/script-tests/request.js

@@ -238,8 +238,8 @@ test(function() {
             if (method1 != undefined) { init1['method'] = method1; }
             if (mode1 != undefined) { init1['mode'] = mode1; }
             if (!isSimpleMethod(method1) && mode1 == 'no-cors') {
-              assert_throws(
-                {name: 'TypeError'},
+              assert_throws_js(
+                TypeError,
                 function() { request1 = new Request(URL, init1); },
                 'new no-cors Request with non simple method (' + method1 +
                 ') should throw');
@@ -266,8 +266,8 @@ test(function() {
                     if (mode2 != undefined) { init2['mode'] = mode2; }
                     if (!isSimpleMethod(effectiveMethod(method1, method2)) &&
                         effectiveMode(mode1, mode2) == 'no-cors') {
-                      assert_throws(
-                        {name: 'TypeError'},
+                      assert_throws_js(
+                        TypeError,
                         function() { request2 = new Request(request1, init2); },
                         'new no-cors Request with non simple method should ' +
                         'throw');
@@ -359,8 +359,8 @@ test(function() {
 test(function() {
     ['same-origin', 'cors', 'no-cors'].forEach(function(mode) {
         FORBIDDEN_METHODS.forEach(function(method) {
-            assert_throws(
-              {name: 'TypeError'},
+            assert_throws_js(
+              TypeError,
               function() {
                 var request = new Request(URL, {mode: mode, method: method});
               },
@@ -368,8 +368,8 @@ test(function() {
               'throw');
           });
         INVALID_METHOD_NAMES.forEach(function(name) {
-            assert_throws(
-              {name: 'TypeError'},
+            assert_throws_js(
+              TypeError,
               function() {
                 var request = new Request(URL, {mode: mode, method: name});
               },
@@ -379,8 +379,8 @@ test(function() {
   }, 'Request method name throw test');
 
 test(function() {
-    assert_throws(
-      {name: 'TypeError'},
+    assert_throws_js(
+      TypeError,
       function() {
         var request = new Request(URL, {mode: 'navigate'});
       },
@@ -446,8 +446,8 @@ test(function() {
                  'Request should not be flagged as used if it has not been ' +
                  'consumed.');
     // See https://crbug.com/501195.
-    assert_throws(
-      {name: 'TypeError'},
+    assert_throws_js(
+      TypeError,
       function() { new Request(req); },
       'Request construction should throw if used.');
   }, 'POST Request construction without body behavior regardning "bodyUsed"');
@@ -457,15 +457,15 @@ test(function() {
     assert_false(req.bodyUsed,
                  'Request should not be flagged as used if it has not been ' +
                  'consumed.');
-    assert_throws(
-      {name: 'TypeError'},
+    assert_throws_js(
+      TypeError,
       function() { new Request(req, {method: 'GET'}); },
       'A get request may not have body.');
 
     assert_false(req.bodyUsed, 'After the GET case');
 
-    assert_throws(
-      {name: 'TypeError'},
+    assert_throws_js(
+      TypeError,
       function() { new Request(req, {method: 'CONNECT'}); },
       'Request() with a forbidden method must throw.');
 
@@ -553,7 +553,7 @@ test(function() {
 
 test(function() {
     var referrer = 'invali\0d';
-    assert_throws({name: 'TypeError'},
+    assert_throws_js(TypeError,
         () => new Request(URL, {referrer: referrer}));
   }, 'Request with an invalid referrer');
 
@@ -577,8 +577,8 @@ test(() => {
         .referrerPolicy, 'origin-when-cross-origin');
     assert_equals(new Request('/', {referrerPolicy: 'unsafe-url'})
         .referrerPolicy, 'unsafe-url');
-    assert_throws(
-        {name: 'TypeError'},
+    assert_throws_js(
+        TypeError,
         () => new Request('/', {referrerPolicy: 'invalid'}),
         'Setting invalid referrer policy should be thrown.');
   }, 'Referrer policy settings');
@@ -657,8 +657,8 @@ test(function() {
     var headers = new Headers;
     headers.set('Content-Language', 'ja');
     ['GET', 'HEAD'].forEach(function(method) {
-        assert_throws(
-          {name: 'TypeError'},
+        assert_throws_js(
+          TypeError,
           function() {
             new Request(URL,
                         {method: method,
@@ -673,7 +673,7 @@ test(() => {
     var req = new Request(URL, {method: 'POST', body: 'hello'});
     req.text();
     assert_true(req.bodyUsed);
-    assert_throws({name: 'TypeError'}, () => { req.clone(); });
+    assert_throws_js(TypeError, () => { req.clone(); });
   }, 'Used => clone');
 
 test(() => {
@@ -921,8 +921,8 @@ test(function() {
     // Step 32:
     // Fill r's Headers object with headers. Rethrow any exceptions.
     INVALID_HEADER_NAMES.forEach(function(name) {
-        assert_throws(
-          {name: 'TypeError'},
+        assert_throws_js(
+          TypeError,
           function() {
             var obj = {};
             obj[name] = 'a';
@@ -930,8 +930,8 @@ test(function() {
           },
           'new Request with headers with an invalid name (' + name +
           ') should throw');
-        assert_throws(
-          {name: 'TypeError'},
+        assert_throws_js(
+          TypeError,
           function() {
             new Request('http://localhost/', {headers: [[name, 'a']]});
           },
@@ -940,15 +940,15 @@ test(function() {
       });
 
     INVALID_HEADER_VALUES.forEach(function(value) {
-        assert_throws(
-          {name: 'TypeError'},
+        assert_throws_js(
+          TypeError,
           function() {
             new Request('http://localhost/',
                          {headers: {'X-Fetch-Test': value}});
           },
           'new Request with headers with an invalid value should throw');
-        assert_throws(
-          {name: 'TypeError'},
+        assert_throws_js(
+          TypeError,
           function() {
             new Request('http://localhost/',
                          {headers: [['X-Fetch-Test', value]]});

third_party/blink/web_tests/http/tests/fetch/script-tests/response-content.js

@@ -181,9 +181,9 @@ promise_test(function() {
     assert_true(response.bodyUsed, 'bodyUsed should be true when locked.');
     assert_false(response2.bodyUsed,
                  'Cloned bodies should not share bodyUsed.');
-    assert_throws({name: 'TypeError'},
-                  function() { response3 = response.clone(); },
-                  'Response.clone() should throw if the body was used.');
+    assert_throws_js(TypeError,
+                     function() { response3 = response.clone(); },
+                     'Response.clone() should throw if the body was used.');
     return p.then(function(text) {
         assert_true(response.bodyUsed);
         assert_false(response2.bodyUsed);

third_party/blink/web_tests/http/tests/fetch/script-tests/response.js

@@ -144,12 +144,12 @@ test(function() {
       });
 
     [204, 205, 304].forEach(function(status) {
-        assert_throws({name: 'TypeError'},
-                      function() {
-                        new Response(new Blob(), {status: status});
-                      },
-                      'new Response with null body status = ' + status +
-                      ' and body is non-null should throw');
+        assert_throws_js(TypeError,
+                         function() {
+                           new Response(new Blob(), {status: status});
+                         },
+                         'new Response with null body status = ' + status +
+                         ' and body is non-null should throw');
       });
 
     [300, 0, 304, 305, 306, 309, 500].forEach(function(status) {
@@ -162,8 +162,8 @@ test(function() {
                       ' should throw');
       });
 
-    assert_throws(
-      {name: 'TypeError'},
+    assert_throws_js(
+      TypeError,
       function() {
         Response.redirect('https://', 301);
       },
@@ -171,8 +171,8 @@ test(function() {
       ' and status 301 should throw');
 
     INVALID_URLS.forEach(function(url) {
-        assert_throws(
-          {name: 'TypeError'},
+        assert_throws_js(
+          TypeError,
           function() {
             Response.redirect(url);
           },
@@ -180,8 +180,8 @@ test(function() {
           ' and default status value should throw');
       });
 
-    assert_throws(
-      {name: 'TypeError'},
+    assert_throws_js(
+      TypeError,
       function() {
         Response.redirect('https://', 300);
       },
@@ -198,8 +198,8 @@ test(function() {
       });
 
     INVALID_HEADER_NAMES.forEach(function(name) {
-        assert_throws(
-          {name: 'TypeError'},
+        assert_throws_js(
+          TypeError,
           function() {
             var obj = {};
             obj[name] = 'a';
@@ -207,8 +207,8 @@ test(function() {
           },
           'new Response with headers with an invalid name (' + name +
           ') should throw');
-        assert_throws(
-          {name: 'TypeError'},
+        assert_throws_js(
+          TypeError,
           function() {
             new Response(new Blob(), {headers: [[name, 'a']]});
           },
@@ -216,15 +216,15 @@ test(function() {
           ') should throw');
       });
     INVALID_HEADER_VALUES.forEach(function(value) {
-        assert_throws(
-          {name: 'TypeError'},
+        assert_throws_js(
+          TypeError,
           function() {
             new Response(new Blob(),
                          {headers: {'X-Fetch-Test': value}});
           },
           'new Response with headers with an invalid value should throw');
-        assert_throws(
-          {name: 'TypeError'},
+        assert_throws_js(
+          TypeError,
           function() {
             new Response(new Blob(),
                          {headers: [['X-Fetch-Test', value]]});
@@ -240,8 +240,8 @@ test(function() {
       });
 
     INVALID_REASON_PHRASE.forEach(function(text) {
-        assert_throws(
-          {name: 'TypeError'},
+        assert_throws_js(
+          TypeError,
           function() {
             new Response(new Blob(), {statusText: text});
           },
@@ -301,7 +301,7 @@ promise_test(function(t) {
     assert_not_equals(res.body, body);
     assert_not_equals(res.body, clone.body);
     assert_not_equals(body, clone.body);
-    assert_throws({name: 'TypeError'}, function() { body.getReader(); });
+    assert_throws_js(TypeError, function() { body.getReader(); });
     return Promise.all([res.text(), clone.text()]).then(function(r) {
         assert_equals(r[0], 'hello');
         assert_equals(r[1], 'hello');
@@ -317,7 +317,7 @@ promise_test(function(t) {
     assert_not_equals(res.body, body);
     assert_not_equals(res.body, clone.body);
     assert_not_equals(body, clone.body);
-    assert_throws({name: 'TypeError'}, function() { body.getReader(); });
+    assert_throws_js(TypeError, function() { body.getReader(); });
     return Promise.all(
       [readableStreamToArray(res.body), readableStreamToArray(clone.body)])
       .then(r => {
@@ -330,14 +330,14 @@ test(() => {
     var res = new Response('hello');
     res.body.cancel();
     assert_true(res.bodyUsed);
-    assert_throws({name: 'TypeError'}, () => res.clone());
+    assert_throws_js(TypeError, () => res.clone());
   }, 'Used => clone');
 
 test(() => {
     var res = new Response('hello');
     const reader = res.body.getReader();
     assert_false(res.bodyUsed);
-    assert_throws({name: 'TypeError'}, () => res.clone());
+    assert_throws_js(TypeError, () => res.clone());
     reader.releaseLock();
   }, 'Locked => clone');
 
@@ -440,11 +440,11 @@ promise_test(function() {
         assert_equals(response.headers.get('location'),
                       'https://www.example.com/test.html',
                       'Location header should be correct absoulte URL');
-        assert_throws({name: 'TypeError'},
-                      function() {
-                        response.headers.append('Accept-Language', 'test');
-                      },
-                      'response.headers must throw since guard is immutable');
+        assert_throws_js(TypeError,
+                         function() {
+                           response.headers.append('Accept-Language', 'test');
+                         },
+                         'response.headers must throw since guard is immutable');
       });
   }, 'Response.redirect() with default status value');
 

third_party/blink/web_tests/http/tests/fetch/script-tests/stream-reader.js

@@ -7,7 +7,7 @@ promise_test(function(t) {
     return fetch('/fetch/resources/doctype.html').then(function(res) {
         var stream = res.body;
         var reader = stream.getReader();
-        assert_throws({name: 'TypeError'}, function() { stream.getReader() });
+        assert_throws_js(TypeError, function() { stream.getReader() });
         reader.releaseLock();
         var another = stream.getReader();
         assert_not_equals(another, reader);

third_party/blink/web_tests/http/tests/media/media-source/mediasource-append-buffer.html

@@ -544,7 +544,7 @@
               test.expectEvent(sourceBuffer, 'update', 'Append success.');
               test.expectEvent(sourceBuffer, 'updateend', 'Append ended.');
 
-              assert_throws( { name: 'TypeError'} ,
+              assert_throws_js( TypeError,
                   function() { sourceBuffer.appendBuffer(null); },
                   'appendBuffer(null) throws an exception.');
               test.done();
@@ -559,7 +559,7 @@
                   test.expectEvent(sourceBuffer, 'update', 'Append success.');
                   test.expectEvent(sourceBuffer, 'updateend', 'Append ended.');
 
-                  assert_throws( { name: 'TypeError'} ,
+                  assert_throws_js( TypeError,
                       function() { sourceBuffer.appendBuffer(new Uint8Array(new SharedArrayBuffer(16))); },
                       'appendBuffer() of SharedArrayBuffer view throws an exception.');
                   test.done();

third_party/blink/web_tests/http/tests/media/media-source/mediasource-appendwindow.html

@@ -32,51 +32,51 @@
               assert_true(sourceBuffer != null, 'New SourceBuffer returned');
               sourceBuffer.appendWindowEnd = 500.0;
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowStart = Number.NEGATIVE_INFINITY; },
                   'set appendWindowStart throws an exception for Number.NEGATIVE_INFINITY.');
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowStart = Number.POSITIVE_INFINITY; },
                   'set appendWindowStart throws an exception for Number.POSITIVE_INFINITY.');
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowStart = Number.NaN; },
                   'set appendWindowStart throws an exception for Number.NaN.');
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowStart = 600.0; },
                   'set appendWindowStart throws an exception when greater than appendWindowEnd.');
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowStart = sourceBuffer.appendWindowEnd; },
                   'set appendWindowStart throws an exception when equal to appendWindowEnd.');
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowEnd = sourceBuffer.appendWindowStart; },
                   'set appendWindowEnd throws an exception when equal to appendWindowStart.');
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowEnd = sourceBuffer.appendWindowStart - 1; },
                   'set appendWindowEnd throws an exception if less than appendWindowStart.');
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowStart = -100.0; },
                   'set appendWindowStart throws an exception when less than 0.');
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowEnd = -100.0; },
                   'set appendWindowEnd throws an exception when less than 0.');
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowEnd = Number.NaN; },
                   'set appendWindowEnd throws an exception if NaN.');
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowEnd = undefined; },
                   'set appendWindowEnd throws an exception if undefined.');
 
-              assert_throws({name: 'TypeError'},
+              assert_throws_js(TypeError,
                   function() { sourceBuffer.appendWindowStart = undefined; },
                   'set appendWindowStart throws an exception if undefined.');
 

third_party/blink/web_tests/http/tests/media/media-source/mediasource-duration-boundaryconditions.html

@@ -20,7 +20,7 @@
                   test.waitForExpectedEvents(function()
                   {
                       if (expectTypeError) {
-                          assert_throws({name: "TypeError"},
+                          assert_throws_js(TypeError,
                               function() { mediaSource.duration = testDurationValue; },
                               "mediaSource.duration assignment throws an exception for " + testDurationValue);
                           test.done();

third_party/blink/web_tests/http/tests/media/media-source/mediasource-timestamp-offset.html

@@ -17,7 +17,7 @@
                   var sourceBuffer = mediaSource.addSourceBuffer(segmentInfo.type);
 
                   if (expected == 'TypeError')  {
-                      assert_throws({name: 'TypeError'},
+                      assert_throws_js(TypeError,
                           function() { sourceBuffer.timestampOffset = value; },
                           'setting timestampOffset to ' + description + ' throws an exception.');
                   } else {

third_party/blink/web_tests/http/tests/notifications/resources/serviceworker-notification-constructor.js

@@ -3,7 +3,7 @@ importScripts('../../serviceworker/resources/worker-testharness.js');
 test(function() {
     assert_true('Notification' in self);
 
-    assert_throws({ name: 'TypeError' }, function() {
+    assert_throws_js(TypeError, function() {
         new Notification();
     });
 

third_party/blink/web_tests/screen_orientation/lockOrientation-bad-argument.html

@@ -15,47 +15,47 @@ window.screen.orientation.addEventListener('change', test.step_func(onOrientatio
 
 test.step(function() {
     assert_equals(screen.orientation.type, 'portrait-primary');
-    assert_throws({ name: 'TypeError' }, function() {
+    assert_throws_js(TypeError, function() {
         screen.lock('invalid-orientation');
     });
 
     assert_equals(screen.orientation.type, 'portrait-primary');
-    assert_throws({ name: 'TypeError' }, function() {
+    assert_throws_js(TypeError, function() {
         screen.lock(null);
     });
 
     assert_equals(screen.orientation.type, 'portrait-primary');
-    assert_throws({ name: 'TypeError' }, function() {
+    assert_throws_js(TypeError, function() {
         screen.lock(undefined);
     });
 
     assert_equals(screen.orientation.type, 'portrait-primary');
-    assert_throws({ name: 'TypeError' }, function() {
+    assert_throws_js(TypeError, function() {
         screen.lock(undefined);
     });
 
     assert_equals(screen.orientation.type, 'portrait-primary');
-    assert_throws({ name: 'TypeError' }, function() {
+    assert_throws_js(TypeError, function() {
         screen.lock(123);
     });
 
     assert_equals(screen.orientation.type, 'portrait-primary');
-    assert_throws({ name: 'TypeError' }, function() {
+    assert_throws_js(TypeError, function() {
         screen.lock(window);
     });
 
     assert_equals(screen.orientation.type, 'portrait-primary');
-    assert_throws({ name: 'TypeError' }, function() {
+    assert_throws_js(TypeError, function() {
         screen.lock(['portrait-primary']);
     });
 
     assert_equals(screen.orientation.type, 'portrait-primary');
-    assert_throws({ name: 'TypeError' }, function() {
+    assert_throws_js(TypeError, function() {
         screen.lock(['portrait-primary', 'landscape-primary']);
     });
 
     assert_equals(screen.orientation.type, 'portrait-primary');
-    assert_throws({ name: 'TypeError' }, function() {
+    assert_throws_js(TypeError, function() {
         screen.lock();
     });
 });

third_party/blink/web_tests/shadow-dom/attach-shadow-with-parameter.html

@@ -19,7 +19,7 @@ test(() => {
     assert_equals(Object.getPrototypeOf(root2), ShadowRoot.prototype,
         'ShadowRoot object should be returned by attachShadow({mode:"closed"}).');
 
-    assert_throws({name: 'TypeError'}, () => { host3.attachShadow({mode: 'illegal'}); },
+    assert_throws_js(TypeError, () => { host3.attachShadow({mode: 'illegal'}); },
         'Attach shadow root whose mode is neither open nor closed should throw TypeError.');
 
     assert_throws_dom('NotSupportedError', () => { host1.attachShadow({mode: 'open'}); },