chrome-devtools-frontend 1.0.1376716 → 1.0.1386602

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

@@ -6,7 +6,9 @@
 
 import type {Protocol} from 'devtools-protocol';
 
+import {TouchError} from '../common/Errors.js';
 import type {KeyInput} from '../common/USKeyboardLayout.js';
+import {createIncrementalIdGenerator} from '../util/incremental-id-generator.js';
 
 import type {Point} from './ElementHandle.js';
 
@@ -469,36 +471,71 @@ export abstract class Mouse {
     options?: {delay?: number},
   ): Promise<void>;
 }
-
+/**
+ * The TouchHandle interface exposes methods to manipulate touches that have been started
+ * @public
+ */
+export interface TouchHandle {
+  /**
+   * Dispatches a `touchMove` event for this touch.
+   * @param x - Horizontal position of the move.
+   * @param y - Vertical position of the move.
+   */
+  move(x: number, y: number): Promise<void>;
+  /**
+   * Dispatches a `touchend` event for this touch.
+   */
+  end(): Promise<void>;
+}
 /**
  * The Touchscreen class exposes touchscreen events.
  * @public
  */
 export abstract class Touchscreen {
+  /**
+   * @internal
+   */
+  idGenerator = createIncrementalIdGenerator();
+  /**
+   * @internal
+   */
+  touches: TouchHandle[] = [];
   /**
    * @internal
    */
   constructor() {}
 
+  /**
+   * @internal
+   */
+  removeHandle(handle: TouchHandle): void {
+    const index = this.touches.indexOf(handle);
+    if (index === -1) {
+      return;
+    }
+    this.touches.splice(index, 1);
+  }
+
   /**
    * Dispatches a `touchstart` and `touchend` event.
    * @param x - Horizontal position of the tap.
    * @param y - Vertical position of the tap.
    */
   async tap(x: number, y: number): Promise<void> {
-    await this.touchStart(x, y);
-    await this.touchEnd();
+    const touch = await this.touchStart(x, y);
+    await touch.end();
   }
 
   /**
    * Dispatches a `touchstart` event.
    * @param x - Horizontal position of the tap.
    * @param y - Vertical position of the tap.
+   * @returns A handle for the touch that was started.
    */
-  abstract touchStart(x: number, y: number): Promise<void>;
+  abstract touchStart(x: number, y: number): Promise<TouchHandle>;
 
   /**
-   * Dispatches a `touchMove` event.
+   * Dispatches a `touchMove` event on the first touch that is active.
    * @param x - Horizontal position of the move.
    * @param y - Vertical position of the move.
    *
@@ -509,10 +546,22 @@ export abstract class Touchscreen {
    * {@link https://developer.chrome.com/blog/a-more-compatible-smoother-touch/#chromes-new-model-the-throttled-async-touchmove-model | throttles}
    * touch move events.
    */
-  abstract touchMove(x: number, y: number): Promise<void>;
+  async touchMove(x: number, y: number): Promise<void> {
+    const touch = this.touches[0];
+    if (!touch) {
+      throw new TouchError('Must start a new Touch first');
+    }
+    return await touch.move(x, y);
+  }
 
   /**
-   * Dispatches a `touchend` event.
+   * Dispatches a `touchend` event on the first touch that is active.
    */
-  abstract touchEnd(): Promise<void>;
+  async touchEnd(): Promise<void> {
+    const touch = this.touches.shift();
+    if (!touch) {
+      throw new TouchError('Must start a new Touch first');
+    }
+    await touch.end();
+  }
 }

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

