Fix crash in WritableStreamFinishClose

WritableStreamFinishClose would fail if the writer had been
detached. Add checks to stop this happening.

This updates the implementation to match Streams Standard version

https://github.com/whatwg/streams/commit/347667724b8a4b83fcc379b730603cf4cd0d6e91

which is current as of 12 Jan 2017.

Also update the tests to the same commit.

BUG=658144

Review-Url: https://codereview.chromium.org/2625873008
Cr-Commit-Position: refs/heads/master@{#443201}

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

@@ -170,4 +170,47 @@ promise_test(t => {
   });
 }, 'releaseLock() should not change the result of async close()');
 
+promise_test(() => {
+  let resolveClose;
+  const ws = new WritableStream({
+    close() {
+      const promise = new Promise(resolve => {
+        resolveClose = resolve;
+      });
+      return promise;
+    }
+  });
+  const writer = ws.getWriter();
+  const closePromise = writer.close();
+  writer.releaseLock();
+  return delay(0).then(() => {
+    resolveClose();
+    return closePromise.then(() => {
+      assert_equals(ws.getWriter().desiredSize, 0, 'desiredSize should be 0');
+    });
+  });
+}, 'close() should set state to CLOSED even if writer has detached');
+
+promise_test(() => {
+  let resolveClose;
+  const ws = new WritableStream({
+    close() {
+      const promise = new Promise(resolve => {
+        resolveClose = resolve;
+      });
+      return promise;
+    }
+  });
+  const writer = ws.getWriter();
+  writer.close();
+  writer.releaseLock();
+  return delay(0).then(() => {
+    const abortingWriter = ws.getWriter();
+    const abortPromise = abortingWriter.abort();
+    abortingWriter.releaseLock();
+    resolveClose();
+    return abortPromise;
+  });
+}, 'the promise returned by async abort during close should resolve');
+
 done();

third_party/WebKit/Source/core/streams/WritableStream.js

@@ -306,13 +306,16 @@
     TEMP_ASSERT(state === CLOSING || state === ERRORED,
                 'state is "closing" or "errored"');
 
+    const writer = stream[_writer];
     if (state === CLOSING) {
-      v8.resolvePromise(stream[_writer][_closedPromise], undefined);
+      if (writer !== undefined) {
+        v8.resolvePromise(writer[_closedPromise], undefined);
+      }
       stream[_state] = CLOSED;
-    } else {
+    } else if (writer !== undefined) {
       TEMP_ASSERT(state === ERRORED, 'state is "errored"');
-      v8.rejectPromise(stream[_writer][_closedPromise], stream[_storedError]);
-      v8.markPromiseAsHandled(stream[_writer][_closedPromise]);
+      v8.rejectPromise(writer[_closedPromise], stream[_storedError]);
+      v8.markPromiseAsHandled(writer[_closedPromise]);
     }
 
     if (stream[_pendingAbortRequest] !== undefined) {