diff --git a/websockets/stream/tentative/abort.any.js b/websockets/stream/tentative/abort.any.js
index 6742bf2b38fb1d..9047f246f968f6 100644
--- a/websockets/stream/tentative/abort.any.js
+++ b/websockets/stream/tentative/abort.any.js
@@ -16,9 +16,10 @@ promise_test(async t => {
   // We intentionally use the port for the HTTP server, not the WebSocket
   // server, because we don't expect the connection to be performed.
   const wss = new WebSocketStream(wsUrl, { signal: controller.signal });
-  await promise_rejects_dom(t, 'AbortError', wss.connection,
-                        'connection should reject');
-  await promise_rejects_dom(t, 'AbortError', wss.closed, 'closed should reject');
+  await promise_rejects_dom(
+      t, 'AbortError', wss.opened, 'opened should reject');
+  await promise_rejects_dom(
+      t, 'AbortError', wss.closed, 'closed should reject');
   // An incorrect implementation could pass this test due a race condition,
   // but it is hard to completely eliminate the possibility.
   const response = await fetch(`/fetch/api/resources/stash-take.py?key=${key}`);
@@ -32,15 +33,16 @@ promise_test(async t => {
   // Give the connection a chance to start.
   await new Promise(resolve => t.step_timeout(resolve, 0));
   controller.abort();
-  await promise_rejects_dom(t, 'AbortError', wss.connection,
-                        'connection should reject');
-  await promise_rejects_dom(t, 'AbortError', wss.closed, 'closed should reject');
+  await promise_rejects_dom(
+      t, 'AbortError', wss.opened, 'opened should reject');
+  await promise_rejects_dom(
+      t, 'AbortError', wss.closed, 'closed should reject');
 }, 'abort during handshake should work');
 
 promise_test(async t => {
   const controller = new AbortController();
   const wss = new WebSocketStream(ECHOURL, { signal: controller.signal });
-  const { readable, writable } = await wss.connection;
+  const { readable, writable } = await wss.opened;
   controller.abort();
   writable.getWriter().write('connected');
   const { value } = await readable.getReader().read();
diff --git a/websockets/stream/tentative/backpressure-receive.any.js b/websockets/stream/tentative/backpressure-receive.any.js
index cce5bf2a47eb88..236bb2e40fac1a 100644
--- a/websockets/stream/tentative/backpressure-receive.any.js
+++ b/websockets/stream/tentative/backpressure-receive.any.js
@@ -16,7 +16,7 @@ const LARGE_MESSAGE_COUNT = 16;
 // the large message.
 promise_test(async t => {
   const wss = new WebSocketStream(`${BASEURL}/send-backpressure`);
-  const { readable } = await wss.connection;
+  const { readable } = await wss.opened;
   const reader = readable.getReader();
 
   // Create backpressure for 2 seconds.
diff --git a/websockets/stream/tentative/backpressure-send.any.js b/websockets/stream/tentative/backpressure-send.any.js
index c17f1cc2b8b16e..e4a80f6e1c071b 100644
--- a/websockets/stream/tentative/backpressure-send.any.js
+++ b/websockets/stream/tentative/backpressure-send.any.js
@@ -16,7 +16,7 @@ const MESSAGE_SIZE = 8 * 1024 * 1024;
 // times how long it takes to send the first message.
 promise_test(async t => {
   const wss = new WebSocketStream(`${BASEURL}/receive-backpressure`);
-  const { writable } = await wss.connection;
+  const { writable } = await wss.opened;
   const writer = writable.getWriter();
   const start = performance.now();
   await writer.write(new Uint8Array(MESSAGE_SIZE));
diff --git a/websockets/stream/tentative/close.any.js b/websockets/stream/tentative/close.any.js
index 0ed91cc8a64390..2be9034872e909 100644
--- a/websockets/stream/tentative/close.any.js
+++ b/websockets/stream/tentative/close.any.js
@@ -6,7 +6,7 @@
 
 promise_test(async () => {
   const wss = new WebSocketStream(ECHOURL);
-  await wss.connection;
+  await wss.opened;
   wss.close({code: 3456, reason: 'pizza'});
   const { code, reason } = await wss.closed;
   assert_equals(code, 3456, 'code should match');
@@ -15,7 +15,7 @@ promise_test(async () => {
 
 promise_test(async () => {
   const wss = new WebSocketStream(ECHOURL);
-  await wss.connection;
+  await wss.opened;
   wss.close();
   const { code, reason } = await wss.closed;
   assert_equals(code, 1005, 'code should be unset');
@@ -24,7 +24,7 @@ promise_test(async () => {
 
 promise_test(async () => {
   const wss = new WebSocketStream(ECHOURL);
-  await wss.connection;
+  await wss.opened;
   wss.close({});
   const { code, reason } = await wss.closed;
   assert_equals(code, 1005, 'code should be unset');
@@ -33,7 +33,7 @@ promise_test(async () => {
 
 promise_test(async () => {
   const wss = new WebSocketStream(ECHOURL);
-  await wss.connection;
+  await wss.opened;
   wss.close({reason: ''});
   const { code, reason } = await wss.closed;
   assert_equals(code, 1005, 'code should be unset');
@@ -42,7 +42,7 @@ promise_test(async () => {
 
 promise_test(async () => {
   const wss = new WebSocketStream(ECHOURL);
-  await wss.connection;
+  await wss.opened;
   wss.close({reason: 'non-empty'});
   const { code, reason } = await wss.closed;
   assert_equals(code, 1000, 'code should be set');
@@ -51,14 +51,14 @@ promise_test(async () => {
 
 promise_test(async () => {
   const wss = new WebSocketStream(ECHOURL);
-  await wss.connection;
+  await wss.opened;
   assert_throws_js(TypeError, () => wss.close(true),
                    'close should throw a TypeError');
 }, 'close(true) should throw a TypeError');
 
 promise_test(async () => {
   const wss = new WebSocketStream(ECHOURL);
-  await wss.connection;
+  await wss.opened;
   const reason = '.'.repeat(124);
   assert_throws_dom('SyntaxError', () => wss.close({ reason }),
                     'close should throw a TypeError');
@@ -68,16 +68,17 @@ promise_test(t => {
   const wss = new WebSocketStream(ECHOURL);
   wss.close();
   return Promise.all([
-    promise_rejects_dom(t, 'NetworkError', wss.connection,
-                    'connection promise should reject'),
-    promise_rejects_dom(t, 'NetworkError', wss.closed,
-                    'closed promise should reject')]);
+    promise_rejects_dom(
+        t, 'NetworkError', wss.opened, 'opened promise should reject'),
+    promise_rejects_dom(
+        t, 'NetworkError', wss.closed, 'closed promise should reject'),
+  ]);
 }, 'close during handshake should work');
 
 for (const invalidCode of [999, 1001, 2999, 5000]) {
   promise_test(async () => {
     const wss = new WebSocketStream(ECHOURL);
-    await wss.connection;
+    await wss.opened;
     assert_throws_dom('InvalidAccessError', () => wss.close({ code: invalidCode }),
                       'close should throw a TypeError');
   }, `close() with invalid code ${invalidCode} should throw`);
@@ -85,7 +86,7 @@ for (const invalidCode of [999, 1001, 2999, 5000]) {
 
 promise_test(async () => {
   const wss = new WebSocketStream(ECHOURL);
-  const { writable } = await wss.connection;
+  const { writable } = await wss.opened;
   writable.getWriter().close();
   const { code, reason } = await wss.closed;
   assert_equals(code, 1005, 'code should be unset');
@@ -94,7 +95,7 @@ promise_test(async () => {
 
 promise_test(async () => {
   const wss = new WebSocketStream(`${BASEURL}/delayed-passive-close`);
-  const { writable } = await wss.connection;
+  const { writable } = await wss.opened;
   const startTime = performance.now();
   await writable.getWriter().close();
   const elapsed = performance.now() - startTime;
@@ -120,7 +121,7 @@ for (const { method, voweling, stream } of abortOrCancel) {
 
   promise_test(async () => {
     const wss = new WebSocketStream(ECHOURL);
-    const info = await wss.connection;
+    const info = await wss.opened;
     info[stream][method]();
     const { code, reason } = await wss.closed;
     assert_equals(code, 1005, 'code should be unset');
@@ -129,7 +130,7 @@ for (const { method, voweling, stream } of abortOrCancel) {
 
   promise_test(async () => {
     const wss = new WebSocketStream(ECHOURL);
-    const info = await wss.connection;
+    const info = await wss.opened;
     info[stream][method]({ code: 3333 });
     const { code, reason } = await wss.closed;
     assert_equals(code, 3333, 'code should be used');
@@ -138,7 +139,7 @@ for (const { method, voweling, stream } of abortOrCancel) {
 
   promise_test(async () => {
     const wss = new WebSocketStream(ECHOURL);
-    const info = await wss.connection;
+    const info = await wss.opened;
     info[stream][method]({ code: 3456, reason: 'set' });
     const { code, reason } = await wss.closed;
     assert_equals(code, 3456, 'code should be used');
@@ -147,7 +148,7 @@ for (const { method, voweling, stream } of abortOrCancel) {
 
   promise_test(async () => {
     const wss = new WebSocketStream(ECHOURL);
-    const info = await wss.connection;
+    const info = await wss.opened;
     info[stream][method]({ reason: 'specified' });
     const { code, reason } = await wss.closed;
     assert_equals(code, 1005, 'code should be unset');
@@ -156,7 +157,7 @@ for (const { method, voweling, stream } of abortOrCancel) {
 
   promise_test(async () => {
     const wss = new WebSocketStream(ECHOURL);
-    const info = await wss.connection;
+    const info = await wss.opened;
     info[stream][method]({ code: 999 });
     const { code, reason } = await wss.closed;
     assert_equals(code, 1005, 'code should be unset');
@@ -165,7 +166,7 @@ for (const { method, voweling, stream } of abortOrCancel) {
 
   promise_test(async () => {
     const wss = new WebSocketStream(ECHOURL);
-    const info = await wss.connection;
+    const info = await wss.opened;
     info[stream][method]({ code: 1000, reason: 'x'.repeat(128) });
     const { code, reason } = await wss.closed;
     assert_equals(code, 1005, 'code should be unset');
@@ -176,7 +177,7 @@ for (const { method, voweling, stream } of abortOrCancel) {
   // be a valid WebSocket close code.
   promise_test(async () => {
     const wss = new WebSocketStream(ECHOURL);
-    const info = await wss.connection;
+    const info = await wss.opened;
     info[stream][method](new DOMException('yes', 'DataCloneError'));
     const { code, reason } = await wss.closed;
     assert_equals(code, 1005, 'code should be unset');
diff --git a/websockets/stream/tentative/constructor.any.js b/websockets/stream/tentative/constructor.any.js
index 454dd4c09425b0..4d67d81cf288cb 100644
--- a/websockets/stream/tentative/constructor.any.js
+++ b/websockets/stream/tentative/constructor.any.js
@@ -10,25 +10,25 @@ test(() => {
 }, 'constructing with no URL should throw');
 
 test(() => {
-  assert_throws_dom("SyntaxError", () => new WebSocketStream('invalid:'),
-                    "constructor should throw");
+  assert_throws_dom('SyntaxError', () => new WebSocketStream('invalid:'),
+                    'constructor should throw');
 }, 'constructing with an invalid URL should throw');
 
 test(() => {
   assert_throws_js(TypeError,
                 () => new WebSocketStream(`${BASEURL}/`, true),
-                "constructor should throw");
+                'constructor should throw');
 }, 'constructing with invalid options should throw');
 
 test(() => {
   assert_throws_js(TypeError,
                 () => new WebSocketStream(`${BASEURL}/`, {protocols: 'hi'}),
-                "constructor should throw");
+                'constructor should throw');
 }, 'protocols should be required to be a list');
 
 promise_test(async () => {
   const wss = new WebSocketStream(ECHOURL);
-  await wss.connection;
+  await wss.opened;
   assert_equals(wss.url, ECHOURL, 'url should match');
   wss.close();
 }, 'constructing with a valid URL should work');
@@ -36,7 +36,7 @@ promise_test(async () => {
 promise_test(async () => {
   const wss = new WebSocketStream(`${BASEURL}/protocol_array`,
                                   {protocols: ['alpha', 'beta']});
-  const { readable, protocol } = await wss.connection;
+  const { readable, protocol } = await wss.opened;
   assert_equals(protocol, 'alpha', 'protocol should be right');
   const reader = readable.getReader();
   const { value, done } = await reader.read();
@@ -47,15 +47,14 @@ promise_test(async () => {
 promise_test(t => {
   const wss = new WebSocketStream(`${BASEURL}/404`);
   return Promise.all([
-    promise_rejects_dom(t, 'NetworkError', wss.connection,
-                    'connection should reject'),
-    promise_rejects_dom(t, 'NetworkError', wss.closed, 'closed should reject')
+    promise_rejects_dom(t, 'NetworkError', wss.opened, 'opened should reject'),
+    promise_rejects_dom(t, 'NetworkError', wss.closed, 'closed should reject'),
   ]);
 }, 'connection failure should reject the promises');
 
 promise_test(async () => {
   const wss = new WebSocketStream(ECHOURL);
-  const { readable, writable, protocol, extensions} = await wss.connection;
+  const { readable, writable, protocol, extensions} = await wss.opened;
   // Verify that |readable| really is a ReadableStream using the getReader()
   // brand check. If it doesn't throw the test passes.
   ReadableStream.prototype.getReader.call(readable);
@@ -65,4 +64,4 @@ promise_test(async () => {
   assert_equals(typeof protocol, 'string', 'protocol should be a string');
   assert_equals(typeof extensions, 'string', 'extensions should be a string');
   wss.close();
-}, 'wss.connection should resolve to the right types');
+}, 'wss.opened should resolve to the right types');