Import latest WritableStream tests from upstream

third_party/WebKit/LayoutTests/http/tests/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');
 }
 
 function writeArrayToStream(array, writableStreamWriter) {
   array.forEach(chunk => writableStreamWriter.write(chunk));
@@ skipping 78 matching lines @@
         assert_equals(value, undefined, 'writePromise should be fulfilled with undefined');
       }),
       writer.ready.then(value => {
         assert_equals(resolveSinkWritePromise, undefined, 'sinkWritePromise should be fulfilled before writer.ready');
         assert_true(writePromiseResolved, 'writePromise should be fulfilled before writer.ready');
 
         assert_equals(writer.desiredSize, 1, 'desiredSize should be 1 again');
 
         assert_equals(value, undefined, 'writePromise should be fulfilled with undefined');
       }),
-      delay(100).then(() => {
+      flushAsyncEvents().then(() => {
         resolveSinkWritePromise();
         resolveSinkWritePromise = undefined;
       })
     ]);
   });
 }, 'WritableStream should transition to waiting until write is acknowledged');
 
 promise_test(t => {
   let sinkWritePromiseRejectors = [];
   const ws = new WritableStream({
@@ skipping 25 matching lines @@
     return Promise.all([
       promise_rejects(t, passedError, closedPromise, 'closedPromise should reject with passedError')
           .then(() => assert_equals(sinkWritePromiseRejectors.length, 0,
                                     'sinkWritePromise should reject before closedPromise')),
       promise_rejects(t, passedError, writePromise, 'writePromise should reject with passedError')
           .then(() => assert_equals(sinkWritePromiseRejectors.length, 0,
                                     'sinkWritePromise should reject before writePromise')),
       promise_rejects(t, passedError, writePromise2, 'writePromise2 should reject with passedError')
           .then(() => assert_equals(sinkWritePromiseRejectors.length, 0,
                                     'sinkWritePromise should reject before writePromise2')),
-      delay(100).then(() => {
+      flushAsyncEvents().then(() => {
         sinkWritePromiseRejectors[0](passedError);
         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({
@@ skipping 31 matching lines @@
       writer.write('a');
     }
     const writePromise = writer.write('a');
 
     assert_equals(writeCount, 1, 'should have called sink\'s write once');
 
     resolveFirstWritePromise();
 
     return writePromise
         .then(() =>
-          assert_equals(writeCount, numberOfWrites, `should have called sink's write ${numberOfWrites} times`));
+        assert_equals(writeCount, numberOfWrites, `should have called sink's write ${numberOfWrites} times`));
   });
 }, 'a large queue of writes should be processed completely');
 
 promise_test(() => {
   const stream = recordingWritableStream();
   const w = stream.getWriter();
   const WritableStreamDefaultWriter = w.constructor;
   w.releaseLock();
   const writer = new WritableStreamDefaultWriter(stream);
   return writer.ready.then(() => {
@@ skipping 11 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();