Update writable streams for the latest spec changes

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

 'use strict';
 
 if (self.importScripts) {
   self.importScripts('/resources/testharness.js');
 }
 
 test(() => {
   const ws = new WritableStream({});
   const writer = ws.getWriter();
   writer.releaseLock();
@@ skipping 134 matching lines @@
   return promises.start
       .then(thisValue => assert_equals(thisValue, theSink, 'start should be called as a method'))
       .then(() => promises.write)
       .then(thisValue => assert_equals(thisValue, theSink, 'write should be called as a method'))
       .then(() => promises.close)
       .then(thisValue => assert_equals(thisValue, theSink, 'close should be called as a method'))
       .then(() => promises.abort)
       .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();
   assert_equals(undefined, writer1.releaseLock(), 'releaseLock() should return undefined');
   const writer2 = ws.getWriter();
   assert_equals(undefined, writer1.releaseLock(), 'no-op releaseLock() should return undefined');
   // Calling releaseLock() on writer1 should not interfere with writer2. If it did, then the ready promise would be
   // rejected.
   return writer2.ready;
 }, 'redundant releaseLock() is no-op');
 
 done();