From de159446c28a2ed1213bb3aae9983b3962bcb2b2 Mon Sep 17 00:00:00 2001
From: Devin Rousso <devinrousso@microsoft.com>
Date: Thu, 25 Jun 2026 01:05:29 -0700
Subject: [PATCH] fix(webview): support input for elements inside cross-origin
 `<iframe>`

---
 packages/injected/src/webview/webViewInput.ts | 245 +++++++++---------
 .../src/server/webkit/webview/wvInput.ts      |  54 ++--
 .../src/server/webkit/webview/wvPage.ts       |  42 ++-
 .../expectations/webkit-webview-page.txt      |   9 -
 4 files changed, 177 insertions(+), 173 deletions(-)

diff --git a/packages/injected/src/webview/webViewInput.ts b/packages/injected/src/webview/webViewInput.ts
index bddc78ae40621..83e40f95d6575 100644
--- a/packages/injected/src/webview/webViewInput.ts
+++ b/packages/injected/src/webview/webViewInput.ts
@@ -66,6 +66,10 @@ function markAndDispatch(node: EventTarget, event: Event): boolean {
   return node.dispatchEvent(event);
 }
 
+function modifiersOf(modifiers: Modifiers): Modifiers {
+  return { ctrlKey: modifiers.ctrlKey, shiftKey: modifiers.shiftKey, altKey: modifiers.altKey, metaKey: modifiers.metaKey };
+}
+
 // Legacy WebKit-only KeyboardEvent.keyIdentifier (a DOM Level 3 draft property
 // dropped by every other engine). It cannot be supplied via the constructor, so
 // compute it from the virtual key code and define it on the event before
@@ -101,8 +105,8 @@ function keyIdentifierFor(keyCode: number, key: string): string {
   return '';
 }
 
-function dispatchKeyEvent(node: EventTarget, type: string, init: KeyboardEventInit, keyCode: number, key: string): boolean {
-  const event = new KeyboardEvent(type, init);
+function dispatchKeyEvent(view: Window & typeof globalThis, node: EventTarget, type: string, init: KeyboardEventInit, keyCode: number, key: string): boolean {
+  const event = new view.KeyboardEvent(type, init);
   Object.defineProperty(event, 'keyIdentifier', { value: keyIdentifierFor(keyCode, key), configurable: true });
   return markAndDispatch(node, event);
 }
@@ -132,67 +136,97 @@ export class WebViewInput {
     });
   }
 
