Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

feat(devtools): chrome devtools + pick locator (#39256)

Simon Knotte07852343d3b
diff --git a/packages/devtools/src/devtools.css b/packages/devtools/src/devtools.css
index ca5346758a..6e88fe1674 100644
--- a/packages/devtools/src/devtools.css
+++ b/packages/devtools/src/devtools.css
@@ -255,6 +255,14 @@
min-height: 0;
}
+.viewport-main {
+ flex: 1;
+ display: flex;
+ flex-direction: column;
+ position: relative;
+ min-width: 0;
+}
+
.screen {
position: relative;
outline: none;
@@ -315,3 +323,58 @@
.capture-hint.visible {
opacity: 1;
}
+
+.capture-hint code {
+ color: var(--accent);
+ font-family: 'SF Mono', 'Cascadia Code', 'Fira Code', 'Consolas', monospace;
+ margin-left: 4px;
+}
+
+.inspector-panel {
+ width: 50%;
+ min-width: 300px;
+ max-width: calc(100% - 320px);
+ display: flex;
+ flex-direction: column;
+ border-left: 1px solid var(--bg-elevated);
+ flex: none;
+ overflow: hidden;
+ position: relative;
+}
+
+.inspector-grip {
+ position: absolute;
+ left: -4px;
+ top: 0;
+ bottom: 0;
+ width: 8px;
+ cursor: col-resize;
+ z-index: 10;
+ touch-action: none;
+}
+
+.inspector-grip::before {
+ content: '';
+ position: absolute;
+ left: 3px;
+ top: 0;
+ bottom: 0;
+ width: 1px;
+ background: var(--bg-elevated);
+}
+
+.inspector-grip:hover::before {
+ background: var(--accent);
+}
+
+.inspector-frame {
+ width: 100%;
+ height: 100%;
+ border: none;
+ background: var(--bg);
+}
+
+.nav-btn.active-toggle {
+ color: var(--accent);
+ background: rgba(138, 180, 248, 0.12);
+}
diff --git a/packages/devtools/src/devtools.tsx b/packages/devtools/src/devtools.tsx
index f4f8719400..5d886e16f3 100644
--- a/packages/devtools/src/devtools.tsx
+++ b/packages/devtools/src/devtools.tsx
@@ -18,6 +18,7 @@ import React from 'react';
import './devtools.css';
import { navigate } from './index';
import { DevToolsClient } from './devtoolsClient';
+import { asLocator } from '@isomorphic/locatorGenerators';
import type { DevToolsClientChannel } from './devtoolsClient';
import type { Tab } from './devtoolsChannel';
@@ -41,21 +42,32 @@ export const DevTools: React.FC<{ wsUrl?: string }> = ({ wsUrl }) => {
const [frameSrc, setFrameSrc] = React.useState('');
const [captured, setCaptured] = React.useState(false);
const [hintVisible, setHintVisible] = React.useState(false);
+ const [showInspector, setShowInspector] = React.useState(false);
+ const [picking, setPicking] = React.useState(false);
+ const [toast, setToast] = React.useState<string | null>(null);
const channelRef = React.useRef<DevToolsClientChannel | null>(null);
const displayRef = React.useRef<HTMLImageElement>(null);
const screenRef = React.useRef<HTMLDivElement>(null);
+ const viewportWrapperRef = React.useRef<HTMLDivElement>(null);
const omniboxRef = React.useRef<HTMLInputElement>(null);
const viewportSizeRef = React.useRef<{ width: number; height: number }>({ width: 0, height: 0 });
const resizedRef = React.useRef(false);
const capturedRef = React.useRef(false);
const moveThrottleRef = React.useRef(0);
+ const pickingRef = React.useRef(false);
+ const toastTimerRef = React.useRef<ReturnType<typeof setTimeout>>(0 as any);
+ const [inspectorWidth, setInspectorWidth] = React.useState<number | undefined>();
// Keep capturedRef in sync with state.
React.useEffect(() => {
capturedRef.current = captured;
}, [captured]);
+ React.useEffect(() => {
+ pickingRef.current = picking;
+ }, [picking]);
+
React.useEffect(() => {
if (!wsUrl)
return;
@@ -69,6 +81,8 @@ export const DevTools: React.FC<{ wsUrl?: string }> = ({ wsUrl }) => {
const selected = params.tabs.find(t => t.selected);
if (selected)
setUrl(selected.url);
+ if (!selected?.inspectorUrl)
+ setShowInspector(false);
});
channel.on('frame', params => {
@@ -80,9 +94,21 @@ export const DevTools: React.FC<{ wsUrl?: string }> = ({ wsUrl }) => {
resizeToFit();
});
+ channel.on('elementPicked', params => {
+ const locator = asLocator('javascript', params.selector);
+ navigator.clipboard?.writeText(locator).catch(() => {});
+ setPicking(false);
+ setToast(locator);
+ clearTimeout(toastTimerRef.current);
+ toastTimerRef.current = setTimeout(() => setToast(null), 3000);
+ });
+
channel.onclose = () => setStatus({ text: 'Disconnected', cls: 'error' });
- return () => channel.close();
+ return () => {
+ clearTimeout(toastTimerRef.current);
+ channel.close();
+ };
}, [wsUrl]);
function resizeToFit() {
@@ -132,28 +158,33 @@ export const DevTools: React.FC<{ wsUrl?: string }> = ({ wsUrl }) => {
};
}
+ const isForwardingInput = () => showInspector || capturedRef.current;
+
+ function sendMouseEvent(method: 'mousedown' | 'mouseup', e: React.MouseEvent) {
+ const { x, y } = imgCoords(e);
+ channelRef.current?.[method]({ x, y, button: BUTTONS[e.button] || 'left' });
+ }
+
function onScreenMouseDown(e: React.MouseEvent) {
e.preventDefault();
screenRef.current?.focus();
- if (!capturedRef.current) {
+ if (!pickingRef.current && !isForwardingInput()) {
setCaptured(true);
setHintVisible(false);
return;
}
- const { x, y } = imgCoords(e);
- channelRef.current?.mousedown({ x, y, button: BUTTONS[e.button] || 'left' });
+ sendMouseEvent('mousedown', e);
}
function onScreenMouseUp(e: React.MouseEvent) {
- if (!capturedRef.current)
+ if (!pickingRef.current && !isForwardingInput())
return;
e.preventDefault();
- const { x, y } = imgCoords(e);
- channelRef.current?.mouseup({ x, y, button: BUTTONS[e.button] || 'left' });
+ sendMouseEvent('mouseup', e);
}
function onScreenMouseMove(e: React.MouseEvent) {
- if (!capturedRef.current)
+ if (!pickingRef.current && !isForwardingInput())
return;
const now = Date.now();
if (now - moveThrottleRef.current < 32)
@@ -164,14 +195,20 @@ export const DevTools: React.FC<{ wsUrl?: string }> = ({ wsUrl }) => {
}
function onScreenWheel(e: React.WheelEvent) {
- if (!capturedRef.current)
+ if (!isForwardingInput())
return;
e.preventDefault();
channelRef.current?.wheel({ deltaX: e.deltaX, deltaY: e.deltaY });
}
function onScreenKeyDown(e: React.KeyboardEvent) {
- if (!capturedRef.current)
+ if (pickingRef.current && e.key === 'Escape') {
+ e.preventDefault();
+ channelRef.current?.cancelPickLocator();
+ setPicking(false);
+ return;
+ }
+ if (!isForwardingInput())
return;
e.preventDefault();
if (e.key === 'Escape' && !(e.metaKey || e.ctrlKey)) {
@@ -182,15 +219,46 @@ export const DevTools: React.FC<{ wsUrl?: string }> = ({ wsUrl }) => {
}
function onScreenKeyUp(e: React.KeyboardEvent) {
- if (!capturedRef.current)
+ if (!isForwardingInput())
return;
e.preventDefault();
channelRef.current?.keyup({ key: e.key });
}
function onScreenBlur() {
- if (capturedRef.current)
- setCaptured(false);
+ setCaptured(false);
+ }
+
+ function onInspectorGripPointerDown(e: React.PointerEvent<HTMLDivElement>) {
+ if (e.button !== 0)
+ return;
+ const wrapperRect = viewportWrapperRef.current?.getBoundingClientRect();
+ if (!wrapperRect)
+ return;
+ e.preventDefault();
+ const grip = e.currentTarget;
+ grip.setPointerCapture(e.pointerId);
+ const minWidth = 300;
+ const maxWidth = Math.max(minWidth, wrapperRect.width - 320);
+ const startX = e.clientX;
+ const startWidth = inspectorWidth ?? wrapperRect.width * 0.5;
+ const onPointerMove = (event: PointerEvent) => {
+ const delta = startX - event.clientX;
+ const nextWidth = Math.max(minWidth, Math.min(maxWidth, startWidth + delta));
+ setInspectorWidth(nextWidth);
+ };
+ const onPointerUp = () => {
+ grip.removeEventListener('pointermove', onPointerMove);
+ grip.removeEventListener('pointerup', onPointerUp);
+ grip.removeEventListener('lostpointercapture', onPointerUp);
+ document.body.style.cursor = '';
+ document.body.style.userSelect = '';
+ };
+ document.body.style.cursor = 'col-resize';
+ document.body.style.userSelect = 'none';
+ grip.addEventListener('pointermove', onPointerMove);
+ grip.addEventListener('pointerup', onPointerUp);
+ grip.addEventListener('lostpointercapture', onPointerUp);
}
function onOmniboxKeyDown(e: React.KeyboardEvent<HTMLInputElement>) {
@@ -204,7 +272,8 @@ export const DevTools: React.FC<{ wsUrl?: string }> = ({ wsUrl }) => {
}
}
- const hasPages = tabs.some(t => t.selected);
+ const selectedTab = tabs.find(t => t.selected);
+ const hasPages = !!selectedTab;
return (<div className='devtools-view'>
{/* Tab bar */}
@@ -282,33 +351,79 @@ export const DevTools: React.FC<{ wsUrl?: string }> = ({ wsUrl }) => {
onKeyDown={onOmniboxKeyDown}
onFocus={e => e.target.select()}
/>
+ <button
+ className={'nav-btn' + (picking ? ' active-toggle' : '')}
+ title={picking ? 'Cancel pick locator' : 'Pick locator'}
+ onClick={() => {
+ if (picking) {
+ channelRef.current?.cancelPickLocator();
+ setPicking(false);
+ } else {
+ channelRef.current?.pickLocator();
+ setPicking(true);
+ }
+ }}
+ >
+ <svg viewBox='0 0 48 48' fill='currentColor'>
+ <path d='M18 42h-7.5c-3 0-4.5-1.5-4.5-4.5v-27C6 7.5 7.5 6 10.5 6h27C42 6 42 10.404 42 10.5V18h-3V9H9v30h9v3Zm27-15-9 6 9 9-3 3-9-9-6 9-6-24 24 6Z'/>
+ </svg>
+ </button>
+ {selectedTab?.inspectorUrl && (
+ <button
+ className={'nav-btn' + (showInspector ? ' active-toggle' : '')}
+ title={showInspector ? 'Hide Chrome DevTools' : 'Show Chrome DevTools'}
+ onClick={() => setShowInspector(!showInspector)}
+ >
+ <svg viewBox='0 0 24 24' fill='none' stroke='currentColor' strokeWidth='2' strokeLinecap='round' strokeLinejoin='round'>
+ <rect x='3' y='3' width='18' height='18' rx='2'/>
+ <line x1='9' y1='3' x2='9' y2='21'/>
+ </svg>
+ </button>
+ )}
</div>
{/* Viewport */}
- <div className='viewport-wrapper'>
- <div
- ref={screenRef}
- className={'screen' + (captured ? ' captured' : '')}
- tabIndex={0}
- style={{ display: hasPages ? '' : 'none' }}
- onMouseDown={onScreenMouseDown}
- onMouseUp={onScreenMouseUp}
- onMouseMove={onScreenMouseMove}
- onWheel={onScreenWheel}
- onKeyDown={onScreenKeyDown}
- onKeyUp={onScreenKeyUp}
- onBlur={onScreenBlur}
- onContextMenu={e => e.preventDefault()}
- onMouseEnter={() => {
- if (!capturedRef.current)
- setHintVisible(true);
- }}
- onMouseLeave={() => setHintVisible(false)}
- >
- <img ref={displayRef} id='display' className='display' alt='screencast' src={frameSrc}/>
- <div className={'capture-hint' + (hintVisible ? ' visible' : '')}>Click to interact &middot; Esc to release</div>
+ <div ref={viewportWrapperRef} className='viewport-wrapper'>
+ <div className='viewport-main'>
+ <div
+ ref={screenRef}
+ className={'screen' + (captured ? ' captured' : '')}
+ tabIndex={0}
+ style={{ display: hasPages ? '' : 'none' }}
+ onMouseDown={onScreenMouseDown}
+ onMouseUp={onScreenMouseUp}
+ onMouseMove={onScreenMouseMove}
+ onWheel={onScreenWheel}
+ onKeyDown={onScreenKeyDown}
+ onKeyUp={onScreenKeyUp}
+ onBlur={onScreenBlur}
+ onContextMenu={e => e.preventDefault()}
+ onMouseEnter={() => {
+ if (!showInspector && !capturedRef.current)
+ setHintVisible(true);
+ }}
+ onMouseLeave={() => setHintVisible(false)}
+ >
+ <img ref={displayRef} id='display' className='display' alt='screencast' src={frameSrc}/>
+ {toast
+ ? <div className='capture-hint visible'>Copied: <code>{toast}</code></div>
+ : picking
+ ? <div className='capture-hint visible'>Click an element to pick its locator</div>
+ : !showInspector && <div className={'capture-hint' + (hintVisible ? ' visible' : '')}>Click to interact &middot; Esc to release</div>
+ }
+ </div>
+ <div id='no-pages' className={'no-pages' + (!hasPages ? ' visible' : '')}>No tabs open</div>
</div>
- <div id='no-pages' className={'no-pages' + (!hasPages ? ' visible' : '')}>No tabs open</div>
+ {showInspector && selectedTab?.inspectorUrl && (
+ <div className='inspector-panel' style={inspectorWidth ? { width: `${inspectorWidth}px` } : undefined}>
+ <div className='inspector-grip' onPointerDown={onInspectorGripPointerDown} />
+ <iframe
+ className='inspector-frame'
+ src={selectedTab.inspectorUrl}
+ title='Chrome DevTools'
+ />
+ </div>
+ )}
</div>
</div>);
};
diff --git a/packages/devtools/src/devtoolsChannel.ts b/packages/devtools/src/devtoolsChannel.ts
index bc940534eb..b2b59156e5 100644
--- a/packages/devtools/src/devtoolsChannel.ts
+++ b/packages/devtools/src/devtoolsChannel.ts
@@ -14,11 +14,12 @@
* limitations under the License.
*/
-export type Tab = { pageId: string; title: string; url: string; selected: boolean };
+export type Tab = { pageId: string; title: string; url: string; selected: boolean; inspectorUrl?: string };
export type DevToolsChannelEvents = {
frame: { data: string; viewportWidth: number; viewportHeight: number };
tabs: { tabs: Tab[] };
+ elementPicked: { selector: string };
};
export interface DevToolsChannel {
@@ -36,6 +37,8 @@ export interface DevToolsChannel {
wheel(params: { deltaX: number; deltaY: number }): Promise<void>;
keydown(params: { key: string }): Promise<void>;
keyup(params: { key: string }): Promise<void>;
+ pickLocator(): Promise<void>;
+ cancelPickLocator(): Promise<void>;
on<K extends keyof DevToolsChannelEvents>(event: K, listener: (params: DevToolsChannelEvents[K]) => void): void;
off<K extends keyof DevToolsChannelEvents>(event: K, listener: (params: DevToolsChannelEvents[K]) => void): void;
diff --git a/packages/playwright-core/src/server/DEPS.list b/packages/playwright-core/src/server/DEPS.list
index 85e6f0a420..011d1a4c3d 100644
--- a/packages/playwright-core/src/server/DEPS.list
+++ b/packages/playwright-core/src/server/DEPS.list
@@ -14,6 +14,9 @@
./trace/recorder/tracing.ts
./utils/
+[devtoolsController.ts]
+./chromium/
+
[playwright.ts]
./android/
./bidi/
diff --git a/packages/playwright-core/src/server/chromium/crBrowser.ts b/packages/playwright-core/src/server/chromium/crBrowser.ts
index af659066a1..d4b3fa6892 100644
--- a/packages/playwright-core/src/server/chromium/crBrowser.ts
+++ b/packages/playwright-core/src/server/chromium/crBrowser.ts
@@ -50,6 +50,7 @@ export class CRBrowser extends Browser {
_devtools?: CRDevTools;
private _version = '';
private _majorVersion = 0;
+ _revision = '';
private _tracingRecording = false;
private _tracingClient: CRSession | undefined;
@@ -68,6 +69,7 @@ export class CRBrowser extends Browser {
await (options as any).__testHookOnConnectToBrowser();
const version = await session.send('Browser.getVersion');
+ browser._revision = version.revision;
browser._version = version.product.substring(version.product.indexOf('/') + 1);
try {
browser._majorVersion = +browser._version.split('.')[0];
diff --git a/packages/playwright-core/src/server/devtoolsController.ts b/packages/playwright-core/src/server/devtoolsController.ts
index 30ada58b4a..f214fbf9cb 100644
--- a/packages/playwright-core/src/server/devtoolsController.ts
+++ b/packages/playwright-core/src/server/devtoolsController.ts
@@ -19,9 +19,15 @@ import { HttpServer } from './utils/httpServer';
import { BrowserContext } from './browserContext';
import { Page } from './page';
import { ProgressController } from './progress';
+import { Recorder, RecorderEvent } from './recorder';
+import { CRPage } from './chromium/crPage';
+import { CDPSession } from './chromium/crConnection';
+import { CRBrowserContext } from './chromium/crBrowser';
import type { RegisteredListener } from '../utils';
import type { Transport } from './utils/httpServer';
+import type { CRBrowser } from './chromium/crBrowser';
+import type { ElementInfo } from '@recorder/recorderTypes';
import type { DevToolsChannel, DevToolsChannelEvents, Tab } from '@devtools/devtoolsChannel';
export class DevToolsController {
@@ -37,7 +43,11 @@ export class DevToolsController {
if (!this._url) {
const guid = createGuid();
this._httpServer = new HttpServer();
- this._httpServer.createWebSocket(() => new DevToolsConnection(this._context), guid);
+ this._httpServer.createWebSocket(url => {
+ if (url.searchParams.has('cdp'))
+ return new CDPConnection(this._context, url.searchParams.get('cdp')!);
+ return new DevToolsConnection(this._context, this._url!);
+ }, guid);
await this._httpServer.start({ port: options.port, host: options.host });
this._url = (this._httpServer.urlPrefix('human-readable') + `/${guid}`).replace('http://', 'ws://');
}
@@ -58,11 +68,15 @@ class DevToolsConnection implements Transport, DevToolsChannel {
private _lastViewportSize: { width: number, height: number } | null = null;
private _pageListeners: RegisteredListener[] = [];
private _contextListeners: RegisteredListener[] = [];
+ private _recorderListeners: RegisteredListener[] = [];
private _context: BrowserContext;
+ private _controllerUrl: string;
+ private _recorder: Recorder | null = null;
private _eventListeners = new Map<string, Set<Function>>();
- constructor(context: BrowserContext) {
+ constructor(context: BrowserContext, controllerUrl: string) {
this._context = context;
+ this._controllerUrl = controllerUrl;
}
// -- IDevToolsConnection: event subscription --
@@ -125,6 +139,7 @@ class DevToolsConnection implements Transport, DevToolsChannel {
}
onclose() {
+ this._cancelPicking();
this._deselectPage();
eventsHelper.removeEventListeners(this._contextListeners);
this._contextListeners = [];
@@ -227,6 +242,14 @@ class DevToolsConnection implements Transport, DevToolsChannel {
await ProgressController.runInternalTask(async progress => { await page.keyboard.up(progress, params.key); });
}
+ async pickLocator() {
+ await this._startPicking();
+ }
+
+ async cancelPickLocator() {
+ this._cancelPicking();
+ }
+
// -- Internal helpers --
private async _selectPage(page: Page) {
@@ -256,6 +279,7 @@ class DevToolsConnection implements Transport, DevToolsChannel {
private _deselectPage() {
if (!this.selectedPage)
return;
+ this._cancelPicking();
eventsHelper.removeEventListeners(this._pageListeners);
this._pageListeners = [];
this.selectedPage.screencast.stopScreencast(this);
@@ -264,6 +288,28 @@ class DevToolsConnection implements Transport, DevToolsChannel {
this._lastViewportSize = null;
}
+ private async _startPicking() {
+ this._cancelPicking();
+ const recorder = await Recorder.forContext(this._context, { omitCallTracking: true });
+ this._recorder = recorder;
+ this._recorderListeners.push(
+ eventsHelper.addEventListener(recorder, RecorderEvent.ElementPicked, (elementInfo: ElementInfo) => {
+ this._emit('elementPicked', { selector: elementInfo.selector });
+ this._cancelPicking();
+ }),
+ );
+ recorder.setMode('inspecting');
+ }
+
+ private _cancelPicking() {
+ eventsHelper.removeEventListeners(this._recorderListeners);
+ this._recorderListeners = [];
+ if (this._recorder) {
+ this._recorder.setMode('none');
+ this._recorder = null;
+ }
+ }
+
private _sendCachedState() {
if (this._lastFrameData && this._lastViewportSize)
this._emit('frame', { data: this._lastFrameData, viewportWidth: this._lastViewportSize.width, viewportHeight: this._lastViewportSize.height });
@@ -280,9 +326,33 @@ class DevToolsConnection implements Transport, DevToolsChannel {
title: await page.mainFrame().title().catch(() => '') || page.mainFrame().url(),
url: page.mainFrame().url(),
selected: page === this.selectedPage,
+ inspectorUrl: this._inspectorUrl(page),
})));
}
+ private _devtoolsURL() {
+ if (this._context._browser.options.wsEndpoint) {
+ const url = new URL('/devtools/', this._context._browser.options.wsEndpoint);
+ if (url.protocol === 'ws:')
+ url.protocol = 'http:';
+ if (url.protocol === 'wss:')
+ url.protocol = 'https:';
+ return url;
+ }
+
+ return new URL(`https://chrome-devtools-frontend.appspot.com/serve_rev/@${(this._context._browser as CRBrowser)._revision}/`);
+ }
+
+ private _inspectorUrl(page: Page): string | undefined {
+ if (!(page.delegate instanceof CRPage))
+ return;
+ const inspector = new URL('./devtools_app.html', this._devtoolsURL());
+ const cdp = new URL(this._controllerUrl);
+ cdp.searchParams.set('cdp', page.guid);
+ inspector.searchParams.set('ws', `${cdp.host}${cdp.pathname}${cdp.search}`);
+ return inspector.toString();
+ }
+
private _sendTabList() {
this._tabList().then(tabs => this._emit('tabs', { tabs }));
}
@@ -294,3 +364,57 @@ class DevToolsConnection implements Transport, DevToolsChannel {
this._emit('frame', { data, viewportWidth, viewportHeight });
}
}
+
+class CDPConnection implements Transport {
+ sendEvent?: (method: string, params: any) => void;
+ close?: () => void;
+
+ private _context: BrowserContext;
+ private _pageId: string;
+ private _rawSession: CDPSession | null = null;
+ private _rawSessionListeners: RegisteredListener[] = [];
+ private _initializePromise: Promise<void> | undefined;
+
+ constructor(context: BrowserContext, pageId: string) {
+ this._context = context;
+ this._pageId = pageId;
+ }
+
+ onconnect() {
+ this._initializePromise = this._initializeRawSession(this._pageId);
+ }
+
+ async dispatch(method: string, params: any): Promise<any> {
+ await this._initializePromise;
+ if (!this._rawSession)
+ throw new Error('CDP session is not initialized');
+ return await this._rawSession.send(method, params);
+ }
+
+ onclose() {
+ eventsHelper.removeEventListeners(this._rawSessionListeners);
+ if (this._rawSession)
+ void this._rawSession.detach().catch(() => {});
+ this._rawSession = null;
+ this._initializePromise = undefined;
+ }
+
+ private async _initializeRawSession(pageId: string) {
+ const page = this._context.pages().find(p => p.guid === pageId);
+ if (!page) {
+ this.close?.();
+ return;
+ }
+ const crContext = this._context as CRBrowserContext;
+ const session = await crContext.newCDPSession(page);
+ this._rawSession = session;
+ this._rawSessionListeners = [
+ eventsHelper.addEventListener(session, CDPSession.Events.Event, (event: { method: string, params?: any }) => {
+ this.sendEvent?.(event.method, event.params);
+ }),
+ eventsHelper.addEventListener(session, CDPSession.Events.Closed, () => {
+ this.close?.();
+ }),
+ ];
+ }
+}
diff --git a/packages/playwright-core/src/server/utils/httpServer.ts b/packages/playwright-core/src/server/utils/httpServer.ts
index c001b0f0ad..e75fcce341 100644
--- a/packages/playwright-core/src/server/utils/httpServer.ts
+++ b/packages/playwright-core/src/server/utils/httpServer.ts
@@ -63,12 +63,13 @@ export class HttpServer {
return this._port;
}
- createWebSocket(transportFactory: () => Transport, guid?: string) {
+ createWebSocket(transportFactory: (url: URL) => Transport, guid?: string) {
assert(!this._wsGuid, 'can only create one main websocket transport per server');
this._wsGuid = guid || createGuid();
const wss = new wsServer({ server: this._server, path: '/' + this._wsGuid });
- wss.on('connection', ws => {
- const transport = transportFactory();
+ wss.on('connection', (ws, request) => {
+ const url = new URL(request.url ?? '/', 'http://localhost');
+ const transport = transportFactory(url);
transport.sendEvent = (method, params) => ws.send(JSON.stringify({ method, params }));
transport.close = () => ws.close();
transport.onconnect();