Update writable streams for the latest spec changes

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

 'use strict';
 
 if (self.importScripts) {
   self.importScripts('/resources/testharness.js');
   self.importScripts('../resources/test-utils.js');
   self.importScripts('../resources/recording-streams.js');
 }
 
 promise_test(() => {
   const ws = new WritableStream({
@@ skipping 14 matching lines @@
   let controller;
   const ws = new WritableStream({
     close(c) {
       controller = c;
       return delay(50);
     }
   });
 
   const writer = ws.getWriter();
 
-  writer.close();
-
   return Promise.all([
+    writer.close(),
     delay(10).then(() => controller.error(passedError)),
     promise_rejects(t, passedError, writer.closed,
                     'closed promise should be rejected with the passed error'),
     delay(70).then(() => promise_rejects(t, passedError, writer.closed, 'closed should stay rejected'))
   ]);
 }, 'when sink calls error asynchronously while closing, the stream should become errored');
 
 promise_test(t => {
   const passedError = new Error('error me');
   const ws = new WritableStream({
     close(controller) {
       controller.error(passedError);
     }
   });
 
   const writer = ws.getWriter();
 
-  return promise_rejects(t, passedError, writer.close(), 'close promise should be rejected with the passed error')
-      .then(() => promise_rejects(t, passedError, writer.closed, 'closed should stay rejected'));
+  return writer.close().then(() => promise_rejects(t, passedError, writer.closed, 'closed should stay rejected'));
 }, 'when sink calls error synchronously while closing, the stream should become errored');
 
 promise_test(() => {
   const ws = recordingWritableStream();
 
   const writer = ws.getWriter();
 
   return writer.ready.then(() => {
     assert_equals(writer.desiredSize, 1, 'desiredSize should be 1');
 
@@ skipping 66 matching lines @@
   const ws = new WritableStream({
     close() {
       return {
         then(onFulfilled, onRejected) { onRejected(rejection); }
       };
     }
   });
   return promise_rejects(t, rejection, ws.getWriter().close(), 'close() should return a rejection');
 }, 'returning a thenable from close() should work');
 
+promise_test(t => {
+  const ws = new WritableStream();
+  const writer = ws.getWriter();
+  return writer.ready.then(() => {
+    const closePromise = writer.close();
+    const closedPromise = writer.closed;
+    writer.releaseLock();
+    return Promise.all([
+      closePromise,
+      promise_rejects(t, new TypeError(), closedPromise, '.closed promise should be rejected')
+    ]);
+  });
+}, 'releaseLock() should not change the result of sync close()');
+
+promise_test(t => {
+  const ws = new WritableStream({
+    close() {
+      return flushAsyncEvents();
+    }
+  });
+  const writer = ws.getWriter();
+  return writer.ready.then(() => {
+    const closePromise = writer.close();
+    const closedPromise = writer.closed;
+    writer.releaseLock();
+    return Promise.all([
+      closePromise,
+      promise_rejects(t, new TypeError(), closedPromise, '.closed promise should be rejected')
+    ]);
+  });
+}, 'releaseLock() should not change the result of async close()');
+
 done();