Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.
TypeScript automationchromechromiume2e-testingelectronend-to-end-testingfirefoxjavascriptplaywrighttesttest-automationtestingtesting-toolswebwebkit
fix(webview): handle cross-origin process swap (#41024)
Yury Semikhatsky08a37f29f421
diff --git a/.claude/skills/playwright-dev/SKILL.md b/.claude/skills/playwright-dev/SKILL.mdindex 8a9e0ca5f8..56f7165fbd 100644--- a/.claude/skills/playwright-dev/SKILL.md+++ b/.claude/skills/playwright-dev/SKILL.md@@ -14,5 +14,6 @@ See [CLAUDE.md](../../../CLAUDE.md) for monorepo structure, build/test/lint comm- [MCP Tools and CLI Commands](tools.md) — add MCP tools, CLI commands, config options- [Vendor Dependencies & Bundling](vendor.md) — utilsBundle, coreBundle, babelBundle; adding vendored npm packages; DEPS.list; `check_deps`- [Updating WebKit Safari Version](webkit-safari-version.md) — update the Safari version string in the WebKit user-agent+- [WebView (iOS Safari) Backend](webview.md) — `webkit/webview/` against stock Mobile Safari; provisional-target pause/resume; what's upstream vs Playwright patches; local + CI test setup- [Bisecting Across Published Versions](bisect-published-versions.md) — reproduce regressions side-by-side from npm and diff `node_modules/playwright/lib/` between versions- [Dashboard](dashboard.md) - the UI powering the "playwright cli show" command, and how to work on itdiff --git a/.claude/skills/playwright-dev/webview.md b/.claude/skills/playwright-dev/webview.mdnew file mode 100644index 0000000000..680cf0100f--- /dev/null+++ b/.claude/skills/playwright-dev/webview.md@@ -0,0 +1,149 @@+# WebView (iOS Safari) Backend Reference++Notes for developing the **stock-Mobile-Safari** backend in+[packages/playwright-core/src/server/webkit/webview/](../../../packages/playwright-core/src/server/webkit/webview/).+The regular WebKit backend one level up (`webkit/`) runs against a+Playwright-patched WebKit build; the `webview/` folder targets unmodified+Safari on real iOS/iPadOS or the iOS Simulator over the standard Web Inspector+Protocol.++## What is and isn't available++Stock Mobile Safari only exposes the upstream Web Inspector Protocol. Anything+Playwright added to its forked WebKit is not available here.++**Available** — methods/events in `Source/JavaScriptCore/inspector/protocol/*.json`+on `browser_upstream/main`:++```bash+git -C ~/webkit show browser_upstream/main:Source/JavaScriptCore/inspector/protocol/<Domain>.json+```++**Not available** — anything added by the Playwright WebKit patches:++```bash+ls ~/playwright-browsers/browser_patches/webkit/patches/ # bootstrap.diff lives here+```++Quick provenance check for a symbol — in `~/webkit`:++```bash+git log --all -S "<symbol>" -- <path>+```++If every hit is a `chore(webkit): bootstrap build` commit, it's a Playwright+patch. Some traps where the upstream name overlaps with a Playwright-only+helper of similar intent:++- `Target.setPauseOnStart` / `Target.resume` (**upstream**, gates loading of+ provisional process-swap targets) vs `PageInspectorController::pauseOnStart`+ / `resumeIfPausedInNewWindow` (**Playwright patch**, for `window.open`+ popups). They sound the same; they aren't.+- `Playwright.*` domain (cookies, navigate, all global controls) — entirely+ Playwright. Use stock equivalents on the page session (e.g. `Page.getCookies`).+- `Network.continueWithAuth`, intercepted-response body access via Network —+ Playwright extensions.++## Architecture++This backend deliberately mirrors the regular WebKit backend one level up+(`wkConnection.ts` / `wkPage.ts` / `wkProvisionalPage.ts`). When in doubt,+read the WK equivalent — the WV class should look almost the same. The+`outerSession` is the WV analogue of WK's page-proxy session.++```+WebSocketTransport (ws://localhost:9222/devtools/page/<n>, via ios_webkit_debug_proxy)+ → WVConnection — dumb transport; owns only outerSession+ → WVConnection.outerSession (sessionId "") — Target.sendMessageToTarget bridge+ → WVPage — owns per-target WVSessions, routes+ Target.dispatchMessageFromTarget, manages swaps+ → _session (current) + WVProvisionalPage (during a swap)+ → WVExecutionContext, WVWorkers, RawKeyboard/Mouse/Touchscreen+ (all hold a session reference, all have setSession() for swap)+```++`WVConnection` is intentionally minimal: it pumps the transport into+`outerSession` and back. `WVPage` creates the per-target `WVSession`s+(`_createSession`), routes `Target.dispatchMessageFromTarget` by `targetId` to+either `_session` or `_provisionalPage._session`, and handles+`Target.targetCreated/targetDestroyed/didCommitProvisionalTarget` — exactly+like `WKPage`. `WVPage` is constructed with the outer session (not a target+session); `_session` starts undefined and is bound on the first+`Target.targetCreated` via `_setSession`. `WVBrowser._attachTab` awaits+`page.waitForInitialized()` (resolves after the first target is reported as+new) instead of waiting on the connection.++## Process swap / provisional targets++Cross-origin navigation in an existing tab can make Mobile Safari spawn a new+process. The protocol sequence is:++```+Target.targetCreated targetInfo:{ isProvisional:true, isPaused:true }+... events on the provisional target during the navigation ...+Target.didCommitProvisionalTarget oldTargetId, newTargetId+Target.targetDestroyed oldTargetId+```++Handling mirrors WK — `WVProvisionalPage` ≈ `WKProvisionalPage`, swapped in by+`WVPage._onDidCommitProvisionalTarget`. The one essential trick:+`Target.setPauseOnStart` (sent in `WVBrowser._attachTab`) makes provisional+targets arrive `isPaused`, so `WVPage` can set up interception / bootstrap+before resuming them with `Target.resume`; otherwise the new process races+ahead and `page.route(...)` never fires.++Not to be confused with the **popup-pause** path (`window.open`), which is a+Playwright patch (`PageInspectorController::pauseOnStart`) with no stock-Safari+equivalent.++## Test infrastructure++```+tests/webview/+ playwright.config.ts — single project "webkit-webview-page", runs tests/page/+ webviewTest.ts — fixture: discovers tab via ios_webkit_debug_proxy /json,+ resets Mobile Safari between tests+ expectations/+ webkit-webview-page.txt — `<test path> › <name> [fail|flaky|timeout|skip]`+ expectationUtil.ts — loader + skip-decision logic+```++`[fail]` entries cause `it.skip()` to fire before the test body runs — so a+formerly-failing test that now passes won't be flagged automatically, you have+to remove the line and re-run. The marker also has prefix-match semantics for+`it.step` children.++### Running locally++```bash+./utils/run_webview_tests.sh # ensures ios_webkit_debug_proxy is up on 9222+npm run wvtest -- -g "<test title>" # single test+npm run wvtest -- tests/page/foo.spec.ts+DEBUG=pw:protocol npm run wvtest -- -g "<title>" > /tmp/log 2>&1+```++The simulator needs to be booted with one Mobile Safari tab. The script's only+job is keeping a single+`ios_webkit_debug_proxy -F -d -s unix:<socket> -c null:9221,:9222-9322` alive;+everything else is done by the fixture.++### Common local pitfalls++- **Multiple `ios_webkit_debug_proxy` processes** — every protocol event is+ delivered through each instance, so debug logs show events duplicated and+ some tests flake. `pgrep -lf ios_webkit_debug_proxy` and clean up.+- **Chrome bound to `127.0.0.1:9222`** — Chrome's `--remote-debugging-port=9222`+ shadows iwdp's `*:9222` listener for traffic addressed to `localhost`.+ Kill the Chrome instance (`lsof -nP -iTCP -sTCP:LISTEN | grep 9222`).+- **Stale launchd socket** — `lsof -aUc launchd_sim` should show+ `com.apple.webinspectord_sim.socket` for the currently booted simulator. If+ iwdp was started against an older `launchd_sim` socket path it will silently+ serve nothing.++## CI++[.github/workflows/tests_webview_simulator.yml](../../../.github/workflows/tests_webview_simulator.yml)+runs the same suite on `macos-15` (booted iOS Simulator ++`brew install ios-webkit-debug-proxy`). Triggers: `workflow_dispatch`, and+`pull_request` only when paths under `tests/webview/**`, the `webview/` source+folder, or the workflow file itself change.diff --git a/packages/playwright-core/src/server/webkit/webview/wvBrowser.ts b/packages/playwright-core/src/server/webkit/webview/wvBrowser.tsindex c5f39292c2..3b646b1ae9 100644--- a/packages/playwright-core/src/server/webkit/webview/wvBrowser.ts+++ b/packages/playwright-core/src/server/webkit/webview/wvBrowser.ts@@ -171,12 +171,13 @@ export class WVBrowser extends Browser {private async _attachTab(pageId: string, tab: ProxyTab): Promise<void> {const transport = await WebSocketTransport.connect(undefined, tab.webSocketDebuggerUrl, { headers: this._headers, followRedirects: true });const connection = new WVConnection(transport, () => this._detachTab(pageId), this.options.protocolLogger, this.options.browserLogsCollector);- const session = await connection.waitForBrowserSession();+ // TODO: handle this as RDP connection parameter.+ connection.outerSession.sendMayFail('Target.setPauseOnStart', { pauseOnStart: true });const dialogEndpoint = this._dialogBridge.endpointFor(pageId);- const page = new WVPage(this._context, session, dialogEndpoint);+ const page = new WVPage(this._context, connection.outerSession, dialogEndpoint);this._dialogBridge.registerTab(pageId, req => page.onBridgeDialog(req));this._tabs.set(pageId, { pageId, transport, connection, page });- await page.initialize();+ await page.waitForInitialized();}private _detachTab(pageId: string): void {@@ -240,7 +241,7 @@ export class WVBrowserContext extends BrowserContext {}async doGetCookies(urls: string[]): Promise<channels.NetworkCookie[]> {- throw new Error('Method not implemented.');+ return [];}async addCookies(cookies: channels.SetNetworkCookie[]) {diff --git a/packages/playwright-core/src/server/webkit/webview/wvConnection.ts b/packages/playwright-core/src/server/webkit/webview/wvConnection.tsindex 30515bbbc8..94a4a141a4 100644--- a/packages/playwright-core/src/server/webkit/webview/wvConnection.ts+++ b/packages/playwright-core/src/server/webkit/webview/wvConnection.ts@@ -35,9 +35,6 @@ export class WVConnection {private _lastId = 0;private _closed = false;readonly outerSession: WVSession;- private _browserSession: WVSession | undefined;- private readonly _browserSessionPromise: Promise<WVSession>;- private _resolveBrowserSession!: (session: WVSession) => void;constructor(transport: ConnectionTransport, onDisconnect: () => void, protocolLogger: ProtocolLogger, browserLogsCollector: RecentLogsCollector) {this._transport = transport;@@ -47,51 +44,12 @@ export class WVConnection {this.outerSession = new WVSession(this, '', (message: any) => {this.rawSend(message);});- this._browserSessionPromise = new Promise<WVSession>(resolve => {- this._resolveBrowserSession = resolve;- });-- this.outerSession.on('Target.targetCreated', this._onTargetCreated.bind(this));- this.outerSession.on('Target.targetDestroyed', this._onTargetDestroyed.bind(this));- this.outerSession.on('Target.dispatchMessageFromTarget', this._onDispatchMessageFromTarget.bind(this));this._transport.onmessage = this._dispatchMessage.bind(this);// onclose should be set last, since it can be immediately called.this._transport.onclose = this._onClose.bind(this);}- async waitForBrowserSession(): Promise<WVSession> {- return this._browserSessionPromise;- }-- private _onTargetCreated(event: Protocol.Target.targetCreatedPayload) {- if (this._browserSession)- return;- const targetId = event.targetInfo.targetId;- const session = new WVSession(this, targetId, (message: any) => {- this.outerSession.send('Target.sendMessageToTarget', {- targetId,- message: JSON.stringify(message),- }).catch(e => {- session.dispatchMessage({ id: message.id, error: { message: e.message } });- });- });- this._browserSession = session;- this._resolveBrowserSession(session);- }-- private _onTargetDestroyed(event: Protocol.Target.targetDestroyedPayload) {- if (this._browserSession && this._browserSession.sessionId === event.targetId) {- this._browserSession.dispose();- this._browserSession = undefined;- }- }-- private _onDispatchMessageFromTarget(event: Protocol.Target.dispatchMessageFromTargetPayload) {- if (this._browserSession && this._browserSession.sessionId === event.targetId)- this._browserSession.dispatchMessage(JSON.parse(event.message));- }-nextMessageId(): number {return ++this._lastId;}@@ -112,8 +70,6 @@ export class WVConnection {this._transport.onclose = undefined;this._browserDisconnectedLogs = helper.formatBrowserLogs(this._browserLogsCollector.recentLogs(), reason);this.outerSession.dispose();- if (this._browserSession)- this._browserSession.dispose();this._onDisconnect();}diff --git a/packages/playwright-core/src/server/webkit/webview/wvInput.ts b/packages/playwright-core/src/server/webkit/webview/wvInput.tsindex 431dc3fe1b..afce325482 100644--- a/packages/playwright-core/src/server/webkit/webview/wvInput.ts+++ b/packages/playwright-core/src/server/webkit/webview/wvInput.ts@@ -64,9 +64,9 @@ function toButtonsMask(buttons: Set<types.MouseButton>): number {}export class RawKeyboardImpl implements input.RawKeyboard {- private _session: WVSession;+ private _session: WVSession | undefined;- constructor(session: WVSession) {+ setSession(session: WVSession) {this._session = session;}@@ -116,9 +116,9 @@ export class RawKeyboardImpl implements input.RawKeyboard {}export class RawMouseImpl implements input.RawMouse {- private _session: WVSession;+ private _session: WVSession | undefined;- constructor(session: WVSession) {+ setSession(session: WVSession) {this._session = session;}@@ -173,9 +173,9 @@ export class RawMouseImpl implements input.RawMouse {}export class RawTouchscreenImpl implements input.RawTouchscreen {- private _session: WVSession;+ private _session: WVSession | undefined;- constructor(session: WVSession) {+ setSession(session: WVSession) {this._session = session;}@@ -199,6 +199,8 @@ export class RawTouchscreenImpl implements input.RawTouchscreen {}}-async function evalInPage(progress: Progress, session: WVSession, expression: string): Promise<void> {+async function evalInPage(progress: Progress, session: WVSession | undefined, expression: string): Promise<void> {+ if (!session)+ throw new Error('Page is not initialized');await progress.race(session.send('Runtime.evaluate', { expression, returnByValue: true } as any));}diff --git a/packages/playwright-core/src/server/webkit/webview/wvPage.ts b/packages/playwright-core/src/server/webkit/webview/wvPage.tsindex 30f61d3469..3375aa9067 100644--- a/packages/playwright-core/src/server/webkit/webview/wvPage.ts+++ b/packages/playwright-core/src/server/webkit/webview/wvPage.ts@@ -17,6 +17,7 @@import { PNG } from 'pngjs';import jpegjs from 'jpeg-js';+import { assert } from '@isomorphic/assert';import { headersArrayToObject } from '@isomorphic/headers';import { splitErrorMessage } from '@isomorphic/stackTrace';import { debugLogger } from '@utils/debugLogger';@@ -33,6 +34,7 @@ import { createHandle, WVExecutionContext } from './wvExecutionContext';import { RawKeyboardImpl, RawMouseImpl, RawTouchscreenImpl } from './wvInput';import { WVWorkers } from './wvWorkers';import { WVInterceptableRequest, WVRouteImpl } from './wvInterceptableRequest';+import { WVProvisionalPage } from './wvProvisionalPage';import type { Protocol } from './protocol';import type { WVBrowserContext } from './wvBrowser';@@ -48,41 +50,56 @@ export class WVPage implements PageDelegate {readonly rawMouse: RawMouseImpl;readonly rawKeyboard: RawKeyboardImpl;readonly rawTouchscreen: RawTouchscreenImpl;- _session: WVSession;- private _targetIdToFrameSession = new Map<string, WKFrame>();+ private _session!: WVSession;+ private readonly _outerSession: WVSession;+ private _provisionalPage: WVProvisionalPage | null = null;readonly _page: Page;private readonly _requestIdToRequest = new Map<string, WVInterceptableRequest>();private readonly _requestIdToRequestWillBeSentEvent = new Map<string, Protocol.Network.requestWillBeSentPayload>();- private readonly _workers: WVWorkers;+ private _workers: WVWorkers;private readonly _contextIdToContext: Map<number, dom.FrameExecutionContext>;private _sessionListeners: RegisteredListener[] = [];+ private _eventListeners: RegisteredListener[];+ private _pendingMainFrameLoaderResolvers = new Map<string, (loaderId: string) => void>();readonly _browserContext: WVBrowserContext;private _firstNonInitialNavigationCommittedPromise: Promise<void>;private _firstNonInitialNavigationCommittedFulfill = () => {};_firstNonInitialNavigationCommittedReject = (e: Error) => {};+ private _initializedPromise: Promise<void>;+ private _initializedFulfill = () => {};private _lastConsoleMessage: { derivedType: string, text: string, handles: JSHandle[]; count: number, location: types.ConsoleMessageLocation; } | null = null;private readonly _requestIdToResponseReceivedPayloadEvent = new Map<string, Protocol.Network.responseReceivedPayload>();private readonly _dialogEndpoint: string | undefined;- constructor(browserContext: WVBrowserContext, session: WVSession, dialogEndpoint?: string) {- this._session = session;+ constructor(browserContext: WVBrowserContext, outerSession: WVSession, dialogEndpoint?: string) {+ this._outerSession = outerSession;this._dialogEndpoint = dialogEndpoint;- this.rawKeyboard = new RawKeyboardImpl(session);- this.rawMouse = new RawMouseImpl(session);- this.rawTouchscreen = new RawTouchscreenImpl(session);+ this.rawKeyboard = new RawKeyboardImpl();+ this.rawMouse = new RawMouseImpl();+ this.rawTouchscreen = new RawTouchscreenImpl();this._contextIdToContext = new Map();this._page = new Page(this, browserContext);- this._workers = new WVWorkers(this._page, session);+ this._workers = new WVWorkers(this._page, outerSession);this._browserContext = browserContext;this._page.on(Page.Events.FrameDetached, (frame: frames.Frame) => this._removeContextsForFrame(frame, false));+ this._eventListeners = [+ eventsHelper.addEventListener(outerSession, 'Target.targetCreated', this._onTargetCreated.bind(this)),+ eventsHelper.addEventListener(outerSession, 'Target.targetDestroyed', this._onTargetDestroyed.bind(this)),+ eventsHelper.addEventListener(outerSession, 'Target.dispatchMessageFromTarget', this._onDispatchMessageFromTarget.bind(this)),+ eventsHelper.addEventListener(outerSession, 'Target.didCommitProvisionalTarget', this._onDidCommitProvisionalTarget.bind(this)),+ ];this._firstNonInitialNavigationCommittedPromise = new Promise((f, r) => {this._firstNonInitialNavigationCommittedFulfill = f;this._firstNonInitialNavigationCommittedReject = r;});// Avoid unhandled rejection on disconnect in the middle of initialization.this._firstNonInitialNavigationCommittedPromise.catch(() => {});- this._addSessionListeners();+ this._initializedPromise = new Promise(f => { this._initializedFulfill = f; });+ }++ waitForInitialized(): Promise<void> {+ return this._initializedPromise;}updateEmulatedViewportSize(preserveWindowBoundaries?: boolean): Promise<void> {@@ -125,39 +142,131 @@ export class WVPage implements PageDelegate {coverage?: (() => any) | undefined;cspErrorsAsynchronousForInlineScripts?: boolean | undefined;- _setSession(session: WVSession) {+ private _setSession(session: WVSession) {eventsHelper.removeEventListeners(this._sessionListeners);this._session = session;+ this.rawKeyboard.setSession(session);+ this.rawMouse.setSession(session);+ this.rawTouchscreen.setSession(session);+ this._workers.setSession(session);+ this._addSessionListeners();}- async initialize(): Promise<void> {- let pageOrError: Page | Error;- try {- const [, frameTree] = await Promise.all([- this._session.send('Page.enable'),- this._session.send('Page.getResourceTree'),- ] as const);- this._handleFrameTree(frameTree.frameTree);+ // This method is called for provisional targets as well. The session passed as the parameter+ // may be different from the current session and may be destroyed without becoming current.+ async _initializeSession(session: WVSession, provisional: boolean, resourceTreeHandler: (r: Protocol.Page.getResourceTreeReturnValue) => void): Promise<void> {+ await this._initializeSessionMayThrow(session, resourceTreeHandler).catch(e => {+ // Provisional session can be disposed at any time, for example due to new navigation initiating+ // a new provisional page.+ if (provisional && session.isDisposed())+ return;+ // Swallow initialization errors due to newer target swap in,+ // since we will reinitialize again.+ if (this._session === session)+ throw e;+ });+ }++ private async _initializeSessionMayThrow(session: WVSession, resourceTreeHandler: (r: Protocol.Page.getResourceTreeReturnValue) => void): Promise<void> {+ const [, frameTree] = await Promise.all([+ session.send('Page.enable'),+ session.send('Page.getResourceTree'),+ ] as const);+ resourceTreeHandler(frameTree);+ await Promise.all([+ session.send('Runtime.enable'),+ session.sendMayFail('Network.enable'),+ session.sendMayFail('Console.enable'),+ session.sendMayFail('Page.setBootstrapScript', { source: this._calculateBootstrapScript() }),+ session.sendMayFail('Runtime.evaluate', { expression: saveGlobalsSnapshotSource, returnByValue: true } as any),+ ]);+ if (this._page.needsRequestInterception()) {await Promise.all([- this._session.send('Runtime.enable'),- this._session.sendMayFail('Network.enable'),- this._session.sendMayFail('Console.enable'),- this._updateBootstrapScript(),- this._session.sendMayFail('Runtime.evaluate', { expression: saveGlobalsSnapshotSource, returnByValue: true } as any),+ session.sendMayFail('Network.setInterceptionEnabled', { enabled: true }),+ session.sendMayFail('Network.setResourceCachingDisabled', { disabled: true }),+ session.sendMayFail('Network.addInterception', { url: '.*', stage: 'request', isRegex: true }),]);- // Inject the dialog bridge into the currently-loaded document too —- // bootstrap only applies to future navigations.- if (this._dialogEndpoint) {- await this._session.sendMayFail('Runtime.evaluate', {- expression: dialogBridgeSource(this._dialogEndpoint),- returnByValue: true,- } as any);+ }+ // Inject the dialog bridge into the currently-loaded document too —+ // bootstrap only applies to future navigations.+ if (this._dialogEndpoint) {+ await session.sendMayFail('Runtime.evaluate', {+ expression: dialogBridgeSource(this._dialogEndpoint),+ returnByValue: true,+ } as any);+ }+ }++ private _createSession(targetId: string): WVSession {+ const session: WVSession = new WVSession(this._outerSession.connection, targetId, (message: any) => {+ this._outerSession.send('Target.sendMessageToTarget', {+ targetId,+ message: JSON.stringify(message),+ }).catch(e => {+ session.dispatchMessage({ id: message.id, error: { message: e.message } });+ });+ });+ return session;+ }++ private async _onTargetCreated(event: Protocol.Target.targetCreatedPayload) {+ const { targetInfo } = event;+ assert(targetInfo.type === 'page', 'Only page targets are expected in WebView, received: ' + targetInfo.type);+ const session = this._createSession(targetInfo.targetId);+ if (!targetInfo.isProvisional) {+ let pageOrError: Page | Error;+ try {+ this._setSession(session);+ await this._initializeSession(session, false, ({ frameTree }) => this._handleFrameTree(frameTree));+ pageOrError = this._page;+ } catch (e) {+ pageOrError = e as Error;+ }+ if (targetInfo.isPaused)+ this._outerSession.sendMayFail('Target.resume', { targetId: targetInfo.targetId });+ await this._page.reportAsNew(undefined, pageOrError instanceof Page ? undefined : pageOrError);+ this._initializedFulfill();+ } else {+ assert(!this._provisionalPage);+ this._provisionalPage = new WVProvisionalPage(session, this);+ if (targetInfo.isPaused) {+ this._provisionalPage.initializationPromise.then(() => {+ this._outerSession.sendMayFail('Target.resume', { targetId: targetInfo.targetId });+ });}- pageOrError = this._page;- } catch (e) {- pageOrError = e as Error;}- await this._page.reportAsNew(undefined, pageOrError instanceof Page ? undefined : pageOrError);+ }++ private _onDispatchMessageFromTarget(event: Protocol.Target.dispatchMessageFromTargetPayload) {+ const { targetId, message } = event;+ if (this._provisionalPage && this._provisionalPage._session.sessionId === targetId)+ this._provisionalPage._session.dispatchMessage(JSON.parse(message));+ else if (this._session && this._session.sessionId === targetId)+ this._session.dispatchMessage(JSON.parse(message));+ }++ private _onDidCommitProvisionalTarget(event: Protocol.Target.didCommitProvisionalTargetPayload) {+ const { oldTargetId, newTargetId } = event;+ assert(this._provisionalPage);+ assert(this._provisionalPage._session.sessionId === newTargetId, 'Unknown new target: ' + newTargetId);+ assert(this._session.sessionId === oldTargetId, 'Unknown old target: ' + oldTargetId);+ const newSession = this._provisionalPage._session;+ this._provisionalPage.commit();+ this._provisionalPage.dispose();+ this._provisionalPage = null;+ this._setSession(newSession);+ }++ private _onTargetDestroyed(event: Protocol.Target.targetDestroyedPayload) {+ const { targetId } = event;+ if (this._provisionalPage && this._provisionalPage._session.sessionId === targetId) {+ this._provisionalPage._session.dispose();+ this._provisionalPage.dispose();+ this._provisionalPage = null;+ } else if (this._session && this._session.sessionId === targetId) {+ this._session.dispose();+ eventsHelper.removeEventListeners(this._sessionListeners);+ }}async onBridgeDialog(req: { type: 'alert' | 'confirm' | 'prompt'; message: string; defaultValue: string }): Promise<{ accept: boolean; promptText?: string }> {@@ -174,35 +283,45 @@ export class WVPage implements PageDelegate {didClose() {eventsHelper.removeEventListeners(this._sessionListeners);+ eventsHelper.removeEventListeners(this._eventListeners);if (this._session)this._session.dispose();+ if (this._provisionalPage) {+ this._provisionalPage._session.dispose();+ this._provisionalPage.dispose();+ this._provisionalPage = null;+ }this._firstNonInitialNavigationCommittedReject(new TargetClosedError(this._page.closeReason()));this._page._didClose();}private _addSessionListeners() {- this._sessionListeners = [- eventsHelper.addEventListener(this._session, 'Page.frameNavigated', event => this._onFrameNavigated(event.frame, false)),- eventsHelper.addEventListener(this._session, 'Page.navigatedWithinDocument', event => this._onFrameNavigatedWithinDocument(event.frameId, event.url)),- eventsHelper.addEventListener(this._session, 'Page.frameAttached', event => this._onFrameAttached(event.frameId, event.parentFrameId)),- eventsHelper.addEventListener(this._session, 'Page.frameDetached', event => this._onFrameDetached(event.frameId)),- eventsHelper.addEventListener(this._session, 'Page.loadEventFired', event => this._page.frameManager.frameLifecycleEvent(this._page.mainFrame()._id, 'load')),- eventsHelper.addEventListener(this._session, 'Page.domContentEventFired', event => this._page.frameManager.frameLifecycleEvent(this._page.mainFrame()._id, 'domcontentloaded')),- eventsHelper.addEventListener(this._session, 'Runtime.executionContextCreated', event => this._onExecutionContextCreated(event.context)),- eventsHelper.addEventListener(this._session, 'Console.messageAdded', event => this._onConsoleMessage(event)),- eventsHelper.addEventListener(this._session, 'Console.messageRepeatCountUpdated', event => this._onConsoleRepeatCountUpdated(event)),- eventsHelper.addEventListener(this._session, 'Network.requestWillBeSent', e => this._onRequestWillBeSent(this._session, e)),- eventsHelper.addEventListener(this._session, 'Network.requestIntercepted', e => this._onRequestIntercepted(this._session, e)),- eventsHelper.addEventListener(this._session, 'Network.responseReceived', e => this._onResponseReceived(this._session, e)),- eventsHelper.addEventListener(this._session, 'Network.loadingFinished', e => this._onLoadingFinished(e)),- eventsHelper.addEventListener(this._session, 'Network.loadingFailed', e => this._onLoadingFailed(this._session, e)),- eventsHelper.addEventListener(this._session, 'Network.webSocketCreated', e => this._page.frameManager.onWebSocketCreated(e.requestId, e.url)),- eventsHelper.addEventListener(this._session, 'Network.webSocketWillSendHandshakeRequest', e => this._page.frameManager.onWebSocketRequest(e.requestId)),- eventsHelper.addEventListener(this._session, 'Network.webSocketHandshakeResponseReceived', e => this._page.frameManager.onWebSocketResponse(e.requestId, e.response.status, e.response.statusText)),- eventsHelper.addEventListener(this._session, 'Network.webSocketFrameSent', e => e.response.payloadData && this._page.frameManager.onWebSocketFrameSent(e.requestId, e.response.opcode, e.response.payloadData)),- eventsHelper.addEventListener(this._session, 'Network.webSocketFrameReceived', e => e.response.payloadData && this._page.frameManager.webSocketFrameReceived(e.requestId, e.response.opcode, e.response.payloadData)),- eventsHelper.addEventListener(this._session, 'Network.webSocketClosed', e => this._page.frameManager.webSocketClosed(e.requestId)),- eventsHelper.addEventListener(this._session, 'Network.webSocketFrameError', e => this._page.frameManager.webSocketError(e.requestId, e.errorMessage)),+ this._sessionListeners = this._buildSessionListeners(this._session);+ }++ private _buildSessionListeners(session: WVSession): RegisteredListener[] {+ return [+ eventsHelper.addEventListener(session, 'Page.frameNavigated', event => this._onFrameNavigated(event.frame, false)),+ eventsHelper.addEventListener(session, 'Page.navigatedWithinDocument', event => this._onFrameNavigatedWithinDocument(event.frameId, event.url)),+ eventsHelper.addEventListener(session, 'Page.frameAttached', event => this._onFrameAttached(event.frameId, event.parentFrameId)),+ eventsHelper.addEventListener(session, 'Page.frameDetached', event => this._onFrameDetached(event.frameId)),+ eventsHelper.addEventListener(session, 'Page.loadEventFired', event => this._page.frameManager.frameLifecycleEvent(this._page.mainFrame()._id, 'load')),+ eventsHelper.addEventListener(session, 'Page.domContentEventFired', event => this._page.frameManager.frameLifecycleEvent(this._page.mainFrame()._id, 'domcontentloaded')),+ eventsHelper.addEventListener(session, 'Runtime.executionContextCreated', event => this._onExecutionContextCreated(event.context)),+ eventsHelper.addEventListener(session, 'Console.messageAdded', event => this._onConsoleMessage(event)),+ eventsHelper.addEventListener(session, 'Console.messageRepeatCountUpdated', event => this._onConsoleRepeatCountUpdated(event)),+ eventsHelper.addEventListener(session, 'Network.requestWillBeSent', e => this._onRequestWillBeSent(session, e)),+ eventsHelper.addEventListener(session, 'Network.requestIntercepted', e => this._onRequestIntercepted(session, e)),+ eventsHelper.addEventListener(session, 'Network.responseReceived', e => this._onResponseReceived(session, e)),+ eventsHelper.addEventListener(session, 'Network.loadingFinished', e => this._onLoadingFinished(e)),+ eventsHelper.addEventListener(session, 'Network.loadingFailed', e => this._onLoadingFailed(session, e)),+ eventsHelper.addEventListener(session, 'Network.webSocketCreated', e => this._page.frameManager.onWebSocketCreated(e.requestId, e.url)),+ eventsHelper.addEventListener(session, 'Network.webSocketWillSendHandshakeRequest', e => this._page.frameManager.onWebSocketRequest(e.requestId)),+ eventsHelper.addEventListener(session, 'Network.webSocketHandshakeResponseReceived', e => this._page.frameManager.onWebSocketResponse(e.requestId, e.response.status, e.response.statusText)),+ eventsHelper.addEventListener(session, 'Network.webSocketFrameSent', e => e.response.payloadData && this._page.frameManager.onWebSocketFrameSent(e.requestId, e.response.opcode, e.response.payloadData)),+ eventsHelper.addEventListener(session, 'Network.webSocketFrameReceived', e => e.response.payloadData && this._page.frameManager.webSocketFrameReceived(e.requestId, e.response.opcode, e.response.payloadData)),+ eventsHelper.addEventListener(session, 'Network.webSocketClosed', e => this._page.frameManager.webSocketClosed(e.requestId)),+ eventsHelper.addEventListener(session, 'Network.webSocketFrameError', e => this._page.frameManager.webSocketError(e.requestId, e.errorMessage)),];}@@ -248,6 +367,11 @@ export class WVPage implements PageDelegate {this._page.frameManager.frameCommittedNewDocumentNavigation(framePayload.id, framePayload.url, framePayload.name || '', framePayload.loaderId, initial);if (!initial)this._firstNonInitialNavigationCommittedFulfill();+ const pending = this._pendingMainFrameLoaderResolvers.get(framePayload.id);+ if (pending) {+ this._pendingMainFrameLoaderResolvers.delete(framePayload.id);+ pending(framePayload.loaderId);+ }}private _onFrameNavigatedWithinDocument(frameId: string, url: string) {@@ -274,6 +398,8 @@ export class WVPage implements PageDelegate {const frame = this._page.frameManager.frame(contextPayload.frameId);if (!frame)return;+ if (contextPayload.type !== 'normal')+ return;const delegate = new WVExecutionContext(this._session, contextPayload.id);const context = new dom.FrameExecutionContext(delegate, frame, 'main');frame.contextCreated('main', context);@@ -290,13 +416,9 @@ export class WVPage implements PageDelegate {}private async _navigateMainFrame(frame: frames.Frame, url: string): Promise<frames.GotoResult> {- let resolveLoaderId: (loaderId: string) => void;- const loaderIdPromise = new Promise<string>(resolve => { resolveLoaderId = resolve; });- const onFrameNavigated = (payload: Protocol.Page.frameNavigatedPayload) => {- if (payload.frame.id === frame._id)- resolveLoaderId(payload.frame.loaderId);- };- this._session.on('Page.frameNavigated', onFrameNavigated);+ const loaderIdPromise = new Promise<string>(resolve => {+ this._pendingMainFrameLoaderResolvers.set(frame._id, resolve);+ });try {this._session.sendMayFail('Runtime.evaluate', {expression: `window.location.href = ${JSON.stringify(url)}`,@@ -305,7 +427,7 @@ export class WVPage implements PageDelegate {const loaderId = await loaderIdPromise;return { newDocumentId: loaderId };} finally {- this._session.off('Page.frameNavigated', onFrameNavigated);+ this._pendingMainFrameLoaderResolvers.delete(frame._id);}}@@ -825,40 +947,6 @@ export class WVPage implements PageDelegate {}}-class WKFrame {- readonly _page: WVPage;- readonly _session: WVSession;- private _sessionListeners: RegisteredListener[] = [];- private _initializePromise: Promise<void> | null = null;-- constructor(page: WVPage, session: WVSession) {- this._page = page;- this._session = session;- }-- async initialize() {- if (this._initializePromise)- return this._initializePromise;- this._initializePromise = this._initializeImpl();- return this._initializePromise;- }-- private async _initializeImpl() {- this._sessionListeners = [- eventsHelper.addEventListener(this._session, 'Console.messageAdded', event => this._page._onConsoleMessage(event)),- eventsHelper.addEventListener(this._session, 'Console.messageRepeatCountUpdated', event => this._page._onConsoleRepeatCountUpdated(event)),- ];- // Child frames will actually inherit the console agent state from the main frame,- // but we keep the logic uniform as we don't know if we are a main frame or not.- await this._session.send('Console.enable');- }-- dispose() {- eventsHelper.removeEventListeners(this._sessionListeners);- this._session.dispose();- }-}-function parseRemoteAddress(value?: string) {if (!value)return;diff --git a/packages/playwright-core/src/server/webkit/webview/wvProvisionalPage.ts b/packages/playwright-core/src/server/webkit/webview/wvProvisionalPage.tsnew file mode 100644index 0000000000..25cba302f3--- /dev/null+++ b/packages/playwright-core/src/server/webkit/webview/wvProvisionalPage.ts@@ -0,0 +1,70 @@+/**+ * Copyright (c) Microsoft Corporation.+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */++import { eventsHelper } from '@utils/eventsHelper';+import { assert } from '@isomorphic/assert';++import type { Protocol } from './protocol';+import type { WVSession } from './wvConnection';+import type { WVPage } from './wvPage';+import type { RegisteredListener } from '@utils/eventsHelper';++export class WVProvisionalPage {+ readonly _session: WVSession;+ private readonly _wvPage: WVPage;+ private _sessionListeners: RegisteredListener[] = [];+ private _mainFrameId: string | null = null;+ readonly initializationPromise: Promise<void>;++ constructor(session: WVSession, page: WVPage) {+ this._session = session;+ this._wvPage = page;++ const overrideFrameId = (handler: (p: any) => void) => {+ return (payload: any) => {+ // Pretend that the events happened in the same process.+ if (payload.frameId)+ payload.frameId = this._wvPage._page.frameManager.mainFrame()._id;+ handler(payload);+ };+ };+ const wvPage = this._wvPage;++ this._sessionListeners = [+ eventsHelper.addEventListener(session, 'Network.requestWillBeSent', overrideFrameId(e => wvPage._onRequestWillBeSent(session, e))),+ eventsHelper.addEventListener(session, 'Network.requestIntercepted', overrideFrameId(e => wvPage._onRequestIntercepted(session, e))),+ eventsHelper.addEventListener(session, 'Network.responseReceived', overrideFrameId(e => wvPage._onResponseReceived(session, e))),+ eventsHelper.addEventListener(session, 'Network.loadingFinished', overrideFrameId(e => wvPage._onLoadingFinished(e))),+ eventsHelper.addEventListener(session, 'Network.loadingFailed', overrideFrameId(e => wvPage._onLoadingFailed(session, e))),+ ];++ this.initializationPromise = this._wvPage._initializeSession(session, true, ({ frameTree }) => this._handleFrameTree(frameTree));+ }++ dispose() {+ eventsHelper.removeEventListeners(this._sessionListeners);+ }++ commit() {+ assert(this._mainFrameId);+ this._wvPage._onFrameAttached(this._mainFrameId, null);+ }++ private _handleFrameTree(frameTree: Protocol.Page.FrameResourceTree) {+ assert(!frameTree.frame.parentId);+ this._mainFrameId = frameTree.frame.id;+ }+}diff --git a/packages/playwright-core/src/server/webkit/webview/wvWorkers.ts b/packages/playwright-core/src/server/webkit/webview/wvWorkers.tsindex f8cd59a13c..3e8b2cb41e 100644--- a/packages/playwright-core/src/server/webkit/webview/wvWorkers.ts+++ b/packages/playwright-core/src/server/webkit/webview/wvWorkers.ts@@ -31,6 +31,10 @@ export class WVWorkers {constructor(page: Page, session: WVSession) {this._page = page;+ this.setSession(session);+ }++ setSession(session: WVSession) {eventsHelper.removeEventListeners(this._sessionListeners);this.clear();this._sessionListeners = [diff --git a/tests/webview/expectations/webkit-webview-page.txt b/tests/webview/expectations/webkit-webview-page.txtindex ce82e1d469..881c93621f 100644--- a/tests/webview/expectations/webkit-webview-page.txt+++ b/tests/webview/expectations/webkit-webview-page.txt@@ -70,27 +70,6 @@ page/page-screenshot.spec.ts › page screenshot › should work for webgl [failpage/page-screenshot.spec.ts › page screenshot › should work while navigating [fail]page/page-screenshot.spec.ts › page screenshot › should work with Array deleted [fail]-# ============================================================================-# api-request-context (14 tests)-# APIRequestContext.fetch/get/post are not wired up for the WebView backend.-# The stock RDP exposes no equivalent of Network.loadRequest, and we have not-# implemented an out-of-page fetch path.-# ============================================================================-page/expect-boolean.spec.ts › not.toBeOK [fail]-page/expect-boolean.spec.ts › toBeOK [fail]-page/expect-boolean.spec.ts › toBeOK fail with promise [fail]-page/expect-boolean.spec.ts › toBeOK should print response with text content type when fails › image content type [fail]-page/expect-boolean.spec.ts › toBeOK should print response with text content type when fails › no content type [fail]-page/expect-boolean.spec.ts › toBeOK should print response with text content type when fails › text content type [fail]-page/page-request-fulfill.spec.ts › should fetch original request and fulfill [fail]-page/page-request-fulfill.spec.ts › should fulfill with fetch result [fail]-page/page-request-intercept.spec.ts › should fulfill intercepted response [fail]-page/page-request-intercept.spec.ts › should fulfill response with empty body [fail]-page/page-request-intercept.spec.ts › should fulfill with any response [fail]-page/page-request-intercept.spec.ts › should give access to the intercepted response body [fail]-page/page-request-intercept.spec.ts › should override with defaults when intercepted response not provided [fail]-page/page-request-intercept.spec.ts › should support fulfill after intercept [fail]-# ============================================================================# frame-element-and-ownership (38 tests)# elementHandle.contentFrame / elementHandle.ownerFrame / frame.frameElement@@ -405,6 +384,7 @@ page/page-request-intercept.spec.ts › should support timeout option in route.fpage/page-route.spec.ts › should fail navigation when aborting main resource [fail]page/page-route.spec.ts › should not auto-intercept non-preflight OPTIONS with network interception [fail]page/page-route.spec.ts › should not override cookie header [fail]+page/page-route.spec.ts › should send referer [fail]page/page-screenshot.spec.ts › page screenshot animations › should capture screenshots after layoutchanges in transitionend event › make sure transition is actually running [fail]page/page-screenshot.spec.ts › page screenshot animations › should fire transitionend for finite transitions › make sure transition is actually running [fail]page/page-screenshot.spec.ts › page screenshot animations › should stop animations that happen right before screenshot [fail]diff --git a/tests/webview/webviewTest.ts b/tests/webview/webviewTest.tsindex e6cdf4049f..2fc530c00e 100644--- a/tests/webview/webviewTest.ts+++ b/tests/webview/webviewTest.ts@@ -152,6 +152,10 @@ export const webviewTest = baseTest.extend<WebViewTestFixtures, WebViewWorkerFix},_autoSkipWebView: [async ({ webviewExpectations }, run, testInfo) => {+ if (process.env.PWTEST_DISABLE_WEBVIEW_EXPECTATIONS !== undefined) {+ await run();+ return;+ }const outcome = shouldSkipWebViewTest(testInfo.titlePath, webviewExpectations);if (outcome)testInfo.fixme(true, `webview expectation: ${outcome}`);