chrome-devtools-frontend 1.0.1721762 → 1.0.1726686

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

@@ -450,44 +450,89 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
       }),
       mergeMap(handle => {
         return from(
-          (handle as unknown as ElementHandle<HTMLElement>).evaluate(el => {
-            if (el instanceof HTMLSelectElement) {
-              return 'select';
-            }
-            if (el instanceof HTMLTextAreaElement) {
-              return 'typeable-input';
-            }
-            if (el instanceof HTMLInputElement) {
-              switch (el.type) {
+          (handle as unknown as ElementHandle<HTMLElement>).evaluate(
+            (el, newValue) => {
+              if (el instanceof HTMLSelectElement) {
+                if (
+                  !Array.from(el.options).some(option => {
+                    return option.value === newValue;
+                  })
+                ) {
+                  throw new Error(
+                    `Element has no option with the value "${newValue}".`,
+                  );
+                }
+                return 'select';
+              }
+              if (el instanceof HTMLTextAreaElement) {
+                if (el.readOnly) {
+                  throw new Error('Element is read-only.');
+                }
+                return 'typeable-input';
+              }
+              if (el instanceof HTMLInputElement) {
+                if (el.type === 'checkbox' || el.type === 'radio') {
+                  return 'checkable-input';
+                }
+                if (
+                  el.readOnly &&
+                  [
+                    'text',
+                    'search',
+                    'url',
+                    'tel',
+                    'email',
+                    'password',
+                    'number',
+                    'date',
+                    'month',
+                    'week',
+                    'time',
+                    'datetime-local',
+                  ].includes(el.type)
+                ) {
+                  throw new Error('Element is read-only.');
+                }
+                if (el.type !== 'file' && String(newValue) !== '') {
+                  // Validate without modifying the element before a possible retry.
+                  const probe = document.createElement('input');
+                  probe.type = el.type;
+                  probe.value = String(newValue);
+                  if (probe.value === '') {
+                    throw new Error(
+                      `Element did not accept the value "${newValue}".`,
+                    );
+                  }
+                }
+                switch (el.type) {
+                  case 'text':
+                  case 'url':
+                  case 'tel':
+                  case 'search':
+                  case 'password':
+                  case 'number':
+                  case 'email':
+                    return 'typeable-input';
+                  default:
+                    return 'other-input';
+                }
+              }
+
+              switch (el.getAttribute('role')) {
                 case 'checkbox':
                 case 'radio':
+                case 'switch':
                   return 'checkable-input';
-                case 'text':
-                case 'url':
-                case 'tel':
-                case 'search':
-                case 'password':
-                case 'number':
-                case 'email':
-                  return 'typeable-input';
-                default:
-                  return 'other-input';
               }
-            }
-
-            switch (el.getAttribute('role')) {
-              case 'checkbox':
-              case 'radio':
-              case 'switch':
-                return 'checkable-input';
-            }
 
-            if (el.isContentEditable) {
-              return 'contenteditable';
-            }
+              if (el.isContentEditable) {
+                return 'contenteditable';
+              }
 
-            return 'unknown';
-          }),
+              return 'unknown';
+            },
+            value,
+          ),
         )
           .pipe(
             mergeMap(inputType => {
@@ -811,6 +856,8 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    * method is chosen based on the type. `contenteditable`, select, textarea and
    * input elements are supported. For checkboxes, radio buttons and switches
    * specify a boolean value.
+   * Read-only elements and values the element does not accept are rejected without
+   * modifying the element.
    */
   fill<ElementType extends Element>(
     this: Locator<ElementType>,

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

@@ -20,7 +20,7 @@ import {
   InterceptResolutionAction,
 } from '../api/HTTPRequest.js';
 import {PageEvent} from '../api/Page.js';
-import type {Logger} from '../common/Debug.js';
+import {DEBUG_PREFIXES, type Logger} from '../common/Debug.js';
 import {UnsupportedOperation} from '../common/Errors.js';
 import {stringToBase64} from '../util/encoding.js';
 
@@ -174,6 +174,15 @@ export class BidiHTTPRequest extends HTTPRequest {
     return await this.#request.fetchPostData();
   }
 
+  override async content(): Promise<Uint8Array | undefined> {
+    try {
+      return await this.#request.getRequestContent();
+    } catch (err) {
+      this.#logger?.(DEBUG_PREFIXES.error)?.(err);
+      return;
+    }
+  }
+
   override headers(): Record<string, string> {
     // Callers should not be allowed to mutate internal structure.
     const headers: Record<string, string> = {};
@@ -315,18 +324,29 @@ export class BidiHTTPRequest extends HTTPRequest {
     const credentials = this.#frame.page()._credentials;
     if (credentials && !this.#authenticationHandled) {
       this.#authenticationHandled = true;
-      void this.#request.continueWithAuth({
-        action: 'provideCredentials',
-        credentials: {
-          type: 'password',
-          username: credentials.username,
-          password: credentials.password,
-        },
-      });
+      await this.#request
+        .continueWithAuth({
+          action: 'provideCredentials',
+          credentials: {
+            type: 'password',
+            username: credentials.username,
+            password: credentials.password,
+          },
+        })
+        .catch(error => {
+          // The request may have been canceled or the page closed before the
+          // auth challenge could be answered. Tolerate these errors instead of
+          // rejecting, which would surface as an unhandled rejection.
+          this.#logger(DEBUG_PREFIXES.error)?.(error);
+        });
     } else {
-      void this.#request.continueWithAuth({
-        action: 'cancel',
-      });
+      await this.#request
+        .continueWithAuth({
+          action: 'cancel',
+        })
+        .catch(error => {
+          this.#logger(DEBUG_PREFIXES.error)?.(error);
+        });
     }
   };
 

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

@@ -268,7 +268,7 @@ const getBidiKeyValue = (key: KeyInput) => {
     case 'BracketRight':
       return ']';
     case 'Quote':
-      return '"';
+      return "'";
     default:
       throw new Error(`Unknown key: "${key}"`);
   }

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

@@ -32,6 +32,7 @@ import {
   PageEvent,
   type NewDocumentScriptEvaluation,
   type ScreenshotOptions,
+  type TabInfo,
 } from '../api/Page.js';
 import type {Target} from '../api/Target.js';
 import {Coverage} from '../cdp/Coverage.js';
@@ -252,6 +253,10 @@ export class BidiPage extends Page {
     return this.#frame.browsingContext.windowId;
   }
 
+  override tabInfo(): Promise<TabInfo | null> {
+    throw new UnsupportedOperation();
+  }
+
   override openDevTools(): Promise<Page> {
     throw new UnsupportedOperation();
   }
@@ -343,7 +348,14 @@ export class BidiPage extends Page {
     return this.#frame.browsingContext.isJavaScriptEnabled();
   }
 
-  override async setGeolocation(options: GeolocationOptions): Promise<void> {
+  override async setGeolocation(
+    options: GeolocationOptions | null,
+  ): Promise<void> {
+    if (options === null) {
+      return await this.#frame.browsingContext.setGeolocationOverride({
+        coordinates: null,
+      });
+    }
     const {longitude, latitude, accuracy = 0} = options;
     if (longitude < -180 || longitude > 180) {
       throw new Error(
@@ -501,7 +513,11 @@ export class BidiPage extends Page {
       scale,
       preferCSSPageSize,
     } = parsePDFOptions(options, 'cm');
-    const pageRanges = ranges ? ranges.split(', ') : [];
+    const pageRanges = ranges
+      ? ranges.split(',').map(range => {
+          return range.trim();
+        })
+      : [];
 
     await firstValueFrom(
       from(

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

@@ -6,7 +6,7 @@
 
 import * as Bidi from 'webdriver-bidi-protocol';
 
-import {ProtocolError, UnsupportedOperation} from '../../common/Errors.js';
+import {ProtocolError} from '../../common/Errors.js';
 import {EventEmitter} from '../../common/EventEmitter.js';
 import {inertIfDisposed} from '../../util/decorators.js';
 import {DisposableStack, disposeSymbol} from '../../util/disposable.js';
@@ -40,7 +40,7 @@ export class Request extends EventEmitter<{
   }
 
   #responseContentPromise: Promise<Uint8Array<ArrayBufferLike>> | null = null;
-  #requestBodyPromise: Promise<string> | null = null;
+  #requestContentPromise: Promise<Uint8Array<ArrayBuffer>> | null = null;
   #error?: string;
   #redirect?: Request;
   #response?: Bidi.Network.ResponseData;
@@ -119,6 +119,8 @@ export class Request extends EventEmitter<{
         return;
       }
       this.#error = event.errorText;
+      this.#event.request.headers = event.request.headers;
+      this.#event.request.timings = event.request.timings;
       this.emit('error', this.#error);
       this.dispose();
     });
@@ -131,6 +133,7 @@ export class Request extends EventEmitter<{
         return;
       }
       this.#response = event.response;
+      this.#event.request.headers = event.request.headers;
       this.#event.request.timings = event.request.timings;
       this.emit('response', this.#response);
     });
@@ -143,6 +146,7 @@ export class Request extends EventEmitter<{
         return;
       }
       this.#response = event.response;
+      this.#event.request.headers = event.request.headers;
       this.#event.request.timings = event.request.timings;
       this.emit('success', this.#response);
       // In case this is a redirect.
@@ -259,27 +263,31 @@ export class Request extends EventEmitter<{
     });
   }
 
-  async fetchPostData(): Promise<string | undefined> {
+  async getRequestContent(): Promise<Uint8Array | undefined> {
     if (!this.hasPostData) {
       return undefined;
     }
-    if (!this.#requestBodyPromise) {
-      this.#requestBodyPromise = (async () => {
+    if (!this.#requestContentPromise) {
+      this.#requestContentPromise = (async () => {
         const data = await this.#session.send('network.getData', {
           dataType: Bidi.Network.DataType.Request,
           request: this.id,
         });
-        if (data.result.bytes.type === 'string') {
-          return data.result.bytes.value;
-        }
-
-        // TODO: support base64 response.
-        throw new UnsupportedOperation(
-          `Collected request body data of type ${data.result.bytes.type} is not supported`,
+        return stringToTypedArray(
+          data.result.bytes.value,
+          data.result.bytes.type === 'base64',
         );
       })();
     }
-    return await this.#requestBodyPromise;
+    return await this.#requestContentPromise;
+  }
+
+  async fetchPostData(): Promise<string | undefined> {
+    const content = await this.getRequestContent();
+    if (content === undefined) {
+      return undefined;
+    }
+    return new TextDecoder().decode(content);
   }
 
   async getResponseContent(): Promise<Uint8Array> {

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

@@ -135,7 +135,8 @@ export interface SerializedAXNode {
    * Get an ElementHandle for this AXNode if available.
    *
    * If the underlying DOM element has been disposed, the method might return an
-   * error.
+   * error. If the frame has navigated to a new document since the snapshot,
+   * the method returns `null`.
    */
   elementHandle(): Promise<ElementHandle | null>;
 }
@@ -387,6 +388,7 @@ class AXNode {
   #ignored: boolean;
   #cachedHasFocusableChild?: boolean;
   #realm: Realm;
+  #loaderId: string;
 
   constructor(realm: Realm, payload: Protocol.Accessibility.AXNode) {
     this.payload = payload;
@@ -397,6 +399,7 @@ class AXNode {
       ? this.payload.description.value
       : undefined;
     this.#realm = realm;
+    this.#loaderId = (realm.environment as CdpFrame)._loaderId;
     for (const property of this.payload.properties || []) {
       if (property.name === 'editable') {
         this.#richlyEditable = property.value.value === 'richtext';
@@ -620,6 +623,13 @@ class AXNode {
         if (!this.payload.backendDOMNodeId) {
           return null;
         }
+        // After a navigation, the backend node ID can belong to a different
+        // node in the new document, for example in a new renderer process.
+        if (
+          (this.#realm.environment as CdpFrame)._loaderId !== this.#loaderId
+        ) {
+          return null;
+        }
         using handle = await this.#realm.adoptBackendNode(
           this.payload.backendDOMNodeId,
         );
@@ -642,7 +652,7 @@ class AXNode {
       backendNodeId: this.payload.backendDOMNodeId,
       // LoaderId is an experimental mechanism to establish unique IDs across
       // navigations.
-      loaderId: (this.#realm.environment as CdpFrame)._loaderId,
+      loaderId: this.#loaderId,
     };
 
     type UserStringProperty =

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

@@ -29,6 +29,7 @@ import {
   type LaunchPWAOptions,
   type GetPWAStateOptions,
   type PWAState,
+  type NetworkRestrictions,
 } from '../api/Browser.js';
 import {BrowserContextEvent} from '../api/BrowserContext.js';
 import {CDPSessionEvent} from '../api/CDPSession.js';
@@ -106,16 +107,6 @@ export class CdpBrowser extends BrowserBase {
       logger,
     );
 
-    if (allowlist) {
-      const version = await browser.#getVersion();
-      const majorVersion = parseInt(
-        version.product.match(/\d+/)?.[0] ?? '0',
-        10,
-      );
-      if (majorVersion < 149) {
-        throw new Error('The allowlist option require Chrome 149 or greater.');
-      }
-    }
     if (acceptInsecureCerts) {
       await connection.send('Security.setIgnoreCertificateErrors', {
         ignore: true,
@@ -246,6 +237,21 @@ export class CdpBrowser extends BrowserBase {
     return this.#targetManager;
   }
 
+  override async restrictNetwork(
+    conditions?: NetworkRestrictions | null,
+  ): Promise<void> {
+    await this.#targetManager.setNetworkConditions(conditions);
+    // Only update the state once the target manager has accepted the new
+    // conditions so that failures (e.g. invalid URL patterns) do not leave
+    // the browser and connection out of sync with the target manager.
+    this.#hasNetworkRestrictions = Boolean(
+      (conditions?.blocklist && conditions.blocklist.length > 0) ||
+      (conditions?.allowlist && conditions.allowlist.length > 0),
+    );
+    this.#connection.rejectEmulateNetworkConditionsCalls =
+      this.#hasNetworkRestrictions;
+  }
+
   #setIsPageTargetCallback(isPageTargetCallback?: IsPageTargetCallback): void {
     this.#isPageTargetCallback =
       isPageTargetCallback ||
@@ -502,26 +508,43 @@ export class CdpBrowser extends BrowserBase {
     path: string,
     options?: ExtensionInstallOptions,
   ): Promise<string> {
+    const existingTargetIds = new Set(
+      this._targetManager().getDiscoveredTargetInfos().keys(),
+    );
     const {id} = await this.#connection.send('Extensions.loadUnpacked', {
       path,
       enableInIncognito: options?.enabledInIncognito ?? false,
     });
+    await this.#destroyExtensionServiceWorkerTargets(id, existingTargetIds);
     this.#extensions.delete(id);
     return id;
   }
 
   override async uninstallExtension(id: string): Promise<void> {
     await this.#connection.send('Extensions.uninstall', {id});
+    await this.#destroyExtensionServiceWorkerTargets(id);
+    this.#extensions.delete(id);
+  }
 
-    // Currently sending the Extensions.uninstall command does not trigger
-    // the Target.targetDestroyed event for service workers. This causes
-    // flakiness in the extension tests.
+  async #destroyExtensionServiceWorkerTargets(
+    id: string,
+    existingTargetIds?: ReadonlySet<string>,
+  ): Promise<void> {
+    // Currently sending Extensions.loadUnpacked (when re-installing an
+    // existing extension) or Extensions.uninstall does not trigger the
+    // Target.targetDestroyed event for replaced/uninstalled service workers.
+    // This causes flakiness in extension tests and leaves stale targets in
+    // browser.targets().
     // TODO(nroscino): Remove this once the event is correctly emitted.
     const targetDestroyedPromises = [];
     for (const [targetId, targetInfo] of this._targetManager()
       .getDiscoveredTargetInfos()
       .entries()) {
-      if (targetInfo.url.includes(id) && targetInfo.type === 'service_worker') {
+      if (
+        (!existingTargetIds || existingTargetIds.has(targetId)) &&
+        targetInfo.url.includes(id) &&
+        targetInfo.type === 'service_worker'
+      ) {
         this._targetManager().addToIgnoreTarget(targetId);
         targetDestroyedPromises.push(
           new Promise(resolve => {
@@ -536,8 +559,6 @@ export class CdpBrowser extends BrowserBase {
       }
     }
     await Promise.all(targetDestroyedPromises);
-
-    this.#extensions.delete(id);
   }
 
   override async installPWA(options: InstallPWAOptions): Promise<string> {

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

@@ -546,19 +546,22 @@ export class EmulationManager implements ClientProvider {
     if (!state.active) {
       return;
     }
-    await client.send(
-      'Emulation.setGeolocationOverride',
-      state.geoLocation
-        ? {
-            longitude: state.geoLocation.longitude,
-            latitude: state.geoLocation.latitude,
-            accuracy: state.geoLocation.accuracy,
-          }
-        : undefined,
-    );
+    if (!state.geoLocation) {
+      await client.send('Emulation.clearGeolocationOverride');
+      return;
+    }
+    await client.send('Emulation.setGeolocationOverride', {
+      longitude: state.geoLocation.longitude,
+      latitude: state.geoLocation.latitude,
+      accuracy: state.geoLocation.accuracy,
+    });
   }
 
-  async setGeolocation(options: GeolocationOptions): Promise<void> {
+  async setGeolocation(options: GeolocationOptions | null): Promise<void> {
+    if (options === null) {
+      await this.#geoLocationState.setState({active: true});
+      return;
+    }
     const {longitude, latitude, accuracy = 0} = options;
     if (longitude < -180 || longitude > 180) {
       throw new Error(

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

@@ -199,7 +199,13 @@ export class CdpFrame extends Frame {
       if (error) {
         throw error;
       }
-      return await watcher.navigationResponse();
+      const result = await Deferred.race<
+        Error | HTTPResponse | null | undefined
+      >([watcher.terminationPromise(), watcher.navigationResponse()]);
+      if (result instanceof Error) {
+        throw result;
+      }
+      return result ?? null;
     } finally {
       watcher.dispose();
     }