Import wpt@767dc2a4f049c761bd146d61de2ea860a895a624

third_party/WebKit/LayoutTests/external/wpt/streams/writable-streams/write.js

 'use strict';
 
 if (self.importScripts) {
   self.importScripts('/resources/testharness.js');
   self.importScripts('../resources/test-utils.js');
   self.importScripts('../resources/recording-streams.js');
 }
 
+const error1 = new Error('error1');
+error1.name = 'error1';
+
+const error2 = new Error('error2');
+error2.name = 'error2';
+
 function writeArrayToStream(array, writableStreamWriter) {
   array.forEach(chunk => writableStreamWriter.write(chunk));
   return writableStreamWriter.close();
 }
 
 promise_test(() => {
   let storage;
   const ws = new WritableStream({
     start() {
       storage = [];
@@ skipping 104 matching lines @@
     assert_equals(writer.desiredSize, 0, 'desiredSize should be 0');
 
     const writePromise2 = writer.write('b');
     assert_equals(sinkWritePromiseRejectors.length, 1, 'there should be still 1 rejector');
     assert_equals(writer.desiredSize, -1, 'desiredSize should be -1');
 
     const closedPromise = writer.close();
 
     assert_equals(writer.desiredSize, -1, 'desiredSize should still be -1');
 
-    const passedError = new Error('horrible things');
-
     return Promise.all([
-      promise_rejects(t, passedError, closedPromise, 'closedPromise should reject with passedError')
+      promise_rejects(t, error1, closedPromise,
+                      'closedPromise should reject with the error returned from the sink\'s write method')
           .then(() => assert_equals(sinkWritePromiseRejectors.length, 0,
                                     'sinkWritePromise should reject before closedPromise')),
-      promise_rejects(t, passedError, writePromise, 'writePromise should reject with passedError')
+      promise_rejects(t, error1, writePromise,
+                      'writePromise should reject with the error returned from the sink\'s write method')
           .then(() => assert_equals(sinkWritePromiseRejectors.length, 0,
                                     'sinkWritePromise should reject before writePromise')),
-      promise_rejects(t, passedError, writePromise2, 'writePromise2 should reject with passedError')
+      promise_rejects(t, error1, writePromise2,
+                      'writePromise2 should reject with the error returned from the sink\'s write method')
           .then(() => assert_equals(sinkWritePromiseRejectors.length, 0,
                                     'sinkWritePromise should reject before writePromise2')),
       flushAsyncEvents().then(() => {
-        sinkWritePromiseRejectors[0](passedError);
+        sinkWritePromiseRejectors[0](error1);
         sinkWritePromiseRejectors = [];
       })
     ]);
   });
 }, 'when write returns a rejected promise, queued writes and close should be cleared');
 
 promise_test(t => {
-  const thrownError = new Error('throw me');
   const ws = new WritableStream({
     write() {
-      throw thrownError;
+      throw error1;
     }
   });
 
   const writer = ws.getWriter();
 
-  return promise_rejects(t, thrownError, writer.write('a'), 'write() should reject with thrownError')
+  return promise_rejects(t, error1, writer.write('a'),
+                         'write() should reject with the error returned from the sink\'s write method')
       .then(() => promise_rejects(t, new TypeError(), writer.close(), 'close() should be rejected'));
 }, 'when sink\'s write throws an error, the stream should become errored and the promise should reject');
 
+promise_test(t => {
+  const ws = new WritableStream({
+    write(chunk, controller) {
+      controller.error(error1);
+      throw error2;
+    }
+  });
+
+  const writer = ws.getWriter();
+
+  return promise_rejects(t, error2, writer.write('a'),
+                         'write() should reject with the error returned from the sink\'s write method ')
+  .then(() => {
+    return Promise.all([
+      promise_rejects(t, error1, writer.ready,
+                      'writer.ready must reject with the error passed to the controller'),
+      promise_rejects(t, error1, writer.closed,
+                      'writer.closed must reject with the error passed to the controller')
+    ]);
+  });
+}, 'writer.write(), ready and closed reject with the error passed to controller.error() made before sink.write'
+    + ' rejection');
+
 promise_test(() => {
   const numberOfWrites = 1000;
 
   let resolveFirstWritePromise;
   let writeCount = 0;
   const ws = new WritableStream({
     write() {
       ++writeCount;
       if (!resolveFirstWritePromise) {
         return new Promise(resolve => {
@@ skipping 42 matching lines @@
           thenCalled = true;
           onFulfilled();
         }
       };
     }
   });
   return ws.getWriter().write('a').then(() => assert_true(thenCalled, 'thenCalled should be true'));
 }, 'returning a thenable from write() should work');
 
 done();