chrome-devtools-frontend 1.0.1578729 → 1.0.1581449

package/front_end/third_party/puppeteer/package/src/api/locators/locators.ts

@@ -65,6 +65,18 @@ export interface ActionOptions {
  * @public
  */
 export type LocatorClickOptions = ClickOptions & ActionOptions;
+/**
+ * @public
+ */
+export interface LocatorFillOptions extends ActionOptions {
+  /**
+   * The number of characters to type before switching to a faster fill-out
+   * method.
+   *
+   * @defaultValue `100`
+   */
+  typingThreshold?: number;
+}
 /**
  * @public
  */
@@ -400,9 +412,10 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
   #fill<ElementType extends Element>(
     this: Locator<ElementType>,
     value: string,
-    options?: Readonly<ActionOptions>,
+    options?: Readonly<LocatorFillOptions>,
   ): Observable<void> {
     const signal = options?.signal;
+    const typingThreshold = options?.typingThreshold ?? 100;
     const cause = new Error('Locator.fill');
     return this._wait(options).pipe(
       this.operators.conditions(
@@ -453,68 +466,87 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
         )
           .pipe(
             mergeMap(inputType => {
+              const fillDirectly = (): Observable<void> => {
+                return from(handle.focus()).pipe(
+                  mergeMap(() => {
+                    return from(
+                      handle.evaluate((input, newValue) => {
+                        const element = input as HTMLElement;
+                        const currentValue = element.isContentEditable
+                          ? element.innerText
+                          : (element as HTMLInputElement).value;
+                        if (currentValue === newValue) {
+                          return;
+                        }
+                        if (element.isContentEditable) {
+                          element.innerText = newValue;
+                        } else {
+                          (element as HTMLInputElement).value = newValue;
+                        }
+                        element.dispatchEvent(
+                          new Event('input', {bubbles: true}),
+                        );
+                        element.dispatchEvent(
+                          new Event('change', {bubbles: true}),
+                        );
+                      }, value),
+                    );
+                  }),
+                );
+              };
+
               switch (inputType) {
                 case 'select':
                   return from(handle.select(value).then(noop));
                 case 'contenteditable':
                 case 'typeable-input':
-                  return from(
-                    (
-                      handle as unknown as ElementHandle<HTMLInputElement>
-                    ).evaluate((input, newValue) => {
-                      const currentValue = input.isContentEditable
-                        ? input.innerText
-                        : input.value;
-
-                      // Clear the input if the current value does not match the filled
-                      // out value.
-                      if (
-                        newValue.length <= currentValue.length ||
-                        !newValue.startsWith(input.value)
-                      ) {
-                        if (input.isContentEditable) {
-                          input.innerText = '';
+                  if (value.length < typingThreshold) {
+                    return from(
+                      (
+                        handle as unknown as ElementHandle<HTMLInputElement>
+                      ).evaluate((input, newValue) => {
+                        const element = input as HTMLElement;
+                        const currentValue = element.isContentEditable
+                          ? element.innerText
+                          : (input as HTMLInputElement).value;
+
+                        // Clear the input if the current value does not match the filled
+                        // out value.
+                        if (
+                          newValue.length <= currentValue.length ||
+                          !newValue.startsWith(currentValue)
+                        ) {
+                          if (element.isContentEditable) {
+                            element.innerText = '';
+                          } else {
+                            (input as HTMLInputElement).value = '';
+                          }
+                          return newValue;
+                        }
+
+                        // If the value is partially filled out, only type the rest. Move
+                        // cursor to the end of the common prefix.
+                        if (element.isContentEditable) {
+                          element.innerText = '';
+                          element.innerText = currentValue;
                         } else {
-                          input.value = '';
+                          (input as HTMLInputElement).value = '';
+                          (input as HTMLInputElement).value = currentValue;
                         }
-                        return newValue;
-                      }
-                      const originalValue = input.isContentEditable
-                        ? input.innerText
-                        : input.value;
-
-                      // If the value is partially filled out, only type the rest. Move
-                      // cursor to the end of the common prefix.
-                      if (input.isContentEditable) {
-                        input.innerText = '';
-                        input.innerText = originalValue;
-                      } else {
-                        input.value = '';
-                        input.value = originalValue;
-                      }
-                      return newValue.substring(originalValue.length);
-                    }, value),
-                  ).pipe(
-                    mergeMap(textToType => {
-                      return from(handle.type(textToType));
-                    }),
-                  );
+                        return newValue.substring(currentValue.length);
+                      }, value),
+                    ).pipe(
+                      mergeMap(textToType => {
+                        if (!textToType) {
+                          return of(undefined);
+                        }
+                        return from(handle.type(textToType));
+                      }),
+                    );
+                  }
+                  return fillDirectly();
                 case 'other-input':
-                  return from(handle.focus()).pipe(
-                    mergeMap(() => {
-                      return from(
-                        handle.evaluate((input, value) => {
-                          (input as HTMLInputElement).value = value;
-                          input.dispatchEvent(
-                            new Event('input', {bubbles: true}),
-                          );
-                          input.dispatchEvent(
-                            new Event('change', {bubbles: true}),
-                          );
-                        }, value),
-                      );
-                    }),
-                  );
+                  return fillDirectly();
                 case 'unknown':
                   throw new Error(`Element cannot be filled out.`);
               }
@@ -716,7 +748,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
   fill<ElementType extends Element>(
     this: Locator<ElementType>,
     value: string,
-    options?: Readonly<ActionOptions>,
+    options?: Readonly<LocatorFillOptions>,
   ): Promise<void> {
     return firstValueFrom(this.#fill(value, options));
   }

package/front_end/third_party/puppeteer/package/src/bidi/Browser.ts

@@ -25,8 +25,7 @@ import type {Page} from '../api/Page.js';
 import type {Target} from '../api/Target.js';
 import type {Connection as CdpConnection} from '../cdp/Connection.js';
 import type {SupportedWebDriverCapabilities} from '../common/ConnectOptions.js';
-import {ProtocolError} from '../common/Errors.js';
-import {UnsupportedOperation} from '../common/Errors.js';
+import {ProtocolError, UnsupportedOperation} from '../common/Errors.js';
 import {EventEmitter} from '../common/EventEmitter.js';
 import {debugError} from '../common/util.js';
 import type {Viewport} from '../common/Viewport.js';
@@ -306,15 +305,41 @@ export class BidiBrowser extends Browser {
     throw new UnsupportedOperation();
   }
 
-  override getWindowBounds(_windowId: WindowId): Promise<WindowBounds> {
-    throw new UnsupportedOperation();
+  override async getWindowBounds(windowId: WindowId): Promise<WindowBounds> {
+    const clientWindowInfo =
+      await this.#browserCore.getClientWindowInfo(windowId);
+    return {
+      left: clientWindowInfo.x,
+      top: clientWindowInfo.y,
+      width: clientWindowInfo.width,
+      height: clientWindowInfo.height,
+      windowState: clientWindowInfo.state,
+    };
   }
 
-  override setWindowBounds(
-    _windowId: WindowId,
-    _windowBounds: WindowBounds,
+  override async setWindowBounds(
+    windowId: WindowId,
+    windowBounds: WindowBounds,
   ): Promise<void> {
-    throw new UnsupportedOperation();
+    let params: Bidi.Browser.SetClientWindowStateParameters | undefined;
+    const windowState = windowBounds.windowState ?? 'normal';
+    if (windowState === 'normal') {
+      params = {
+        clientWindow: windowId,
+        state: 'normal',
+        x: windowBounds.left,
+        y: windowBounds.top,
+        width: windowBounds.width,
+        height: windowBounds.height,
+      };
+    } else {
+      params = {
+        clientWindow: windowId,
+        state: windowState,
+      };
+    }
+
+    await this.#browserCore.setClientWindowState(params);
   }
 
   override targets(): Target[] {

package/front_end/third_party/puppeteer/package/src/bidi/BrowserContext.ts

@@ -6,13 +6,19 @@
 
 import * as Bidi from 'webdriver-bidi-protocol';
 
-import type {CreatePageOptions, Permission} from '../api/Browser.js';
+import type {
+  CreatePageOptions,
+  Permission,
+  PermissionDescriptor,
+  PermissionState,
+} from '../api/Browser.js';
 import {WEB_PERMISSION_TO_PROTOCOL_PERMISSION} from '../api/Browser.js';
 import type {BrowserContextEvents} from '../api/BrowserContext.js';
 import {BrowserContext, BrowserContextEvent} from '../api/BrowserContext.js';
 import {PageEvent, type Page} from '../api/Page.js';
 import type {Target} from '../api/Target.js';
 import type {Cookie, CookieData} from '../common/Cookie.js';
+import {UnsupportedOperation} from '../common/Errors.js';
 import {EventEmitter} from '../common/EventEmitter.js';
 import {debugError} from '../common/util.js';
 import type {Viewport} from '../common/Viewport.js';
@@ -199,8 +205,20 @@ export class BidiBrowserContext extends BrowserContext {
     if (this.#defaultViewport) {
       try {
         await page.setViewport(this.#defaultViewport);
-      } catch {
-        // No support for setViewport in Firefox.
+      } catch (error) {
+        // Tolerate not supporting `browsingContext.setViewport`. Only log it.
+        debugError(error);
+      }
+    }
+    if (options?.type === 'window' && options?.windowBounds !== undefined) {
+      try {
+        await this.browser().setWindowBounds(
+          context.windowId,
+          options.windowBounds,
+        );
+      } catch (error) {
+        // Tolerate not supporting `browser.setClientWindowState`. Only log it.
+        debugError(error);
       }
     }
 
@@ -270,6 +288,46 @@ export class BidiBrowserContext extends BrowserContext {
     );
   }
 
+  override async setPermission(
+    origin: string | '*',
+    ...permissions: Array<{
+      permission: PermissionDescriptor;
+      state: PermissionState;
+    }>
+  ): Promise<void> {
+    if (origin === '*') {
+      throw new UnsupportedOperation(
+        'Origin (*) is not supported by WebDriver BiDi',
+      );
+    }
+    await Promise.all(
+      permissions.map(permission => {
+        if (permission.permission.allowWithoutSanitization) {
+          throw new UnsupportedOperation(
+            'allowWithoutSanitization is not supported by WebDriver BiDi',
+          );
+        }
+        if (permission.permission.panTiltZoom) {
+          throw new UnsupportedOperation(
+            'panTiltZoom is not supported by WebDriver BiDi',
+          );
+        }
+        if (permission.permission.userVisibleOnly) {
+          throw new UnsupportedOperation(
+            'userVisibleOnly is not supported by WebDriver BiDi',
+          );
+        }
+        return this.userContext.setPermissions(
+          origin,
+          {
+            name: permission.permission.name,
+          },
+          permission.state as Bidi.Permissions.PermissionState,
+        );
+      }),
+    );
+  }
+
   override async clearPermissionOverrides(): Promise<void> {
     const promises = this.#overrides.map(({permission, origin}) => {
       return this.userContext

package/front_end/third_party/puppeteer/package/src/bidi/Frame.ts

@@ -37,7 +37,7 @@ import {
 } from '../common/ConsoleMessage.js';
 import {TargetCloseError, UnsupportedOperation} from '../common/Errors.js';
 import type {TimeoutSettings} from '../common/TimeoutSettings.js';
-import type {Awaitable} from '../common/types.js';
+import type {Awaitable, HandleFor} from '../common/types.js';
 import {
   debugError,
   fromAbortSignal,
@@ -52,7 +52,7 @@ import type {Navigation} from './core/Navigation.js';
 import type {Request} from './core/Request.js';
 import {BidiDeserializer} from './Deserializer.js';
 import {BidiDialog} from './Dialog.js';
-import type {BidiElementHandle} from './ElementHandle.js';
+import {BidiElementHandle} from './ElementHandle.js';
 import {ExposableFunction} from './ExposedFunction.js';
 import {BidiHTTPRequest, requests} from './HTTPRequest.js';
 import type {BidiHTTPResponse} from './HTTPResponse.js';
@@ -606,6 +606,27 @@ export class BidiFrame extends Frame {
     );
   }
 
+  @throwIfDetached
+  override async frameElement(): Promise<HandleFor<HTMLIFrameElement> | null> {
+    const parentFrame = this.parentFrame();
+    if (!parentFrame) {
+      return null;
+    }
+    const [node] = await parentFrame.browsingContext.locateNodes({
+      type: 'context',
+      value: {
+        context: this._id,
+      },
+    });
+    if (!node) {
+      return null;
+    }
+    return BidiElementHandle.from(
+      node,
+      parentFrame.mainRealm(),
+    ) as HandleFor<HTMLIFrameElement>;
+  }
+
   @throwIfDetached
   async locateNodes(
     element: BidiElementHandle,

package/front_end/third_party/puppeteer/package/src/bidi/Page.ts

@@ -18,6 +18,7 @@ import type {HTTPResponse} from '../api/HTTPResponse.js';
 import type {
   Credentials,
   GeolocationOptions,
+  HeapSnapshotOptions,
   MediaFeature,
   PageEvents,
   ReloadOptions,
@@ -227,8 +228,8 @@ export class BidiPage extends Page {
     throw new UnsupportedOperation();
   }
 
-  override windowId(): Promise<WindowId> {
-    throw new UnsupportedOperation();
+  override async windowId(): Promise<WindowId> {
+    return this.#frame.browsingContext.windowId;
   }
 
   override openDevTools(): Promise<Page> {
@@ -952,6 +953,12 @@ export class BidiPage extends Page {
     throw new UnsupportedOperation();
   }
 
+  override async captureHeapSnapshot(
+    _options: HeapSnapshotOptions,
+  ): Promise<void> {
+    throw new UnsupportedOperation();
+  }
+
   override async goBack(
     options: WaitForOptions = {},
   ): Promise<HTTPResponse | null> {
@@ -1153,17 +1160,31 @@ export function cdpSpecificCookiePropertiesFromPuppeteerToBidi(
 function convertCookiesSameSiteBiDiToCdp(
   sameSite: Bidi.Network.SameSite | undefined,
 ): CookieSameSite {
-  return sameSite === 'strict' ? 'Strict' : sameSite === 'lax' ? 'Lax' : 'None';
+  switch (sameSite) {
+    case 'strict':
+      return 'Strict';
+    case 'lax':
+      return 'Lax';
+    case 'none':
+      return 'None';
+    default:
+      return 'Default';
+  }
 }
 
 export function convertCookiesSameSiteCdpToBiDi(
   sameSite: CookieSameSite | undefined,
 ): Bidi.Network.SameSite {
-  return sameSite === 'Strict'
-    ? Bidi.Network.SameSite.Strict
-    : sameSite === 'Lax'
-      ? Bidi.Network.SameSite.Lax
-      : Bidi.Network.SameSite.None;
+  switch (sameSite) {
+    case 'Strict':
+      return Bidi.Network.SameSite.Strict;
+    case 'Lax':
+      return Bidi.Network.SameSite.Lax;
+    case 'None':
+      return Bidi.Network.SameSite.None;
+    default:
+      return Bidi.Network.SameSite.Default;
+  }
 }
 
 export function convertCookiesExpiryCdpToBiDi(

package/front_end/third_party/puppeteer/package/src/bidi/core/Browser.ts

@@ -286,6 +286,36 @@ export class Browser extends EventEmitter<{
     await this.session.send('webExtension.uninstall', {extension: id});
   }
 
+  @throwIfDisposed<Browser>(browser => {
+    // SAFETY: By definition of `disposed`, `#reason` is defined.
+    return browser.#reason!;
+  })
+  async setClientWindowState(
+    params: Bidi.Browser.SetClientWindowStateParameters,
+  ): Promise<void> {
+    await this.session.send('browser.setClientWindowState', params);
+  }
+
+  @throwIfDisposed<Browser>(browser => {
+    // SAFETY: By definition of `disposed`, `#reason` is defined.
+    return browser.#reason!;
+  })
+  async getClientWindowInfo(
+    windowId: string,
+  ): Promise<Bidi.Browser.ClientWindowInfo> {
+    const {
+      result: {clientWindows},
+    } = await this.session.send('browser.getClientWindows', {});
+
+    const window = clientWindows.find(window => {
+      return window.clientWindow === windowId;
+    });
+    if (!window) {
+      throw new Error('Window not found');
+    }
+    return window;
+  }
+
   override [disposeSymbol](): void {
     this.#reason ??=
       'Browser was disconnected, probably because the session ended.';

package/front_end/third_party/puppeteer/package/src/bidi/core/BrowsingContext.ts

@@ -140,6 +140,7 @@ export class BrowsingContext extends EventEmitter<{
     id: string,
     url: string,
     originalOpener: string | null,
+    clientWindow: string,
   ): BrowsingContext {
     const browsingContext = new BrowsingContext(
       userContext,
@@ -147,6 +148,7 @@ export class BrowsingContext extends EventEmitter<{
       id,
       url,
       originalOpener,
+      clientWindow,
     );
     browsingContext.#initialize();
     return browsingContext;
@@ -166,6 +168,7 @@ export class BrowsingContext extends EventEmitter<{
   readonly parent: BrowsingContext | undefined;
   readonly userContext: UserContext;
   readonly originalOpener: string | null;
+  readonly windowId: string;
   readonly #emulationState: {
     javaScriptEnabled: boolean;
   } = {javaScriptEnabled: true};
@@ -178,6 +181,7 @@ export class BrowsingContext extends EventEmitter<{
     id: string,
     url: string,
     originalOpener: string | null,
+    clientWindow: string,
   ) {
     super();
 
@@ -186,6 +190,7 @@ export class BrowsingContext extends EventEmitter<{
     this.parent = parent;
     this.userContext = userContext;
     this.originalOpener = originalOpener;
+    this.windowId = clientWindow;
 
     this.defaultRealm = this.#createWindowRealm();
     this.#bluetoothEmulation = new BidiBluetoothEmulation(
@@ -226,6 +231,7 @@ export class BrowsingContext extends EventEmitter<{
         info.context,
         info.url,
         info.originalOpener,
+        info.clientWindow,
       );
       this.#children.set(info.context, browsingContext);
 
@@ -740,13 +746,18 @@ export class BrowsingContext extends EventEmitter<{
   })
   async locateNodes(
     locator: Bidi.BrowsingContext.Locator,
-    startNodes: [Bidi.Script.SharedReference, ...Bidi.Script.SharedReference[]],
+    startNodes: Bidi.Script.SharedReference[] = [],
   ): Promise<Bidi.Script.NodeRemoteValue[]> {
     // TODO: add other locateNodes options if needed.
     const result = await this.#session.send('browsingContext.locateNodes', {
       context: this.id,
       locator,
-      startNodes: startNodes.length ? startNodes : undefined,
+      startNodes: startNodes.length
+        ? (startNodes as [
+            Bidi.Script.SharedReference,
+            ...Bidi.Script.SharedReference[],
+          ])
+        : undefined,
     });
     return result.result.nodes;
   }

package/front_end/third_party/puppeteer/package/src/bidi/core/UserContext.ts

@@ -96,6 +96,7 @@ export class UserContext extends EventEmitter<{
         info.context,
         info.url,
         info.originalOpener,
+        info.clientWindow,
       );
       this.#browsingContexts.set(browsingContext.id, browsingContext);