Split RTCDataChannel-send-close.html web test to avoid timeouts (web-platform-tests#54772)

Addresses flakes by dividing the test into three new tests. Adds one
test for each type of data sent: Blob, string, and ArrayBuffer. Adds
`RTCDataChannel-send-close-helper.js` for shared test code.

The original test ran for ~45 seconds on my powerful developer machine.
Each new tests takes ~15 seconds.

Re-enables the test on win-arm and Linux. MacOS still fails with the
following network errors, that lead to a timeout:

```
services/network/p2p/socket_manager.cc:137 Failed to resolve address for
9218b16a-a784-40f0-9384-0dec7712202d.local., errorcode: -105

third_party/webrtc/p2p/base/p2p_transport_channel.cc:1274 Failed to
resolve ICE candidate hostname
9218b16a-a784-40f0-9384-0dec7712202d.local with error -1
```

Bug: 377072733 414687402
Change-Id: I2e367bdcb9185437d8db4840b5b3ccc70143de7c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6913845
Reviewed-by: Henrik Boström <hbos@chromium.org>
Reviewed-by: Mason Freed <masonf@chromium.org>
Commit-Queue: Steve Becker <stevebe@microsoft.com>
Cr-Commit-Position: refs/heads/main@{#1513170}

Co-authored-by: Steve Becker <stevebe@microsoft.com>

Author: chromium-wpt-export-bot

webrtc/RTCDataChannel-send-close-array-buffer.window.js

@@ -0,0 +1,10 @@
+// META: title=RTCDataChannel.prototype.send with large ArrayBuffer
+// META: script=RTCPeerConnection-helper.js
+// META: script=RTCDataChannel-send-close-helper.js
+// META: timeout=long
+
+'use strict';
+
+const largeString = ' '.repeat(largeSendDataLength);
+const largeArrayBuffer = new TextEncoder('utf-8').encode(largeString);
+rtc_data_channel_send_close_test(/*sendData=*/ largeArrayBuffer);

webrtc/RTCDataChannel-send-close-blob.window.js

@@ -0,0 +1,9 @@
+// META: title=RTCDataChannel.prototype.send with large Blob
+// META: script=RTCPeerConnection-helper.js
+// META: script=RTCDataChannel-send-close-helper.js
+// META: timeout=long
+
+'use strict';
+
+const largeBlob = new Blob([' '.repeat(largeSendDataLength)]);
+rtc_data_channel_send_close_test(/*sendData=*/ largeBlob);

webrtc/RTCDataChannel-send-close-helper.js

@@ -0,0 +1,88 @@
+// META: script=RTCPeerConnection-helper.js
+
+const largeSendDataLength = 64 * 1024;
+
+function rtc_data_channel_send_close_test(sendData) {
+  // Run the test twice: once with a regular data channel and once with a
+  // negotiated data channel.
+  for (const options of [{}, {negotiated: true, id: 0}]) {
+    const mode = `${options.negotiated ? 'Negotiated d' : 'D'}atachannel`;
+
+    // Determine the type of the data being sent.
+    let sendDataType = typeof (sendData);
+    if (sendDataType === 'object') {
+      if (ArrayBuffer.isView(sendData)) {
+        sendDataType = 'arraybuffer';
+      } else if (sendData instanceof Blob) {
+        sendDataType = 'blob';
+      }
+    }
+
+    // Determine the length of the data being sent.
+    let sendDataLength = 0;
+    switch (sendDataType) {
+      case 'string':
+        sendDataLength = sendData.length;
+        break;
+      case 'arraybuffer':
+        sendDataLength = sendData.byteLength;
+        break;
+      case 'blob':
+        sendDataLength = sendData.size;
+        break;
+    }
+
+    promise_test(
+        async t => {
+          assert_greater_than(
+              sendDataLength, 0,
+              '`sendData` must be a string, Blob or ArrayBuffer view.');
+
+          let [channel1, channel2] = await createDataChannelPair(t, options);
+          let receivedSize = 0, sentSize = 0;
+
+          channel2.binaryType = 'arraybuffer';
+          channel2.onmessage = e => {
+            if (typeof e.data === 'string')
+              receivedSize += e.data.length;
+            else
+              receivedSize += e.data.byteLength;
+          };
+
+          channel2.onerror = event => {
+            assert_unreached(
+                `channel2 must not dispatch error events: ${event.error}.`);
+          };
+
+          let closePromiseResolve;
+          let closePromise = new Promise((resolve, reject) => {
+            closePromiseResolve = resolve;
+          });
+          channel2.onclose = e => {
+            closePromiseResolve();
+          };
+
+          try {
+            while (sentSize < 20 * 1024 * 1024) {
+              channel1.send(sendData);
+              sentSize += sendDataLength;
+            }
+          } catch (error) {
+            assert_true(error instanceof DOMException);
+            assert_equals(error.name, 'OperationError');
+          }
+          channel1.onerror = event => {
+            assert_unreached(
+                `channel1 must not dispatch error events: ${event.error}.`);
+          };
+          channel1.close();
+
+          await closePromise;
+          assert_equals(
+              receivedSize, sentSize,
+              'All the pending sent messages are received after calling close()');
+        },
+        `${mode} should be able to send and receive all ${
+            sendDataType} messages on close`);
+  }
+}

webrtc/RTCDataChannel-send-close-string.window.js

@@ -0,0 +1,9 @@
+// META: title=RTCDataChannel.prototype.send with large string
+// META: script=RTCPeerConnection-helper.js
+// META: script=RTCDataChannel-send-close-helper.js
+// META: timeout=long
+
+'use strict';
+
+const largeString = ' '.repeat(largeSendDataLength);
+rtc_data_channel_send_close_test(/*sendData=*/ largeString);