@@ -992,6 +992,11 @@ export abstract class Page extends EventEmitter<PageEvents> {
    */
   abstract getDefaultTimeout(): number;
 
+  /**
+   * Maximum navigation time in milliseconds.
+   */
+  abstract getDefaultNavigationTimeout(): number;
+
   /**
    * Creates a locator for the provided selector. See {@link Locator} for
    * details and supported actions.

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

@@ -102,13 +102,15 @@ export class BidiElementHandle<
   ): Promise<void> {
     // Locate all files and confirm that they exist.
     const path = environment.value.path;
-    files = files.map(file => {
-      if (path.win32.isAbsolute(file) || path.posix.isAbsolute(file)) {
-        return file;
-      } else {
-        return path.resolve(file);
-      }
-    });
+    if (path) {
+      files = files.map(file => {
+        if (path.win32.isAbsolute(file) || path.posix.isAbsolute(file)) {
+          return file;
+        } else {
+          return path.resolve(file);
+        }
+      });
+    }
     await this.frame.setFiles(this, files);
   }
 

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

@@ -193,6 +193,7 @@ export class BidiFrame extends Frame {
             text,
             args,
             getStackTraceLocations(entry.stackTrace),
+            this,
           ),
         );
       } else if (isJavaScriptLogEntry(entry)) {

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

@@ -12,6 +12,7 @@ import {
   Mouse,
   MouseButton,
   Touchscreen,
+  type TouchHandle,
   type KeyboardTypeOptions,
   type KeyDownOptions,
   type KeyPressOptions,
@@ -21,6 +22,7 @@ import {
   type MouseWheelOptions,
 } from '../api/Input.js';
 import {UnsupportedOperation} from '../common/Errors.js';
+import {TouchError} from '../common/Errors.js';
 import type {KeyInput} from '../common/USKeyboardLayout.js';
 
 import type {BidiPage} from './Page.js';
@@ -613,79 +615,87 @@ export class BidiMouse extends Mouse {
 /**
  * @internal
  */
-export class BidiTouchscreen extends Touchscreen {
+class BidiTouchHandle implements TouchHandle {
+  #started = false;
+  #x: number;
+  #y: number;
+  #bidiId: string;
   #page: BidiPage;
+  #touchScreen: BidiTouchscreen;
+  #properties: Bidi.Input.PointerCommonProperties;
 
-  constructor(page: BidiPage) {
-    super();
+  constructor(
+    page: BidiPage,
+    touchScreen: BidiTouchscreen,
+    id: number,
+    x: number,
+    y: number,
+    properties: Bidi.Input.PointerCommonProperties,
+  ) {
     this.#page = page;
+    this.#touchScreen = touchScreen;
+    this.#x = Math.round(x);
+    this.#y = Math.round(y);
+    this.#properties = properties;
+    this.#bidiId = `${InputId.Finger}_${id}`;
   }
 
-  override async touchStart(
-    x: number,
-    y: number,
-    options: BidiTouchMoveOptions = {},
-  ): Promise<void> {
+  async start(options: BidiTouchMoveOptions = {}): Promise<void> {
+    if (this.#started) {
+      throw new TouchError('Touch has already started');
+    }
     await this.#page.mainFrame().browsingContext.performActions([
       {
         type: SourceActionsType.Pointer,
-        id: InputId.Finger,
+        id: this.#bidiId,
         parameters: {
           pointerType: Bidi.Input.PointerType.Touch,
         },
         actions: [
           {
             type: ActionType.PointerMove,
-            x: Math.round(x),
-            y: Math.round(y),
+            x: this.#x,
+            y: this.#y,
             origin: options.origin,
           },
           {
+            ...this.#properties,
             type: ActionType.PointerDown,
             button: 0,
-            width: 0.5 * 2, // 2 times default touch radius.
-            height: 0.5 * 2, // 2 times default touch radius.
-            pressure: 0.5,
-            altitudeAngle: Math.PI / 2,
           },
         ],
       },
     ]);
+    this.#started = true;
   }
 
-  override async touchMove(
-    x: number,
-    y: number,
-    options: BidiTouchMoveOptions = {},
-  ): Promise<void> {
-    await this.#page.mainFrame().browsingContext.performActions([
+  move(x: number, y: number): Promise<void> {
+    const newX = Math.round(x);
+    const newY = Math.round(y);
+    return this.#page.mainFrame().browsingContext.performActions([
       {
         type: SourceActionsType.Pointer,
-        id: InputId.Finger,
+        id: this.#bidiId,
         parameters: {
           pointerType: Bidi.Input.PointerType.Touch,
         },
         actions: [
           {
+            ...this.#properties,
             type: ActionType.PointerMove,
-            x: Math.round(x),
-            y: Math.round(y),
-            origin: options.origin,
-            width: 0.5 * 2, // 2 times default touch radius.
-            height: 0.5 * 2, // 2 times default touch radius.
-            pressure: 0.5,
-            altitudeAngle: Math.PI / 2,
+            x: newX,
+            y: newY,
           },
         ],
       },
     ]);
   }
 
-  override async touchEnd(): Promise<void> {
+  async end(): Promise<void> {
     await this.#page.mainFrame().browsingContext.performActions([
       {
         type: SourceActionsType.Pointer,
-        id: InputId.Finger,
+        id: this.#bidiId,
         parameters: {
           pointerType: Bidi.Input.PointerType.Touch,
         },
@@ -697,5 +707,36 @@ export class BidiTouchscreen extends Touchscreen {
         ],
       },
     ]);
+    this.#touchScreen.removeHandle(this);
+  }
+}
+/**
+ * @internal
+ */
+export class BidiTouchscreen extends Touchscreen {
+  #page: BidiPage;
+  declare touches: BidiTouchHandle[];
+
+  constructor(page: BidiPage) {
+    super();
+    this.#page = page;
+  }
+
+  override async touchStart(
+    x: number,
+    y: number,
+    options: BidiTouchMoveOptions = {},
+  ): Promise<TouchHandle> {
+    const id = this.idGenerator();
+    const properties: Bidi.Input.PointerCommonProperties = {
+      width: 0.5 * 2, // 2 times default touch radius.
+      height: 0.5 * 2, // 2 times default touch radius.
+      pressure: 0.5,
+      altitudeAngle: Math.PI / 2,
+    };
+    const touch = new BidiTouchHandle(this.#page, this, id, x, y, properties);
+    await touch.start(options);
+    this.touches.push(touch);
+    return touch;
   }
 }

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

@@ -303,6 +303,10 @@ export class BidiPage extends Page {
     return this._timeoutSettings.timeout();
   }
 
+  override getDefaultNavigationTimeout(): number {
+    return this._timeoutSettings.navigationTimeout();
+  }
+
   override isJavaScriptEnabled(): boolean {
     return this.#cdpEmulationManager.javascriptEnabled;
   }

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

@@ -21,6 +21,7 @@ import {BrowserContextEvent} from '../api/BrowserContext.js';
 import {CDPSessionEvent, type CDPSession} from '../api/CDPSession.js';
 import type {Page} from '../api/Page.js';
 import type {Target} from '../api/Target.js';
+import type {DownloadBehavior} from '../common/DownloadBehavior.js';
 import type {Viewport} from '../common/Viewport.js';
 
 import {CdpBrowserContext} from './BrowserContext.js';
@@ -49,6 +50,7 @@ export class CdpBrowser extends BrowserBase {
     contextIds: string[],
     acceptInsecureCerts: boolean,
     defaultViewport?: Viewport | null,
+    downloadBehavior?: DownloadBehavior,
     process?: ChildProcess,
     closeCallback?: BrowserCloseCallback,
     targetFilterCallback?: TargetFilterCallback,
@@ -71,7 +73,7 @@ export class CdpBrowser extends BrowserBase {
         ignore: true,
       });
     }
