Reflect recent spec changes to V8 Extra ReadableStream impl

third_party/WebKit/LayoutTests/http/tests/streams/readable-streams/bad-strategies.js

 'use strict';
 
 if (self.importScripts) {
   self.importScripts('/resources/testharness.js');
 }
 
 test(() => {
 
   const theError = new Error('a unique string');
 
   assert_throws(theError, () => {
     new ReadableStream({}, {
       get size() {
         throw theError;
       },
       highWaterMark: 5
     });
   }, 'construction should re-throw the error');
 
 }, 'Readable stream: throwing strategy.size getter');
 
-test(() => {
+promise_test(t => {
 
-  const theError = new Error('a unique string');
+  const controllerError = { name: 'controller error' };
+  const thrownError = { name: 'thrown error' };
 
   let controller;
   const rs = new ReadableStream(
     {
       start(c) {
         controller = c;
       }
     },
     {
       size() {
-        controller.error(theError);
-        throw theError;
+        controller.error(controllerError);
+        throw thrownError;
       },
       highWaterMark: 5
     }
   );
 
-  assert_throws(theError, () => {
-    controller.enqueue('a');
-  }, 'enqueue should re-throw the error');
+  assert_throws(thrownError, () => controller.enqueue('a'), 'enqueue should re-throw the error');
+
+  return promise_rejects(t, controllerError, rs.getReader().closed);
 
 }, 'Readable stream: strategy.size errors the stream and then throws');
 
-test(() => {
+promise_test(t => {
 
-  const theError = new Error('a unique string');
+  const theError = { name: 'my error' };
 
   let controller;
   const rs = new ReadableStream(
     {
       start(c) {
         controller = c;
       }
     },
     {
       size() {
         controller.error(theError);
         return Infinity;
       },
       highWaterMark: 5
     }
   );
 
-  try {
-    controller.enqueue('a');
-  } catch (error) {
-    assert_equals(error.name, 'RangeError', 'enqueue should throw a RangeError');
-  }
+  assert_throws(new RangeError(), () => controller.enqueue('a'), 'enqueue should throw a RangeError');
+
+  return promise_rejects(t, theError, rs.getReader().closed, 'closed should reject with the error');
 
 }, 'Readable stream: strategy.size errors the stream and then returns Infinity');
 
 promise_test(() => {
 
   const theError = new Error('a unique string');
   const rs = new ReadableStream(
     {
       start(c) {
         assert_throws(theError, () => c.enqueue('a'), 'enqueue should throw the error');
@@ skipping 84 matching lines @@
     promises.push(rs.getReader().closed.catch(e => {
       assert_equals(e, theError, 'closed should reject with the error for ' + size);
     }));
   }
 
   return Promise.all(promises);
 
 }, 'Readable stream: invalid strategy.size return value');
 
 done();