chrome-devtools-frontend 1.0.1721762 → 1.0.1726686

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

@@ -11,6 +11,7 @@ import {
   type ContinueRequestOverridesInternal,
   headersArray,
   HTTPRequest,
+  InterceptResolutionAction,
   type ResourceType,
   type ResponseForRequestInternal,
   STATUS_TEXTS,
@@ -25,6 +26,20 @@ import {
 
 import type {CdpHTTPResponse} from './HTTPResponse.js';
 
+type InterceptResolution =
+  | {
+      action: InterceptResolutionAction.Continue;
+      overrides: ContinueRequestOverridesInternal;
+    }
+  | {
+      action: InterceptResolutionAction.Respond;
+      response: Partial<ResponseForRequestInternal>;
+    }
+  | {
+      action: InterceptResolutionAction.Abort;
+      errorReason: Protocol.Network.ErrorReason | null;
+    };
+
 /**
  * @internal
  */
@@ -34,6 +49,7 @@ export class CdpHTTPRequest extends HTTPRequest {
   declare _response: CdpHTTPResponse | null;
 
   #client: CDPSession;
+  #fetchClient: CDPSession;
   #isNavigationRequest: boolean;
 
   #url: string;
@@ -42,10 +58,13 @@ export class CdpHTTPRequest extends HTTPRequest {
   #method: string;
   #hasPostData = false;
   #postData?: string;
+  #postDataBytes?: Uint8Array;
+  #hasCompletePostData = false;
   #headers: Record<string, string> = {};
   #frame: Frame | null;
   #initiator?: Protocol.Network.Initiator;
   #logger: Logger;
+  #resolution: InterceptResolution | null = null;
 
   override get client(): CDPSession {
     return this.#client;
@@ -55,6 +74,17 @@ export class CdpHTTPRequest extends HTTPRequest {
     this.#client = newClient;
   }
 
+  /**
+   * @internal
+   */
+  get _fetchClient(): CDPSession {
+    return this.#fetchClient;
+  }
+
+  set _fetchClient(fetchClient: CDPSession) {
+    this.#fetchClient = fetchClient;
+  }
+
   constructor(
     client: CDPSession,
     frame: Frame | null,
@@ -88,10 +118,12 @@ export class CdpHTTPRequest extends HTTPRequest {
     },
     redirectChain: CdpHTTPRequest[],
     logger: Logger,
+    fetchClient: CDPSession = client,
   ) {
     super();
     this.#logger = logger;
     this.#client = client;
+    this.#fetchClient = fetchClient;
     this.id = data.requestId;
     this.#isNavigationRequest =
       data.requestId === data.loaderId && data.type === 'Document';
@@ -103,17 +135,19 @@ export class CdpHTTPRequest extends HTTPRequest {
       data.request.postDataEntries &&
       data.request.postDataEntries.length > 0
     ) {
-      this.#postData = new TextDecoder().decode(
-        mergeUint8Arrays(
-          data.request.postDataEntries
-            .map(entry => {
-              return entry.bytes ? stringToTypedArray(entry.bytes, true) : null;
-            })
-            .filter((entry): entry is Uint8Array => {
-              return entry !== null;
-            }),
-        ),
+      this.#hasCompletePostData = data.request.postDataEntries.every(entry => {
+        return !!entry.bytes;
+      });
+      this.#postDataBytes = mergeUint8Arrays(
+        data.request.postDataEntries
+          .map(entry => {
+            return entry.bytes ? stringToTypedArray(entry.bytes, true) : null;
+          })
+          .filter(entry => {
+            return entry !== null;
+          }),
       );
+      this.#postData = new TextDecoder().decode(this.#postDataBytes);
     } else {
       this.#postData = data.request.postData;
     }
@@ -154,11 +188,28 @@ export class CdpHTTPRequest extends HTTPRequest {
   }
 
   override async fetchPostData(): Promise<string | undefined> {
+    const content = await this.content();
+    if (content === undefined) {
+      return undefined;
+    }
+    return new TextDecoder().decode(content);
+  }
+
+  override async content(): Promise<Uint8Array | undefined> {
+    if (
+      this._interceptionId !== undefined &&
+      this.interception.enabled &&
+      !this.isInterceptResolutionHandled() &&
+      this.#hasCompletePostData
+    ) {
+      // Chrome may wait for the paused request to continue before returning data.
+      return this.#postDataBytes;
+    }
     try {
       const result = await this.#client.send('Network.getRequestPostData', {
         requestId: this.id,
       });
-      return result.postData;
+      return stringToTypedArray(result.postData, result.base64Encoded);
     } catch (err) {
       this.#logger?.(DEBUG_PREFIXES.error)?.(err);
       return;
@@ -211,6 +262,7 @@ export class CdpHTTPRequest extends HTTPRequest {
   ): Promise<void> {
     const {url, method, postData, headers} = overrides;
     this.interception.handled = true;
+    this.#resolution = {action: InterceptResolutionAction.Continue, overrides};
 
     const postDataBinaryBase64 = postData
       ? stringToBase64(postData)
@@ -221,7 +273,7 @@ export class CdpHTTPRequest extends HTTPRequest {
         'HTTPRequest is missing _interceptionId needed for Fetch.continueRequest',
       );
     }
-    await this.#client
+    await this.#fetchClient
       .send('Fetch.continueRequest', {
         requestId: this._interceptionId,
         url,
@@ -237,6 +289,7 @@ export class CdpHTTPRequest extends HTTPRequest {
 
   async _respond(response: Partial<ResponseForRequestInternal>): Promise<void> {
     this.interception.handled = true;
+    this.#resolution = {action: InterceptResolutionAction.Respond, response};
 
     let parsedBody:
       | {
@@ -251,6 +304,9 @@ export class CdpHTTPRequest extends HTTPRequest {
     const responseHeaders: Record<string, string | string[]> = {};
     if (response.headers) {
       for (const [header, value] of Object.entries(response.headers)) {
+        if (value === undefined) {
+          continue;
+        }
         responseHeaders[header.toLowerCase()] = Array.isArray(value)
           ? value.map(item => {
               return String(item);
@@ -271,7 +327,7 @@ export class CdpHTTPRequest extends HTTPRequest {
         'HTTPRequest is missing _interceptionId needed for Fetch.fulfillRequest',
       );
     }
-    await this.#client
+    await this.#fetchClient
       .send('Fetch.fulfillRequest', {
         requestId: this._interceptionId,
         responseCode: status,
@@ -289,12 +345,13 @@ export class CdpHTTPRequest extends HTTPRequest {
     errorReason: Protocol.Network.ErrorReason | null,
   ): Promise<void> {
     this.interception.handled = true;
+    this.#resolution = {action: InterceptResolutionAction.Abort, errorReason};
     if (this._interceptionId === undefined) {
       throw new Error(
         'HTTPRequest is missing _interceptionId needed for Fetch.failRequest',
       );
     }
-    await this.#client
+    await this.#fetchClient
       .send('Fetch.failRequest', {
         requestId: this._interceptionId,
         errorReason: errorReason || 'Failed',
@@ -303,4 +360,34 @@ export class CdpHTTPRequest extends HTTPRequest {
         return handleError(error, this.#logger);
       });
   }
+
+  /**
+   * The overrides sent with `Fetch.continueRequest`, or an empty object if
+   * the request was not continued.
+   *
+   * @internal
+   */
+  get _continueOverrides(): ContinueRequestOverridesInternal {
+    return this.#resolution?.action === InterceptResolutionAction.Continue
+      ? this.#resolution.overrides
+      : {};
+  }
+
+  /**
+   * Re-sends the resolution the user already chose to the current
+   * `_interceptionId`. Used when Chrome restarts a request under a new
+   * interception id.
+   *
+   * @internal
+   */
+  async _replayInterception(): Promise<void> {
+    switch (this.#resolution?.action) {
+      case InterceptResolutionAction.Continue:
+        return await this._continue(this.#resolution.overrides);
+      case InterceptResolutionAction.Respond:
+        return await this._respond(this.#resolution.response);
+      case InterceptResolutionAction.Abort:
+        return await this._abort(this.#resolution.errorReason);
+    }
+  }
 }

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

@@ -6,6 +6,8 @@
 
 import type {Protocol} from 'devtools-protocol';
 
+import {CDPSession} from '../api/CDPSession.js';
+
 import {CdpHTTPRequest} from './HTTPRequest.js';
 
 /**
@@ -28,9 +30,23 @@ export type FetchRequestId = string;
 export interface RedirectInfo {
   event: Protocol.Network.RequestWillBeSentEvent;
   fetchRequestId?: FetchRequestId;
+  client: CDPSession;
+  fetchClient: CDPSession;
 }
 type RedirectInfoList = RedirectInfo[];
 
+/**
+ * A stored event and the session that sent it. A worker request can get its
+ * Network events on the worker session and its Fetch events on the page
+ * session.
+ *
+ * @internal
+ */
+export interface SessionEvent<T> {
+  event: T;
+  client: CDPSession;
+}
+
 /**
  * @internal
  */
@@ -76,11 +92,11 @@ export class NetworkEventManager {
    */
   #requestWillBeSentMap = new Map<
     NetworkRequestId,
-    Protocol.Network.RequestWillBeSentEvent
+    SessionEvent<Protocol.Network.RequestWillBeSentEvent>
   >();
   #requestPausedMap = new Map<
     NetworkRequestId,
-    Protocol.Fetch.RequestPausedEvent
+    SessionEvent<Protocol.Fetch.RequestPausedEvent>
   >();
   #httpRequestsMap = new Map<NetworkRequestId, CdpHTTPRequest>();
   #requestWillBeSentExtraInfoMap = new Map<
@@ -167,13 +183,14 @@ export class NetworkEventManager {
   storeRequestWillBeSent(
     networkRequestId: NetworkRequestId,
     event: Protocol.Network.RequestWillBeSentEvent,
+    client: CDPSession,
   ): void {
-    this.#requestWillBeSentMap.set(networkRequestId, event);
+    this.#requestWillBeSentMap.set(networkRequestId, {event, client});
   }
 
   getRequestWillBeSent(
     networkRequestId: NetworkRequestId,
-  ): Protocol.Network.RequestWillBeSentEvent | undefined {
+  ): SessionEvent<Protocol.Network.RequestWillBeSentEvent> | undefined {
     return this.#requestWillBeSentMap.get(networkRequestId);
   }
 
@@ -183,7 +200,7 @@ export class NetworkEventManager {
 
   getRequestPaused(
     networkRequestId: NetworkRequestId,
-  ): Protocol.Fetch.RequestPausedEvent | undefined {
+  ): SessionEvent<Protocol.Fetch.RequestPausedEvent> | undefined {
     return this.#requestPausedMap.get(networkRequestId);
   }
 
@@ -194,8 +211,9 @@ export class NetworkEventManager {
   storeRequestPaused(
     networkRequestId: NetworkRequestId,
     event: Protocol.Fetch.RequestPausedEvent,
+    client: CDPSession,
   ): void {
-    this.#requestPausedMap.set(networkRequestId, event);
+    this.#requestPausedMap.set(networkRequestId, {event, client});
   }
 
   getRequest(networkRequestId: NetworkRequestId): CdpHTTPRequest | undefined {
@@ -237,6 +255,8 @@ export class NetworkEventManager {
           dataType: 'Map',
           value: Array.from(value.entries()), // or with spread: value: [...value]
         };
+      } else if (value instanceof CDPSession) {
+        return value.id();
       } else if (value instanceof CdpHTTPRequest) {
         return {
           dataType: 'CdpHTTPRequest',

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

@@ -420,17 +420,27 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
     ) {
       const {requestId: networkRequestId} = event;
 
-      this.#networkEventManager.storeRequestWillBeSent(networkRequestId, event);
+      this.#networkEventManager.storeRequestWillBeSent(
+        networkRequestId,
+        event,
+        client,
+      );
 
       /**
        * CDP may have sent a Fetch.requestPaused event already. Check for it.
+       * It may come from another session, e.g. the page for a worker request.
        */
-      const requestPausedEvent =
+      const requestPaused =
         this.#networkEventManager.getRequestPaused(networkRequestId);
-      if (requestPausedEvent) {
-        const {requestId: fetchRequestId} = requestPausedEvent;
+      if (requestPaused) {
+        const {event: requestPausedEvent, client: fetchClient} = requestPaused;
         this.#patchRequestEventHeaders(event, requestPausedEvent);
-        this.#onRequest(client, event, fetchRequestId);
+        this.#onRequest(
+          client,
+          event,
+          requestPausedEvent.requestId,
+          fetchClient,
+        );
         this.#networkEventManager.forgetRequestPaused(networkRequestId);
       }
 
@@ -495,27 +505,88 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
       return;
     }
 
-    const requestWillBeSentEvent = (() => {
-      const requestWillBeSentEvent =
-        this.#networkEventManager.getRequestWillBeSent(networkRequestId);
-
-      // redirect requests have the same `requestId`,
-      if (
-        requestWillBeSentEvent &&
-        (requestWillBeSentEvent.request.url !== event.request.url ||
-          requestWillBeSentEvent.request.method !== event.request.method)
-      ) {
-        this.#networkEventManager.forgetRequestWillBeSent(networkRequestId);
+    const requestWillBeSent =
+      this.#networkEventManager.getRequestWillBeSent(networkRequestId);
+    if (!requestWillBeSent) {
+      // Chrome may restart a request and send a second Fetch.requestPaused
+      // for a request Puppeteer already emitted (crbug.com/1196004). Repoint
+      // that request instead of emitting a duplicate that never finishes.
+      const request = this.#networkEventManager.getRequest(networkRequestId);
+      if (request && this.#isRestartedRequest(request, event)) {
+        this.#onRequestRestarted(client, request, fetchRequestId);
         return;
       }
-      return requestWillBeSentEvent;
-    })();
+      this.#networkEventManager.storeRequestPaused(
+        networkRequestId,
+        event,
+        client,
+      );
+      return;
+    }
+    const {event: requestWillBeSentEvent, client: networkClient} =
+      requestWillBeSent;
 
-    if (requestWillBeSentEvent) {
-      this.#patchRequestEventHeaders(requestWillBeSentEvent, event);
-      this.#onRequest(client, requestWillBeSentEvent, fetchRequestId);
-    } else {
-      this.#networkEventManager.storeRequestPaused(networkRequestId, event);
+    // Redirect requests have the same `requestId`. Wait for the redirect's
+    // own Network.requestWillBeSent.
+    if (
+      requestWillBeSentEvent.request.url !== event.request.url ||
+      requestWillBeSentEvent.request.method !== event.request.method
+    ) {
+      this.#networkEventManager.forgetRequestWillBeSent(networkRequestId);
+      this.#networkEventManager.storeRequestPaused(
+        networkRequestId,
+        event,
+        client,
+      );
+      return;
+    }
+
+    this.#patchRequestEventHeaders(requestWillBeSentEvent, event);
+    this.#onRequest(
+      networkClient,
+      requestWillBeSentEvent,
+      fetchRequestId,
+      client,
+    );
+  }
+
+  #isRestartedRequest(
+    request: CdpHTTPRequest,
+    event: Protocol.Fetch.RequestPausedEvent,
+  ): boolean {
+    // Only a request with no response yet can be restarted. Redirects are
+    // excluded by id because in a same-URL redirect, the pause can arrive
+    // before the response does.
+    if (event.redirectedRequestId || request.response()) {
+      return false;
+    }
+    // Chrome usually pauses the request the user continued to, but can pause
+    // the original if it restarts before the overrides are applied.
+    const overrides = request._continueOverrides;
+    const eventUrl = event.request.url + (event.request.urlFragment ?? '');
+    const urlMatches =
+      eventUrl === request.url() ||
+      eventUrl === overrides.url ||
+      event.request.url === overrides.url;
+    const methodMatches =
+      event.request.method === request.method() ||
+      event.request.method === overrides.method;
+    return urlMatches && methodMatches;
+  }
+
+  #onRequestRestarted(
+    client: CDPSession,
+    request: CdpHTTPRequest,
+    fetchRequestId: FetchRequestId,
+  ): void {
+    request._interceptionId = fetchRequestId;
+    request._fetchClient = client;
+    if (this.#userRequestInterceptionEnabled) {
+      // If the user already resolved the interception, the restarted job needs
+      // the same resolution or the request hangs.
+      void request._replayInterception().catch(err => {
+        this.#logger?.(DEBUG_PREFIXES.error)?.(err);
+      });
     }
   }
 
@@ -557,6 +628,7 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
     client: CDPSession,
     event: Protocol.Network.RequestWillBeSentEvent,
     fetchRequestId?: FetchRequestId,
+    fetchClient = client,
     fromMemoryCache = false,
   ): void {
     let redirectChain: CdpHTTPRequest[] = [];
@@ -577,6 +649,8 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
           this.#networkEventManager.queueRedirectInfo(event.requestId, {
             event,
             fetchRequestId,
+            client,
+            fetchClient,
           });
           return;
         }
@@ -614,6 +688,7 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
       event,
       redirectChain,
       this.#logger,
+      fetchClient,
     );
 
     const extraInfo = this.#networkEventManager
@@ -625,6 +700,7 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
 
     request._fromMemoryCache = fromMemoryCache;
     this.#networkEventManager.storeRequest(event.requestId, request);
+    this.#networkEventManager.forgetRequestWillBeSent(event.requestId);
     this.emit(NetworkManagerEvent.Request, request);
     void request.finalizeInterceptions();
   }
@@ -645,8 +721,9 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
     client: CDPSession,
     event: Protocol.Network.RequestServedFromCacheEvent,
   ): void {
-    const requestWillBeSentEvent =
-      this.#networkEventManager.getRequestWillBeSent(event.requestId);
+    const requestWillBeSent = this.#networkEventManager.getRequestWillBeSent(
+      event.requestId,
+    );
     let request = this.#networkEventManager.getRequest(event.requestId);
     // Requests served from memory cannot be intercepted.
     if (request) {
@@ -654,8 +731,8 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
     }
     // If request ended up being served from cache, we need to convert
     // requestWillBeSentEvent to a HTTP request.
-    if (!request && requestWillBeSentEvent) {
-      this.#onRequest(client, requestWillBeSentEvent, undefined, true);
+    if (!request && requestWillBeSent) {
+      this.#onRequest(client, requestWillBeSent.event, undefined, client, true);
       request = this.#networkEventManager.getRequest(event.requestId);
     }
     if (!request) {
@@ -760,7 +837,12 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
     );
     if (redirectInfo) {
       this.#networkEventManager.responseExtraInfo(event.requestId).push(event);
-      this.#onRequest(client, redirectInfo.event, redirectInfo.fetchRequestId);
+      this.#onRequest(
+        redirectInfo.client,
+        redirectInfo.event,
+        redirectInfo.fetchRequestId,
+        redirectInfo.fetchClient,
+      );
       return;
     }
 
@@ -868,7 +950,7 @@ export class NetworkManager extends EventEmitter<NetworkManagerEvents> {
       return;
     }
     this.#adoptCdpSessionIfNeeded(client, request);
-    request._failureText = event.errorText;
+    request._failureText = event.errorText || event.blockedReason || null;
     const response = request.response();
     if (response) {
       response._resolveBody();

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

@@ -33,6 +33,7 @@ import {
   type NewDocumentScriptEvaluation,
   type ScreenshotClip,
   type ScreenshotOptions,
+  type TabInfo,
   type WaitTimeoutOptions,
 } from '../api/Page.js';
 import {WebWorker, WebWorkerEvent} from '../api/WebWorker.js';
@@ -447,6 +448,25 @@ export class CdpPage extends Page {
     return windowId.toString();
   }
 
+  override async tabInfo(): Promise<TabInfo | null> {
+    const {targetInfo} = await this.#tabTargetClient.send(
+      'Target.getTargetInfo',
+    );
+    const data = targetInfo.embedderData as TabEmbedderData | undefined;
+    if (typeof data?.tabStripIndex !== 'number') {
+      return null;
+    }
+    const tabInfo: TabInfo = {
+      index: data.tabStripIndex,
+      active: data.tabActive ?? false,
+      pinned: data.tabPinned ?? false,
+    };
+    if (data.tabGroupId) {
+      tabInfo.groupId = data.tabGroupId;
+    }
+    return tabInfo;
+  }
+
   async #onFileChooser(
     event: Protocol.Page.FileChooserOpenedEvent,
   ): Promise<void> {
@@ -454,6 +474,10 @@ export class CdpPage extends Page {
       return;
     }
 
+    if (!event.backendNodeId) {
+      return;
+    }
+
     const frame = this.#frameManager.frame(event.frameId);
     assert(frame, 'This should never happen.');
 
@@ -553,7 +577,9 @@ export class CdpPage extends Page {
     }
   }
 
-  override async setGeolocation(options: GeolocationOptions): Promise<void> {
+  override async setGeolocation(
+    options: GeolocationOptions | null,
+  ): Promise<void> {
     return await this.#emulationManager.setGeolocation(options);
   }
 
@@ -1382,6 +1408,16 @@ export class CdpPage extends Page {
   }
 }
 
+/**
+ * Shape of `TargetInfo.embedderData` for tab targets.
+ */
+interface TabEmbedderData {
+  tabStripIndex?: number;
+  tabActive?: boolean;
+  tabPinned?: boolean;
+  tabGroupId?: string;
+}
+
 const supportedMetrics = new Set<string>([
   'Timestamp',
   'Documents',

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

@@ -62,15 +62,16 @@ export class CdpScreenRecording extends ScreenRecording {
     this.stopped = true;
 
     try {
+      if (!this.#streamHandle) {
+        // `_start()` did not succeed, so there is no recording to stop.
+        return;
+      }
+
       const {client} = this.page.mainFrame();
       await client.send('Page.stopScreenRecording').catch(err => {
         this.logger(DEBUG_PREFIXES.error)?.(err);
       });
 
-      if (!this.#streamHandle) {
-        throw new Error('Screen recording stream handle is missing.');
-      }
-
       let eof = false;
       while (!eof) {
         const {

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

@@ -101,6 +101,11 @@ export class CdpTarget extends Target {
     return this.#session;
   }
 
+  _setSession(session: CdpCDPSession): void {
+    this.#session = session;
+    this.#session.setTarget(this);
+  }
+
   _addChildTarget(target: CdpTarget): void {
     this.#childTargets.add(target);
   }