Implementation of ReadableStream pipeTo and pipeThrough

third_party/WebKit/LayoutTests/http/tests/streams/piping/multiple-propagation.js

Index: third_party/WebKit/LayoutTests/http/tests/streams/piping/multiple-propagation.js
diff --git a/third_party/WebKit/LayoutTests/http/tests/streams/piping/multiple-propagation.js b/third_party/WebKit/LayoutTests/http/tests/streams/piping/multiple-propagation.js
new file mode 100644
index 0000000000000000000000000000000000000000..2c7fd141db4941144968c46c5e8ad2fa272c8e99
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/http/tests/streams/piping/multiple-propagation.js
@@ -0,0 +1,139 @@
+'use strict';
+
+if (self.importScripts) {
+  self.importScripts('/resources/testharness.js');
+  self.importScripts('../resources/test-utils.js');
+  self.importScripts('../resources/recording-streams.js');
+}
+
+const error1 = new Error('error1!');
+error1.name = 'error1';
+
+const error2 = new Error('error2!');
+error2.name = 'error2';
+
+promise_test(t => {
+  const rs = recordingReadableStream({
+    start(c) {
+      c.error(error1);
+    }
+  });
+  const ws = recordingWritableStream({
+    start(c) {
+      c.error(error2);
+    }
+  });
+
+  // Trying to abort a stream that was errored will give that error back
+  return promise_rejects(t, error2, rs.pipeTo(ws), 'pipeTo must reject with the writable stream\'s error').then(() => {
+    assert_array_equals(rs.events, []);
+    assert_array_equals(ws.events, []);
+
+    return Promise.all([
+      promise_rejects(t, error1, rs.getReader().closed, 'the readable stream must be errored with error1'),
+      promise_rejects(t, error2, ws.getWriter().closed, 'the writable stream must be errored with error2')
+    ]);
+  });
+
+}, 'Piping from an errored readable stream to an errored writable stream');
+
+promise_test(t => {
+  const rs = recordingReadableStream({
+    start(c) {
+      c.error(error1);
+    }
+  });
+  const ws = recordingWritableStream({
+    start(c) {
+      c.error(error2);
+    }
+  });
+
+  return promise_rejects(t, error1, rs.pipeTo(ws, { preventAbort: true }),
+    'pipeTo must reject with the readable stream\'s error')
+  .then(() => {
+    assert_array_equals(rs.events, []);
+    assert_array_equals(ws.events, []);
+
+    return Promise.all([
+      promise_rejects(t, error1, rs.getReader().closed, 'the readable stream must be errored with error1'),
+      promise_rejects(t, error2, ws.getWriter().closed, 'the writable stream must be errored with error2')
+    ]);
+  });
+
+}, 'Piping from an errored readable stream to an errored writable stream; preventAbort = true');
+
+// TODO(ricea): Revert to the upstream version of this test once https://github.com/whatwg/streams/pull/634 is
+// resolved and WritableStream.js has been updated to match.
+promise_test(t => {
+  const rs = recordingReadableStream({
+    start(c) {
+      c.error(error1);
+    }
+  });
+  const ws = recordingWritableStream();
+  const writer = ws.getWriter();
+  const closePromise = writer.close();
+  writer.releaseLock();
+
+  return promise_rejects(t, error1, rs.pipeTo(ws), 'pipeTo must reject with the readable stream\'s error').then(() => {
+    assert_array_equals(rs.events, []);
+    assert_array_equals(ws.events, ['abort', error1], 'ws.events should contain abort for the time being');
+
+    return Promise.all([
+      promise_rejects(t, error1, rs.getReader().closed, 'the readable stream must be errored with error1'),
+      promise_rejects(t, new TypeError(), ws.getWriter().closed, 'the writable stream should be errored for the time being'),
+      promise_rejects(t, new TypeError(), closePromise, 'close() should reject for the time being')
+    ]);
+  });
+
+}, 'Piping from an errored readable stream to a closed writable stream');
+
+promise_test(t => {
+  const rs = recordingReadableStream({
+    start(c) {
+      c.close();
+    }
+  });
+  const ws = recordingWritableStream({
+    start(c) {
+      c.error(error1);
+    }
+  });
+
+  return promise_rejects(t, error1, rs.pipeTo(ws), 'pipeTo must reject with the writable stream\'s error').then(() => {
+    assert_array_equals(rs.events, []);
+    assert_array_equals(ws.events, []);
+
+    return Promise.all([
+      rs.getReader().closed,
+      promise_rejects(t, error1, ws.getWriter().closed, 'the writable stream must be errored with error1')
+    ]);
+  });
+
+}, 'Piping from a closed readable stream to an errored writable stream');
+
+promise_test(() => {
+  const rs = recordingReadableStream({
+    start(c) {
+      c.close();
+    }
+  });
+  const ws = recordingWritableStream();
+  const writer = ws.getWriter();
+  writer.close();
+  writer.releaseLock();
+
+  return rs.pipeTo(ws).then(() => {
+    assert_array_equals(rs.events, []);
+    assert_array_equals(ws.events, ['close']);
+
+    return Promise.all([
+      rs.getReader().closed,
+      ws.getWriter().closed
+    ]);
+  });
+
+}, 'Piping from a closed readable stream to a closed writable stream');
+
+done();