Skip to content

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

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.md
index 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 it
diff --git a/.claude/skills/playwright-dev/webview.md b/.claude/skills/playwright-dev/webview.md
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.txt
index 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 [fail
page/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.f
page/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.ts
index 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}`);