Update writable streams for the latest spec changes

third_party/WebKit/LayoutTests/http/tests/streams/writable-streams/constructor.js

 'use strict';
 
 if (self.importScripts) {
   self.importScripts('/resources/testharness.js');
 }
 
+const error1 = new Error('error1');
+error1.name = 'error1';
+
 promise_test(() => {
   let controller;
   const ws = new WritableStream({
     start(c) {
       controller = c;
     }
   });
 
   // Now error the stream after its construction.
-  const passedError = new Error('horrible things');
-  controller.error(passedError);
+  controller.error(error1);
 
   const writer = ws.getWriter();
 
   assert_equals(writer.desiredSize, null, 'desiredSize should be null');
   return writer.closed.catch(r => {
-    assert_equals(r, passedError, 'ws should be errored by passedError');
+    assert_equals(r, error1, 'ws should be errored by the passed error');
   });
 }, 'controller argument should be passed to start method');
 
 promise_test(t => {
   const ws = new WritableStream({
     write(chunk, controller) {
-      controller.error(new Error());
+      controller.error(error1);
     }
   });
 
   const writer = ws.getWriter();
-  writer.write('a');
 
-  return promise_rejects(t, new Error(), writer.closed, 'controller.error() in write() should errored the stream');
+  return Promise.all([
+    writer.write('a'),
+    promise_rejects(t, error1, writer.closed, 'controller.error() in write() should errored the stream')
+  ]);
 }, 'controller argument should be passed to write method');
 
 promise_test(t => {
   const ws = new WritableStream({
     close(controller) {
-      controller.error(new Error());
+      controller.error(error1);
     }
   });
 
   const writer = ws.getWriter();
-  writer.close();
 
-  return promise_rejects(t, new Error(), writer.closed, 'controller.error() in close() should error the stream');
+  return Promise.all([
+    writer.close(),
+    promise_rejects(t, error1, writer.closed, 'controller.error() in close() should error the stream')
+  ]);
 }, 'controller argument should be passed to close method');
 
 promise_test(() => {
   const ws = new WritableStream({}, {
     highWaterMark: 1000,
     size() { return 1; }
   });
 
   const writer = ws.getWriter();
 
@@ skipping 58 matching lines @@
 test(() => {
   let WritableStreamDefaultController;
   const stream = new WritableStream({
     start(c) {
       WritableStreamDefaultController = c.constructor;
     }
   });
 
   assert_throws(new TypeError(), () => new WritableStreamDefaultController(stream),
                 'constructor should throw a TypeError exception');
-}, 'WritableStreamDefaultController constructor should throw when passed an initalised WritableStream');
+}, 'WritableStreamDefaultController constructor should throw when passed an initialised WritableStream');
 
 test(() => {
   const stream = new WritableStream();
   const writer = stream.getWriter();
   const WritableStreamDefaultWriter = writer.constructor;
   writer.releaseLock();
   assert_throws(new TypeError(), () => new WritableStreamDefaultWriter({}),
                 'constructor should throw a TypeError exception');
 }, 'WritableStreamDefaultWriter should throw unless passed a WritableStream');
 
 test(() => {
   const stream = new WritableStream();
   const writer = stream.getWriter();
   const WritableStreamDefaultWriter = writer.constructor;
   assert_throws(new TypeError(), () => new WritableStreamDefaultWriter(stream),
                 'constructor should throw a TypeError exception');
 }, 'WritableStreamDefaultWriter constructor should throw when stream argument is locked');
 
 done();