-  // Descend through open shadow roots so synthetic events land on the actual
-  // element under the pointer rather than on the shadow host.
-  private _deepElementFromPoint(x: number, y: number): Element | null {
-    let el = this._document.elementFromPoint(x, y);
-    while (el && el.shadowRoot) {
-      const inner = el.shadowRoot.elementFromPoint(x, y);
-      if (!inner || inner === el)
+  private _hitTest(x: number, y: number): { target: Element | null, iframe: HTMLIFrameElement | HTMLFrameElement | null, x: number, y: number } {
+    let target = this._document.elementFromPoint(x, y);
+    while (target?.shadowRoot) {
+      const inner = target.shadowRoot.elementFromPoint(x, y);
+      if (!inner || inner === target)
         break;
-      el = inner;
+      target = inner;
     }
-    return el;
+    if (!target || (target.localName !== 'iframe' && target.localName !== 'frame'))
+      return { target, iframe: null, x, y };
+    const frameRect = target.getBoundingClientRect();
+    const frameStyle = this._window.getComputedStyle(target);
+    return {
+      target,
+      iframe: target as HTMLIFrameElement | HTMLFrameElement,
+      x: x - frameRect.left - parseFloat(frameStyle.borderLeftWidth) - parseFloat(frameStyle.paddingLeft),
+      y: y - frameRect.top - parseFloat(frameStyle.borderTopWidth) - parseFloat(frameStyle.paddingTop),
+    };
+  }
+
+  positionInIFrame(x: number, y: number): { iframe: HTMLIFrameElement | HTMLFrameElement | null, x: number, y: number } {
+    const hit = this._hitTest(x, y);
+    return { iframe: hit.iframe, x: hit.x, y: hit.y };
   }
 
-  // The focused element may live inside one or more shadow roots, where
-  // document.activeElement only reports the outermost shadow host.
   private _deepActiveElement(): Element | null {
     let active = this._document.activeElement;
-    while (active && active.shadowRoot && active.shadowRoot.activeElement)
+    while (active?.shadowRoot?.activeElement)
       active = active.shadowRoot.activeElement;
     return active;
   }
 
+  activeIFrame(): { iframe: HTMLIFrameElement | HTMLFrameElement | null } {
+    const active = this._deepActiveElement();
+    const isFrameOwner = !!active && (active.localName === 'iframe' || active.localName === 'frame');
+    return { iframe: isFrameOwner ? active as HTMLIFrameElement | HTMLFrameElement : null };
+  }
+
   private _insertText(target: Element | null, text: string) {
-    if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {
-      const start = target.selectionStart ?? target.value.length;
-      const end = target.selectionEnd ?? target.value.length;
-      target.value = target.value.slice(0, start) + text + target.value.slice(end);
+    if (!target)
+      return;
+    const view = target.ownerDocument.defaultView;
+    const HTMLInputElementConstructor = view?.HTMLInputElement ?? HTMLInputElement;
+    const HTMLTextAreaElementConstructor = view?.HTMLTextAreaElement ?? HTMLTextAreaElement;
+    const InputEventConstructor = view?.InputEvent ?? InputEvent;
+    if (target instanceof HTMLInputElementConstructor || target instanceof HTMLTextAreaElementConstructor) {
+      const field = target as HTMLInputElement | HTMLTextAreaElement;
+      const start = field.selectionStart ?? field.value.length;
+      const end = field.selectionEnd ?? field.value.length;
+      field.value = field.value.slice(0, start) + text + field.value.slice(end);
       const pos = start + text.length;
       try {
-        target.setSelectionRange(pos, pos);
+        field.setSelectionRange(pos, pos);
       } catch {
       }
-      target.dispatchEvent(new InputEvent('input', { bubbles: true, cancelable: false, data: text, inputType: 'insertText' }));
+      field.dispatchEvent(new InputEventConstructor('input', { bubbles: true, cancelable: false, data: text, inputType: 'insertText' }));
     } else if (target && (target as HTMLElement).isContentEditable) {
-      this._document.execCommand('insertText', false, text);
+      target.ownerDocument.execCommand('insertText', false, text);
     }
   }
 
-  keydown(params: KeyEventParams): Promise<void> {
+  private _resolveActive(): { target: Element, doc: Document, view: Window & typeof globalThis } | null {
     const target = this._deepActiveElement() || this._document.body;
     if (!target)
+      return null;
+    const doc = target.ownerDocument;
+    const view = (doc.defaultView || this._window) as Window & typeof globalThis;
+    return { target, doc, view };
+  }
+
+  keydown(params: KeyEventParams): Promise<void> {
+    const active = this._resolveActive();
+    if (!active)
       return Promise.resolve();
+    const { target, doc, view } = active;
     const init: KeyboardEventInit = {
       bubbles: true,
       cancelable: true,
-      view: this._window,
+      view,
       code: params.code,
       key: params.key,
       keyCode: params.keyCode,
       which: params.keyCode,
       location: params.location,
       repeat: params.repeat,
-      ctrlKey: params.ctrlKey,
-      shiftKey: params.shiftKey,
-      altKey: params.altKey,
-      metaKey: params.metaKey,
+      ...modifiersOf(params),
     };
     let notPrevented = true;
     let charNotPrevented = true;
     let lastTask = this._postTask(() => {
-      notPrevented = dispatchKeyEvent(target, 'keydown', init, params.keyCode, params.key);
+      notPrevented = dispatchKeyEvent(view, target, 'keydown', init, params.keyCode, params.key);
     });
     // Non-text keys produce only keydown; a cancelled keydown also suppresses the
     // keypress and the default text insertion.
@@ -202,7 +236,7 @@ export class WebViewInput {
         if (!notPrevented)
           return;
         const charCode = text.charCodeAt(0);
-        charNotPrevented = markAndDispatch(target, new KeyboardEvent('keypress', { ...init, charCode, keyCode: charCode, which: charCode }));
+        charNotPrevented = markAndDispatch(target, new view.KeyboardEvent('keypress', { ...init, charCode, keyCode: charCode, which: charCode }));
       });
       lastTask = this._postTask(() => {
         if (!notPrevented || !charNotPrevented)
@@ -211,38 +245,36 @@ export class WebViewInput {
         // the insertion (and the subsequent beforeinput/input). Replicate it; the
         // event's default does the insertion, so we do not insert manually. Enter's
         // text is '\r' but the inserted/textInput data is a newline.
-        this._dispatchTextInput(target, text === '\r' ? '\n' : text);
+        this._dispatchTextInput(doc, view, target, text === '\r' ? '\n' : text);
       });
     }
     return lastTask;
   }
 
-  private _dispatchTextInput(target: EventTarget, text: string) {
+  private _dispatchTextInput(doc: Document, view: Window & typeof globalThis, target: EventTarget, text: string) {
     // TextEvent has no usable constructor in WebKit — initTextEvent is the only
     // way to create one (initTextEvent(type, bubbles, cancelable, view, data)).
-    const event = this._document.createEvent('TextEvent') as any;
-    event.initTextEvent('textInput', true, true, this._window, text);
+    const event = doc.createEvent('TextEvent') as any;
+    event.initTextEvent('textInput', true, true, view, text);
     markAndDispatch(target, event);
   }
 
   keyup(params: KeyEventParams): Promise<void> {
-    const target = this._deepActiveElement() || this._document.body;
-    if (!target)
+    const active = this._resolveActive();
+    if (!active)
       return Promise.resolve();
+    const { target, view } = active;
     return this._postTask(() => {
-      dispatchKeyEvent(target, 'keyup', {
+      dispatchKeyEvent(view, target, 'keyup', {
         bubbles: true,
         cancelable: true,
-        view: this._window,
+        view,
         code: params.code,
         key: params.key,
         keyCode: params.keyCode,
         which: params.keyCode,
         location: params.location,
-        ctrlKey: params.ctrlKey,
-        shiftKey: params.shiftKey,
-        altKey: params.altKey,
-        metaKey: params.metaKey,
+        ...modifiersOf(params),
       }, params.keyCode, params.key);
     });
   }
@@ -251,113 +283,82 @@ export class WebViewInput {
     return this._postTask(() => this._insertText(this._deepActiveElement(), text));
   }
 
-  mouseMove(params: MouseMoveParams): Promise<void> {
-    const target = this._deepElementFromPoint(params.x, params.y) || this._document.documentElement;
-    const base: MouseEventInit = {
-      bubbles: true,
-      cancelable: true,
-      view: this._window,
-      clientX: params.x,
-      clientY: params.y,
-      screenX: params.x,
-      screenY: params.y,
-      button: params.button,
-      buttons: params.buttons,
-      ctrlKey: params.ctrlKey,
-      shiftKey: params.shiftKey,
-      altKey: params.altKey,
-      metaKey: params.metaKey,
+  private _resolveMouse(params: Modifiers & { x: number, y: number }): { view: Window & typeof globalThis, target: Element, x: number, y: number, init: MouseEventInit } {
+    const hit = this._hitTest(params.x, params.y);
+    const view = this._window;
+    const target = hit.target || view.document.documentElement;
+    return {
+      view,
+      target,
+      x: params.x,
+      y: params.y,
+      init: {
+        bubbles: true,
+        cancelable: true,
+        view,
+        clientX: params.x,
+        clientY: params.y,
+        screenX: params.x,
+        screenY: params.y,
+        ...modifiersOf(params),
+      },
     };
+  }
+
+  mouseMove(params: MouseMoveParams): Promise<void> {
+    const { view, target, init } = this._resolveMouse(params);
+    const base: MouseEventInit = { ...init, button: params.button, buttons: params.buttons };
     const pointer: PointerEventInit = { ...base, pointerId: 1, pointerType: 'mouse', isPrimary: true };
     const prev = this._hoverTarget;
     if (prev !== target) {
+      const sameDocument = prev?.ownerDocument === target.ownerDocument;
       if (prev && prev.isConnected) {
-        void this._postTask(() => markAndDispatch(prev, new PointerEvent('pointerout', { ...pointer, relatedTarget: target })));
-        void this._postTask(() => markAndDispatch(prev, new MouseEvent('mouseout', { ...base, relatedTarget: target })));
-        void this._postTask(() => markAndDispatch(prev, new PointerEvent('pointerleave', { ...pointer, bubbles: false, cancelable: false, relatedTarget: target })));
-        void this._postTask(() => markAndDispatch(prev, new MouseEvent('mouseleave', { ...base, bubbles: false, cancelable: false, relatedTarget: target })));
+        const prevView = (prev.ownerDocument.defaultView || this._window) as Window & typeof globalThis;
+        const relatedTarget = sameDocument ? target : null;
+        void this._postTask(() => markAndDispatch(prev, new prevView.PointerEvent('pointerout', { ...pointer, view: prevView, relatedTarget })));
+        void this._postTask(() => markAndDispatch(prev, new prevView.MouseEvent('mouseout', { ...base, view: prevView, relatedTarget })));
+        void this._postTask(() => markAndDispatch(prev, new prevView.PointerEvent('pointerleave', { ...pointer, view: prevView, bubbles: false, cancelable: false, relatedTarget })));
+        void this._postTask(() => markAndDispatch(prev, new prevView.MouseEvent('mouseleave', { ...base, view: prevView, bubbles: false, cancelable: false, relatedTarget })));
       }
-      void this._postTask(() => markAndDispatch(target, new PointerEvent('pointerover', { ...pointer, relatedTarget: prev })));
-      void this._postTask(() => markAndDispatch(target, new MouseEvent('mouseover', { ...base, relatedTarget: prev })));
-      void this._postTask(() => markAndDispatch(target, new PointerEvent('pointerenter', { ...pointer, bubbles: false, cancelable: false, relatedTarget: prev })));
-      void this._postTask(() => markAndDispatch(target, new MouseEvent('mouseenter', { ...base, bubbles: false, cancelable: false, relatedTarget: prev })));
+      const relatedTarget = sameDocument ? prev : null;
+      void this._postTask(() => markAndDispatch(target, new view.PointerEvent('pointerover', { ...pointer, relatedTarget })));
+      void this._postTask(() => markAndDispatch(target, new view.MouseEvent('mouseover', { ...base, relatedTarget })));
+      void this._postTask(() => markAndDispatch(target, new view.PointerEvent('pointerenter', { ...pointer, bubbles: false, cancelable: false, relatedTarget })));
+      void this._postTask(() => markAndDispatch(target, new view.MouseEvent('mouseenter', { ...base, bubbles: false, cancelable: false, relatedTarget })));
       this._hoverTarget = target;
     }
-    void this._postTask(() => markAndDispatch(target, new PointerEvent('pointermove', pointer)));
-    return this._postTask(() => markAndDispatch(target, new MouseEvent('mousemove', base)));
+    void this._postTask(() => markAndDispatch(target, new view.PointerEvent('pointermove', pointer)));
+    return this._postTask(() => markAndDispatch(target, new view.MouseEvent('mousemove', base)));
   }
 
   mouseEvent(params: MouseEventParams): Promise<void> {
     // Resolve the hit target at dispatch time, not enqueue time: a queued move
     // ahead of this may reveal an overlay that should receive the press.
     return this._postTask(() => {
-      const target = this._deepElementFromPoint(params.x, params.y) || this._document.documentElement;
-      markAndDispatch(target, new MouseEvent(params.type, {
-        bubbles: true,
-        cancelable: true,
-        view: this._window,
-        clientX: params.x,
-        clientY: params.y,
-        screenX: params.x,
-        screenY: params.y,
-        button: params.button,
-        buttons: params.buttons,
-        detail: params.clickCount,
-        ctrlKey: params.ctrlKey,
-        shiftKey: params.shiftKey,
-        altKey: params.altKey,
-        metaKey: params.metaKey,
-      }));
+      const { view, target, init } = this._resolveMouse(params);
+      markAndDispatch(target, new view.MouseEvent(params.type, { ...init, button: params.button, buttons: params.buttons, detail: params.clickCount }));
     });
   }
 
   wheel(params: WheelParams): Promise<void> {
     return this._postTask(() => {
-      const target = this._deepElementFromPoint(params.x, params.y) || this._document.documentElement;
-      markAndDispatch(target, new WheelEvent('wheel', {
-        bubbles: true,
-        cancelable: true,
-        view: this._window,
-        clientX: params.x,
-        clientY: params.y,
-        screenX: params.x,
-        screenY: params.y,
-        deltaX: params.deltaX,
-        deltaY: params.deltaY,
-        deltaMode: 0,
-        ctrlKey: params.ctrlKey,
-        shiftKey: params.shiftKey,
-        altKey: params.altKey,
-        metaKey: params.metaKey,
-      }));
-      this._window.scrollBy(params.deltaX, params.deltaY);
+      const { view, target, init } = this._resolveMouse(params);
+      markAndDispatch(target, new view.WheelEvent('wheel', { ...init, deltaX: params.deltaX, deltaY: params.deltaY, deltaMode: 0 }));
+      view.scrollBy(params.deltaX, params.deltaY);
     });
   }
 
   tap(params: TapParams): Promise<void> {
-    const target = this._deepElementFromPoint(params.x, params.y) || this._document.documentElement;
-    const init: MouseEventInit = {
-      bubbles: true,
-      cancelable: true,
-      view: this._window,
-      clientX: params.x,
-      clientY: params.y,
-      screenX: params.x,
-      screenY: params.y,
-      ctrlKey: params.ctrlKey,
-      shiftKey: params.shiftKey,
-      altKey: params.altKey,
-      metaKey: params.metaKey,
-    };
+    const { view, target, x, y, init } = this._resolveMouse(params);
     try {
-      const touch = new Touch({ identifier: 0, target, clientX: params.x, clientY: params.y, screenX: params.x, screenY: params.y, pageX: params.x, pageY: params.y, radiusX: 1, radiusY: 1, rotationAngle: 0, force: 1 });
-      void this._postTask(() => markAndDispatch(target, new TouchEvent('touchstart', { ...init, touches: [touch], targetTouches: [touch], changedTouches: [touch] })));
-      void this._postTask(() => markAndDispatch(target, new TouchEvent('touchend', { ...init, touches: [], targetTouches: [], changedTouches: [touch] })));
+      const touch = new view.Touch({ identifier: 0, target, clientX: x, clientY: y, screenX: params.x, screenY: params.y, pageX: x + view.scrollX, pageY: y + view.scrollY, radiusX: 1, radiusY: 1, rotationAngle: 0, force: 1 });
+      void this._postTask(() => markAndDispatch(target, new view.TouchEvent('touchstart', { ...init, touches: [touch], targetTouches: [touch], changedTouches: [touch] })));
+      void this._postTask(() => markAndDispatch(target, new view.TouchEvent('touchend', { ...init, touches: [], targetTouches: [], changedTouches: [touch] })));
     } catch {
     }
-    void this._postTask(() => markAndDispatch(target, new MouseEvent('mousedown', { ...init, button: 0, buttons: 1, detail: 1 })));
-    void this._postTask(() => markAndDispatch(target, new MouseEvent('mouseup', { ...init, button: 0, buttons: 0, detail: 1 })));
-    return this._postTask(() => markAndDispatch(target, new MouseEvent('click', { ...init, button: 0, buttons: 0, detail: 1 })));
+    void this._postTask(() => markAndDispatch(target, new view.MouseEvent('mousedown', { ...init, button: 0, buttons: 1, detail: 1 })));
+    void this._postTask(() => markAndDispatch(target, new view.MouseEvent('mouseup', { ...init, button: 0, buttons: 0, detail: 1 })));
+    return this._postTask(() => markAndDispatch(target, new view.MouseEvent('click', { ...init, button: 0, buttons: 0, detail: 1 })));
   }
 }
 
diff --git a/packages/playwright-core/src/server/webkit/webview/wvInput.ts b/packages/playwright-core/src/server/webkit/webview/wvInput.ts
index 32ef4b46a8dae..43bb386db9f38 100644
--- a/packages/playwright-core/src/server/webkit/webview/wvInput.ts
+++ b/packages/playwright-core/src/server/webkit/webview/wvInput.ts
@@ -18,7 +18,6 @@
 import * as input from '../../input';
 
 import type * as types from '../../types';
-import type { WVSession } from './wvConnection';
 import type { Progress } from '../../progress';
 
 function modifierFlags(modifiers: Set<types.KeyboardModifier>) {
@@ -51,11 +50,13 @@ function toButtonsMask(buttons: Set<types.MouseButton>): number {
   return mask;
 }
 
+export type DispatchWebViewInput = (progress: Progress, method: string, params: any) => Promise<void>;
+
 export class RawKeyboardImpl implements input.RawKeyboard {
-  private _session: WVSession | undefined;
+  private _dispatcher: DispatchWebViewInput;
 
-  setSession(session: WVSession) {
-    this._session = session;
+  constructor(dispatcher: DispatchWebViewInput) {
+    this._dispatcher = dispatcher;
   }
 
   async keydown(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription, autoRepeat: boolean): Promise<void> {
@@ -65,29 +66,29 @@ export class RawKeyboardImpl implements input.RawKeyboard {
       ...modifierFlags(modifiers),
       ...(text ? { text } : {}),
     };
-    await callWebViewInput(progress, this._session, 'keydown', params);
+    await this._dispatcher(progress, 'keydown', params);
   }
 
   async keyup(progress: Progress, modifiers: Set<types.KeyboardModifier>, keyName: string, description: input.KeyDescription): Promise<void> {
     const { code, keyCode, key, location } = description;
     const params = { code, key, keyCode, location, ...modifierFlags(modifiers) };
-    await callWebViewInput(progress, this._session, 'keyup', params);
+    await this._dispatcher(progress, 'keyup', params);
   }
 
   async sendText(progress: Progress, text: string): Promise<void> {
-    await callWebViewInput(progress, this._session, 'insertText', text);
+    await this._dispatcher(progress, 'insertText', text);
   }
 }
 
 export class RawMouseImpl implements input.RawMouse {
-  private _session: WVSession | undefined;
+  private _dispatcher: DispatchWebViewInput;
 
-  setSession(session: WVSession) {
-    this._session = session;
+  constructor(dispatcher: DispatchWebViewInput) {
+    this._dispatcher = dispatcher;
   }
 
   async move(progress: Progress, x: number, y: number, button: types.MouseButton | 'none', buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, forClick: boolean): Promise<void> {
-    await callWebViewInput(progress, this._session, 'mouseMove', {
+    await this._dispatcher(progress, 'mouseMove', {
       x, y, button: buttonToNumber(button), buttons: toButtonsMask(buttons), ...modifierFlags(modifiers),
     });
   }
@@ -114,43 +115,24 @@ export class RawMouseImpl implements input.RawMouse {
   }
 
   async wheel(progress: Progress, x: number, y: number, buttons: Set<types.MouseButton>, modifiers: Set<types.KeyboardModifier>, deltaX: number, deltaY: number): Promise<void> {
-    await callWebViewInput(progress, this._session, 'wheel', { x, y, deltaX, deltaY, ...modifierFlags(modifiers) });
+    await this._dispatcher(progress, 'wheel', { x, y, deltaX, deltaY, ...modifierFlags(modifiers) });
   }
 
   private async _mouseEvent(progress: Progress, type: string, x: number, y: number, button: number, buttons: number, modifiers: Set<types.KeyboardModifier>, clickCount: number) {
-    await callWebViewInput(progress, this._session, 'mouseEvent', {
+    await this._dispatcher(progress, 'mouseEvent', {
       type, x, y, button, buttons, clickCount, ...modifierFlags(modifiers),
     });
   }
 }
 
 export class RawTouchscreenImpl implements input.RawTouchscreen {
-  private _session: WVSession | undefined;
+  private _dispatcher: DispatchWebViewInput;
 
-  setSession(session: WVSession) {
-    this._session = session;
+  constructor(dispatcher: DispatchWebViewInput) {
+    this._dispatcher = dispatcher;
   }
 
   async tap(progress: Progress, x: number, y: number, modifiers: Set<types.KeyboardModifier>) {
-    await callWebViewInput(progress, this._session, 'tap', { x, y, ...modifierFlags(modifiers) });
-  }
-}
-
-async function callWebViewInput(progress: Progress, session: WVSession | undefined, method: string, arg: any): Promise<void> {
-  if (!session)
-    throw new Error('Page is not initialized');
-  const expression = `window.__pwWebViewInput.${method}(${JSON.stringify(arg)})`;
-  // Some dispatchers are async — they spread events across event-loop tasks the
-  // way a real device does. Await the returned promise so the action only
-  // resolves once every event has been delivered. Stock WebKit's Runtime.evaluate
-  // has no awaitPromise option, so use the separate Runtime.awaitPromise command.
-  const { result } = await progress.race(session.send('Runtime.evaluate', { expression, returnByValue: false }));
-  // `result` is absent if evaluation failed (e.g. the frame navigated away).
-  // Only promises carry an objectId here — every __pwWebViewInput method returns
-  // void or a Promise — so this both awaits async dispatch and avoids leaking a
-  // handle for the synchronous (void) case.
-  if (result?.className === 'Promise' && result.objectId) {
-    await progress.race(session.send('Runtime.awaitPromise', { promiseObjectId: result.objectId, returnByValue: true }));
-    session.sendMayFail('Runtime.releaseObject', { objectId: result.objectId });
+    await this._dispatcher(progress, 'tap', { x, y, ...modifierFlags(modifiers) });
   }
 }
diff --git a/packages/playwright-core/src/server/webkit/webview/wvPage.ts b/packages/playwright-core/src/server/webkit/webview/wvPage.ts
index b6f2f0cf98681..121f5c1aa5108 100644
--- a/packages/playwright-core/src/server/webkit/webview/wvPage.ts
+++ b/packages/playwright-core/src/server/webkit/webview/wvPage.ts
@@ -79,9 +79,10 @@ export class WVPage implements PageDelegate {
   constructor(browserContext: WVBrowserContext, outerSession: WVSession, dialogEndpoint?: string) {
     this._outerSession = outerSession;
     this._dialogEndpoint = dialogEndpoint;
-    this.rawKeyboard = new RawKeyboardImpl();
-    this.rawMouse = new RawMouseImpl();
-    this.rawTouchscreen = new RawTouchscreenImpl();
+    const dispatchInput = this._dispatchWebViewInput.bind(this);
+    this.rawKeyboard = new RawKeyboardImpl(dispatchInput);
+    this.rawMouse = new RawMouseImpl(dispatchInput);
+    this.rawTouchscreen = new RawTouchscreenImpl(dispatchInput);
     this._contextIdToContext = new Map();
     this._page = new Page(this, browserContext);
     this._workers = new WVWorkers(this._page, outerSession);
@@ -192,9 +193,6 @@ export class WVPage implements PageDelegate {
   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();
   }
@@ -917,6 +915,38 @@ export class WVPage implements PageDelegate {
   async inputActionEpilogue(): Promise<void> {
   }
 
+  private async _dispatchWebViewInput(progress: Progress, method: string, params: any): Promise<void> {
+    const positional = typeof params === 'object' && params !== null && 'x' in params;
+    let frame: frames.Frame = this._page.mainFrame();
+    let x = positional ? params.x as number : 0;
+    let y = positional ? params.y as number : 0;
+    for (;;) {
+      const context = await progress.race(frame.mainContext());
+      const positionInOrActiveIFrame = positional
+        ? await progress.race(context.evaluateHandle(([px, py]) => (globalThis as any).__pwWebViewInput.positionInIFrame(px, py), [x, y]))
+        : await progress.race(context.evaluateHandle(() => (globalThis as any).__pwWebViewInput.activeIFrame()));
+      try {
+        const iframe = await positionInOrActiveIFrame.getProperty(progress, 'iframe') as dom.ElementHandle;
+        let childFrame: frames.Frame | null;
+        try {
+          childFrame = await progress.race(this.getContentFrame(iframe));
+        } finally {
+          iframe.dispose();
+        }
+        if (!childFrame)
+          break;
+        if (positional)
+          ({ x, y } = await progress.race(positionInOrActiveIFrame.evaluate(result => ({ x: result.x, y: result.y }))));
+        frame = childFrame;
+      } finally {
+        positionInOrActiveIFrame.dispose();
+      }
+    }
+    const context = await progress.race(frame.mainContext());
+    // This will automatically await if the result is a promise, so async dispatchers deliver every event before this resolves.
+    await progress.race(context.evaluate(({ method, params }) => (globalThis as any).__pwWebViewInput[method](params), { method, params: positional ? { ...params, x, y } : params }));
+  }
+
   async resetForReuse(progress: Progress): Promise<void> {
   }
 
diff --git a/tests/webview/expectations/webkit-webview-page.txt b/tests/webview/expectations/webkit-webview-page.txt
index 8383ec40ecfee..42fe2d88d6fb3 100644
--- a/tests/webview/expectations/webkit-webview-page.txt
+++ b/tests/webview/expectations/webkit-webview-page.txt
@@ -89,11 +89,8 @@ page/frame-evaluate.spec.ts › should not allow cross-frame element handles whe
 page/frame-frame-element.spec.ts › should work inside closed shadow root [fail]
 page/frame-frame-element.spec.ts › should work inside declarative shadow root [fail]
 page/frame-goto.spec.ts › should return matching responses [fail]
-page/page-click.spec.ts › should click button inside frameset [fail]
-page/page-click.spec.ts › should click the button inside an iframe [fail]
 page/page-click.spec.ts › should not hang when frame is detached [fail]
 page/page-drag.spec.ts › Drag and drop › should work inside iframe [fail]
-page/page-keyboard.spec.ts › should type emoji into an iframe [fail]
 page/page-wait-for-selector-1.spec.ts › page.waitForSelector is shortcut for main frame [fail]
 
 # ============================================================================
@@ -247,7 +244,6 @@ page/page-click.spec.ts › should fire contextmenu event on right click in corr
 page/page-click.spec.ts › should set PointerEvent.pressure on pointerdown [fail]
 page/page-click.spec.ts › should set PointerEvent.pressure on pointermove [fail]
 page/page-dispatchevent.spec.ts › should dispatch absolute device orientation event [fail]
-page/page-drag.spec.ts › Drag and drop › should be able to drag the mouse in a frame [fail]
 page/page-drag.spec.ts › Drag and drop › should cancel on escape [fail]
 page/page-drag.spec.ts › Drag and drop › should work @smoke [fail]
 page/page-drag.spec.ts › Drag and drop › should work if the drag event is captured but not canceled [fail]
@@ -540,7 +536,6 @@ page/to-match-aria-snapshot.spec.ts › should not match what is not matched [fa
 page/frame-evaluate.spec.ts › should work in iframes that interrupted initial javascript url navigation [fail]
 page/locator-frame.spec.ts › should work for iframe @smoke [fail]
 page/locator-frame.spec.ts › should work for nested iframe [fail]
-page/locator-frame.spec.ts › should work with COEP/COOP/CORP isolated iframe [fail]
 page/page-add-init-script.spec.ts › init script should run only once in iframe [fail]
 page/page-aria-snapshot-ai.spec.ts › return empty snapshot when iframe is not loaded [fail]
 page/page-aria-snapshot-ai.spec.ts › should limit depth across iframe boundary [fail]
@@ -558,9 +553,6 @@ page/page-click.spec.ts › should click a button that is overlaid by a permissi
 page/page-click.spec.ts › should click in a nested transformed iframe [fail]
 page/page-click.spec.ts › should click in a transformed iframe [fail]
 page/page-click.spec.ts › should click in a transformed iframe with force [fail]
-page/page-click.spec.ts › should click in an iframe with border [fail]
-page/page-click.spec.ts › should click in an iframe with border 2 [fail]
-page/page-click.spec.ts › should click the button inside an iframe [fail]
 page/page-click.spec.ts › should click the button with fixed position inside an iframe [fail]
 page/page-click.spec.ts › should issue clicks in parallel in page and popup [fail]
 page/page-drag.spec.ts › Drag and drop › iframe › should drag into an iframe [fail]
@@ -672,7 +664,6 @@ page/network-post-data.spec.ts › should get post data for navigator.sendBeacon
 page/page-add-init-script.spec.ts › should work after a cross origin navigation [fail]
 page/page-autowaiting-basic.spec.ts › should await cross-process navigation when clicking anchor [fail]
 page/page-autowaiting-basic.spec.ts › should await form-get on click [fail]
-page/page-basic.spec.ts › frame.press should work [fail]
 page/page-basic.spec.ts › page.close should work with window.close [fail]
 page/page-basic.spec.ts › should provide access to the opener page [fail]
 page/page-click-scroll.spec.ts › should scroll into view display:contents [fail]