Update writable streams for the latest spec changes

This incorporates the spec and test changes at:

- https://github.com/whatwg/streams/commit/0745219ca7b7f02ef104145b78ebebd99c0fd12c
- https://github.com/whatwg/streams/commit/872188a984722861020ae773a5ee558892797c33
- https://github.com/whatwg/streams/commit/591a6eda9ea0b84881a370519d6aca53fab9e256
- https://github.com/whatwg/streams/commit/551489c68d1f9c582a3a7334fbb88a85500d5867
- https://github.com/whatwg/streams/commit/68aa48c5e463bdc15c43944cd561ce6fcec5441c
- https://github.com/whatwg/streams/commit/43c4b00d440b3c391a48fb761c3967c2e77d6cd1
- https://github.com/whatwg/streams/commit/22b3f03bf803868bf65d9b57f862cc7e3cc80188

BUG=671958

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

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

@@ -32,9 +32,8 @@ promise_test(t => {
 
   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'),
@@ -52,8 +51,7 @@ promise_test(t => {
 
   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(() => {
@@ -140,4 +138,36 @@ promise_test(t => {
   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();

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

@@ -4,6 +4,9 @@ if (self.importScripts) {
   self.importScripts('/resources/testharness.js');
 }
 
+const error1 = new Error('error1');
+error1.name = 'error1';
+
 promise_test(() => {
   let controller;
   const ws = new WritableStream({
@@ -13,41 +16,44 @@ promise_test(() => {
   });
 
   // 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(() => {
@@ -126,7 +132,7 @@ test(() => {
 
   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();

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

@@ -152,6 +152,56 @@ promise_test(() => {
       .then(thisValue => assert_equals(thisValue, theSink, 'abort should be called as a method'));
 }, 'WritableStream should call underlying sink methods as methods');
 
+promise_test(t => {
+  function functionWithOverloads() {}
+  functionWithOverloads.apply = () => assert_unreached('apply() should not be called');
+  functionWithOverloads.call = () => assert_unreached('call() should not be called');
+  const underlyingSink = {
+    start: functionWithOverloads,
+    write: functionWithOverloads,
+    close: functionWithOverloads,
+    abort: functionWithOverloads
+  };
+  // Test start(), write(), close().
+  const ws1 = new WritableStream(underlyingSink);
+  const writer1 = ws1.getWriter();
+  writer1.write('a');
+  writer1.close();
+
+  // Test abort().
+  const ws2 = new WritableStream(underlyingSink);
+  const writer2 = ws2.getWriter();
+  writer2.abort();
+
+  // Test PromiseInvokeOrFallbackOrNoop.
+  const ws3 = new WritableStream({
+    start: functionWithOverloads,
+    write: functionWithOverloads,
+    close: functionWithOverloads
+  });
+  const writer3 = ws3.getWriter();
+  writer3.abort();
+
+  return writer1.closed
+      .then(() => promise_rejects(t, new TypeError(), writer2.closed, 'writer2.closed should be rejected'))
+      .then(() => promise_rejects(t, new TypeError(), writer3.closed, 'writer3.closed should be rejected'));
+}, 'methods should not not have .apply() or .call() called');
+
+promise_test(() => {
+  const strategy = {
+    size() {
+      if (this !== undefined) {
+        throw new Error('size called as a method');
+      }
+      return 1;
+    }
+  };
+
+  const ws = new WritableStream({}, strategy);
+  const writer = ws.getWriter();
+  return writer.write('a');
+}, 'WritableStream\'s strategy.size should not be called as a method');
+
 promise_test(() => {
   const ws = new WritableStream();
   const writer1 = ws.getWriter();