-    await browser._attach();
+    await browser._attach(downloadBehavior);
     return browser;
   }
   #defaultViewport?: Viewport | null;
@@ -134,8 +136,11 @@ export class CdpBrowser extends BrowserBase {
     this.emit(BrowserEvent.Disconnected, undefined);
   };
 
-  async _attach(): Promise<void> {
+  async _attach(downloadBehavior: DownloadBehavior | undefined): Promise<void> {
     this.#connection.on(CDPSessionEvent.Disconnected, this.#emitDisconnected);
+    if (downloadBehavior) {
+      await this.#defaultContext.setDownloadBehavior(downloadBehavior);
+    }
     this.#targetManager.on(
       TargetManagerEvent.TargetAvailable,
       this.#onAttachedToTarget,
@@ -202,7 +207,7 @@ export class CdpBrowser extends BrowserBase {
   override async createBrowserContext(
     options: BrowserContextOptions = {},
   ): Promise<CdpBrowserContext> {
-    const {proxyServer, proxyBypassList} = options;
+    const {proxyServer, proxyBypassList, downloadBehavior} = options;
 
     const {browserContextId} = await this.#connection.send(
       'Target.createBrowserContext',
@@ -216,6 +221,9 @@ export class CdpBrowser extends BrowserBase {
       this,
       browserContextId,
     );
+    if (downloadBehavior) {
+      await context.setDownloadBehavior(downloadBehavior);
+    }
     this.#contexts.set(browserContextId, context);
     return context;
   }

package/front_end/third_party/puppeteer/package/src/cdp/BrowserConnector.ts

@@ -28,6 +28,7 @@ export async function _connectToCdpBrowser(
   const {
     acceptInsecureCerts = false,
     defaultViewport = DEFAULT_VIEWPORT,
+    downloadBehavior,
     targetFilter,
     _isPageTarget: isPageTarget,
     slowMo = 0,
@@ -55,6 +56,7 @@ export async function _connectToCdpBrowser(
     browserContextIds,
     acceptInsecureCerts,
     defaultViewport,
+    downloadBehavior,
     undefined,
     () => {
       return connection.send('Browser.close').catch(debugError);

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

@@ -10,6 +10,7 @@ import {
 } from '../api/Browser.js';
 import {BrowserContext} from '../api/BrowserContext.js';
 import type {Page} from '../api/Page.js';
+import type {DownloadBehavior} from '../common/DownloadBehavior.js';
 import {assert} from '../util/assert.js';
 
 import type {CdpBrowser} from './Browser.js';
@@ -98,4 +99,14 @@ export class CdpBrowserContext extends BrowserContext {
     assert(this.#id, 'Default BrowserContext cannot be closed!');
     await this.#browser._disposeContext(this.#id);
   }
+
+  public async setDownloadBehavior(
+    downloadBehavior: DownloadBehavior,
+  ): Promise<void> {
+    await this.#connection.send('Browser.setDownloadBehavior', {
+      behavior: downloadBehavior.policy,
+      downloadPath: downloadBehavior.downloadPath,
+      browserContextId: this.#id,
+    });
+  }
 }

package/front_end/third_party/puppeteer/package/src/cdp/ElementHandle.ts

@@ -101,25 +101,30 @@ export class CdpElementHandle<
   @bindIsolatedHandle
   override async uploadFile(
     this: CdpElementHandle<HTMLInputElement>,
-    ...filePaths: string[]
+    ...files: string[]
   ): Promise<void> {
     const isMultiple = await this.evaluate(element => {
       return element.multiple;
     });
     assert(
-      filePaths.length <= 1 || isMultiple,
+      files.length <= 1 || isMultiple,
       'Multiple file uploads only work with <input type=file multiple>',
     );
 
     // Locate all files and confirm that they exist.
     const path = environment.value.path;
-    const files = filePaths.map(filePath => {
-      if (path.win32.isAbsolute(filePath) || path.posix.isAbsolute(filePath)) {
-        return filePath;
-      } else {
-        return path.resolve(filePath);
-      }
-    });
+    if (path) {
+      files = files.map(filePath => {
+        if (
+          path.win32.isAbsolute(filePath) ||
+          path.posix.isAbsolute(filePath)
+        ) {
+          return filePath;
+        } else {
+          return path.resolve(filePath);
+        }
+      });
+    }
 
     /**
      * The zero-length array is a special case, it seems that

package/front_end/third_party/puppeteer/package/src/cdp/HTTPRequest.ts

@@ -46,6 +46,10 @@ export class CdpHTTPRequest extends HTTPRequest {
     return this.#client;
   }
 
+  override set client(newClient: CDPSession) {
+    this.#client = newClient;
+  }
+
   constructor(
     client: CDPSession,
     frame: Frame | null,

package/front_end/third_party/puppeteer/package/src/cdp/HTTPResponse.ts

@@ -5,7 +5,6 @@
  */
 import type {Protocol} from 'devtools-protocol';
 
-import type {CDPSession} from '../api/CDPSession.js';
 import type {Frame} from '../api/Frame.js';
 import {HTTPResponse, type RemoteAddress} from '../api/HTTPResponse.js';
 import {ProtocolError} from '../common/Errors.js';
@@ -19,7 +18,6 @@ import type {CdpHTTPRequest} from './HTTPRequest.js';
  * @internal
  */
 export class CdpHTTPResponse extends HTTPResponse {
-  #client: CDPSession;
   #request: CdpHTTPRequest;
   #contentPromise: Promise<Uint8Array> | null = null;
   #bodyLoadedDeferred = Deferred.create<void, Error>();
@@ -34,13 +32,11 @@ export class CdpHTTPResponse extends HTTPResponse {
   #timing: Protocol.Network.ResourceTiming | null;
 
   constructor(
-    client: CDPSession,
     request: CdpHTTPRequest,
     responsePayload: Protocol.Network.Response,
     extraInfo: Protocol.Network.ResponseReceivedExtraInfoEvent | null,
   ) {
     super();
-    this.#client = client;
     this.#request = request;
 
     this.#remoteAddress = {
@@ -128,7 +124,9 @@ export class CdpHTTPResponse extends HTTPResponse {
         .valueOrThrow()
         .then(async () => {
           try {
-            const response = await this.#client.send(
+            // Use CDPSession from corresponding request to retrieve body, as it's client
+            // might have been updated (e.g. for an adopted OOPIF).
+            const response = await this.#request.client.send(
               'Network.getResponseBody',
               {
                 requestId: this.#request.id,

package/front_end/third_party/puppeteer/package/src/cdp/Input.ts

@@ -13,6 +13,7 @@ import {
   Mouse,
   MouseButton,
   Touchscreen,
+  type TouchHandle,
   type KeyDownOptions,
   type KeyPressOptions,
   type KeyboardTypeOptions,
@@ -21,6 +22,7 @@ import {
   type MouseOptions,
   type MouseWheelOptions,
 } from '../api/Input.js';
+import {TouchError} from '../common/Errors.js';
 import {
   _keyDefinitions,
   type KeyDefinition,
@@ -552,57 +554,100 @@ export class CdpMouse extends Mouse {
 /**
  * @internal
  */
-export class CdpTouchscreen extends Touchscreen {
+class CdpTouchHandle implements TouchHandle {
+  #started = false;
+  #touchScreen: CdpTouchscreen;
+  #touchPoint: Protocol.Input.TouchPoint;
   #client: CDPSession;
   #keyboard: CdpKeyboard;
 
-  constructor(client: CDPSession, keyboard: CdpKeyboard) {
-    super();
+  constructor(
+    client: CDPSession,
+    touchScreen: CdpTouchscreen,
+    keyboard: CdpKeyboard,
+    touchPoint: Protocol.Input.TouchPoint,
+  ) {
     this.#client = client;
+    this.#touchScreen = touchScreen;
     this.#keyboard = keyboard;
+    this.#touchPoint = touchPoint;
   }
 
   updateClient(client: CDPSession): void {
     this.#client = client;
   }
 
-  override async touchStart(x: number, y: number): Promise<void> {
+  async start(): Promise<void> {
+    if (this.#started) {
+      throw new TouchError('Touch has already started');
+    }
     await this.#client.send('Input.dispatchTouchEvent', {
       type: 'touchStart',
-      touchPoints: [
-        {
-          x: Math.round(x),
-          y: Math.round(y),
-          radiusX: 0.5,
-          radiusY: 0.5,
-          force: 0.5,
-        },
-      ],
+      touchPoints: [this.#touchPoint],
       modifiers: this.#keyboard._modifiers,
     });
+    this.#started = true;
   }
 
-  override async touchMove(x: number, y: number): Promise<void> {
-    await this.#client.send('Input.dispatchTouchEvent', {
+  move(x: number, y: number): Promise<void> {
+    this.#touchPoint.x = Math.round(x);
+    this.#touchPoint.y = Math.round(y);
+    return this.#client.send('Input.dispatchTouchEvent', {
       type: 'touchMove',
-      touchPoints: [
-        {
-          x: Math.round(x),
-          y: Math.round(y),
-          radiusX: 0.5,
-          radiusY: 0.5,
-          force: 0.5,
-        },
-      ],
+      touchPoints: [this.#touchPoint],
       modifiers: this.#keyboard._modifiers,
     });
   }
 
-  override async touchEnd(): Promise<void> {
+  async end(): Promise<void> {
     await this.#client.send('Input.dispatchTouchEvent', {
       type: 'touchEnd',
-      touchPoints: [],
+      touchPoints: [this.#touchPoint],
       modifiers: this.#keyboard._modifiers,
     });
+    this.#touchScreen.removeHandle(this);
+  }
+}
+
+/**
+ * @internal
+ */
+export class CdpTouchscreen extends Touchscreen {
+  #client: CDPSession;
+  #keyboard: CdpKeyboard;
+  declare touches: CdpTouchHandle[];
+
+  constructor(client: CDPSession, keyboard: CdpKeyboard) {
+    super();
+    this.#client = client;
+    this.#keyboard = keyboard;
+  }
+
+  updateClient(client: CDPSession): void {
+    this.#client = client;
+    this.touches.forEach(t => {
+      t.updateClient(client);
+    });
+  }
+
+  override async touchStart(x: number, y: number): Promise<TouchHandle> {
+    const id = this.idGenerator();
+    const touchPoint: Protocol.Input.TouchPoint = {
+      x: Math.round(x),
+      y: Math.round(y),
+      radiusX: 0.5,
+      radiusY: 0.5,
+      force: 0.5,
+      id,
+    };
+    const touch = new CdpTouchHandle(
+      this.#client,
+      this,
+      this.#keyboard,
+      touchPoint,
+    );
+    await touch.start();
+    this.touches.push(touch);
+    return touch;
   }
 }