chrome-devtools-frontend 1.0.1040857 → 1.0.1070764

package/front_end/core/platform/dom-utilities.ts

@@ -14,3 +14,110 @@ export function deepActiveElement(doc: Document): Element|null {
   }
   return activeElement;
 }
+
+export function getEnclosingShadowRootForNode(node: Node): Node|null {
+  let parentNode = node.parentNodeOrShadowHost();
+  while (parentNode) {
+    if (parentNode instanceof ShadowRoot) {
+      return parentNode;
+    }
+    parentNode = parentNode.parentNodeOrShadowHost();
+  }
+  return null;
+}
+
+export function rangeOfWord(
+    rootNode: Node, offset: number, stopCharacters: string, stayWithinNode: Node, direction?: string): Range {
+  let startNode;
+  let startOffset = 0;
+  let endNode;
+  let endOffset = 0;
+
+  if (!stayWithinNode) {
+    stayWithinNode = rootNode;
+  }
+
+  if (!direction || direction === 'backward' || direction === 'both') {
+    let node: Node|null = rootNode;
+    while (node) {
+      if (node === stayWithinNode) {
+        if (!startNode) {
+          startNode = stayWithinNode;
+        }
+        break;
+      }
+
+      if (node.nodeType === Node.TEXT_NODE && node.nodeValue !== null) {
+        const start = (node === rootNode ? (offset - 1) : (node.nodeValue.length - 1));
+        for (let i = start; i >= 0; --i) {
+          if (stopCharacters.indexOf(node.nodeValue[i]) !== -1) {
+            startNode = node;
+            startOffset = i + 1;
+            break;
+          }
+        }
+      }
+
+      if (startNode) {
+        break;
+      }
+
+      node = node.traversePreviousNode(stayWithinNode);
+    }
+
+    if (!startNode) {
+      startNode = stayWithinNode;
+      startOffset = 0;
+    }
+  } else {
+    startNode = rootNode;
+    startOffset = offset;
+  }
+
+  if (!direction || direction === 'forward' || direction === 'both') {
+    let node: (Node|null)|Node = rootNode;
+    while (node) {
+      if (node === stayWithinNode) {
+        if (!endNode) {
+          endNode = stayWithinNode;
+        }
+        break;
+      }
+
+      if (node.nodeType === Node.TEXT_NODE && node.nodeValue !== null) {
+        const start = (node === rootNode ? offset : 0);
+        for (let i = start; i < node.nodeValue.length; ++i) {
+          if (stopCharacters.indexOf(node.nodeValue[i]) !== -1) {
+            endNode = node;
+            endOffset = i;
+            break;
+          }
+        }
+      }
+
+      if (endNode) {
+        break;
+      }
+
+      node = node.traverseNextNode(stayWithinNode);
+    }
+
+    if (!endNode) {
+      endNode = stayWithinNode;
+      endOffset = stayWithinNode.nodeType === Node.TEXT_NODE ? stayWithinNode.nodeValue?.length || 0 :
+                                                               stayWithinNode.childNodes.length;
+    }
+  } else {
+    endNode = rootNode;
+    endOffset = offset;
+  }
+
+  if (!rootNode.ownerDocument) {
+    throw new Error('No `ownerDocument` found for rootNode');
+  }
+  const result = rootNode.ownerDocument.createRange();
+  result.setStart(startNode, startOffset);
+  result.setEnd(endNode, endOffset);
+
+  return result;
+}

package/front_end/core/platform/keyboard-utilities.ts

@@ -28,3 +28,11 @@ export const ARROW_KEYS = new Set<ArrowKey>([
 export function keyIsArrowKey(key: string): key is ArrowKey {
   return ARROW_KEYS.has(key as ArrowKey);
 }
+
+export function isEscKey(event: KeyboardEvent): boolean {
+  return event.key === 'Escape';
+}
+
+export function isEnterOrSpaceKey(event: KeyboardEvent): boolean {
+  return event.key === 'Enter' || event.key === ' ';
+}

package/front_end/core/platform/string-utilities.ts

@@ -452,3 +452,13 @@ export const createPlainTextSearchRegex = function(query: string, flags?: string
   }
   return new RegExp(regex, flags || '');
 };
+
+class LowerCaseStringTag {
+  private lowerCaseStringTag: (string|undefined);
+}
+
+export type LowerCaseString = string&LowerCaseStringTag;
+
+export const toLowerCaseString = function(input: string): LowerCaseString {
+  return input.toLowerCase() as LowerCaseString;
+};

package/front_end/core/root/Runtime.ts

@@ -298,12 +298,10 @@ export enum ExperimentName {
   ALL = '*',
   PROTOCOL_MONITOR = 'protocolMonitor',
   WEBAUTHN_PANE = 'webauthnPane',
-  SYNC_SETTINGS = 'syncSettings',
   FULL_ACCESSIBILITY_TREE = 'fullAccessibilityTree',
   PRECISE_CHANGES = 'preciseChanges',
   STYLES_PANE_CSS_CHANGES = 'stylesPaneCSSChanges',
   HEADER_OVERRIDES = 'headerOverrides',
-  CSS_LAYERS = 'cssLayers',
   EYEDROPPER_COLOR_PICKER = 'eyedropperColorPicker',
   INSTRUMENTATION_BREAKPOINTS = 'instrumentationBreakpoints',
   CSS_AUTHORING_HINTS = 'cssAuthoringHints',

package/front_end/core/sdk/CPUProfileDataModel.ts

@@ -33,7 +33,7 @@ export class CPUProfileNode extends ProfileNode {
   positionTicks: Protocol.Profiler.PositionTickInfo[]|undefined;
   deoptReason: string|null;
 
-  constructor(node: Protocol.Profiler.ProfileNode, sampleTime: number) {
+  constructor(node: Protocol.Profiler.ProfileNode, sampleTime: number, target: Target|null) {
     const callFrame = node.callFrame || ({
                         // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration
                         // @ts-expect-error
@@ -51,7 +51,7 @@ export class CPUProfileNode extends ProfileNode {
                         // @ts-expect-error
                         columnNumber: node['columnNumber'] - 1,
                       } as Protocol.Runtime.CallFrame);
-    super(callFrame);
+    super(callFrame, target);
     this.id = node.id;
     this.self = (node.hitCount || 0) * sampleTime;
     this.positionTicks = node.positionTicks;
@@ -200,7 +200,7 @@ export class CPUProfileDataModel extends ProfileTreeModel {
         Boolean(Common.Settings.Settings.instance().moduleSetting('showNativeFunctionsInJSProfile').get());
     const root = nodes[0];
     const idMap = new Map<number, number>([[root.id, root.id]]);
-    const resultRoot = new CPUProfileNode(root, sampleTime);
+    const resultRoot = new CPUProfileNode(root, sampleTime, this.target());
     if (!root.children) {
       throw new Error('Missing children for root');
     }
@@ -215,7 +215,7 @@ export class CPUProfileDataModel extends ProfileTreeModel {
       if (!sourceNode.children) {
         sourceNode.children = [];
       }
-      const targetNode = new CPUProfileNode(sourceNode, sampleTime);
+      const targetNode = new CPUProfileNode(sourceNode, sampleTime, this.target());
       if (keepNatives || !isNativeNode(sourceNode)) {
         parentNode.children.push(targetNode);
         parentNode = targetNode;
@@ -497,4 +497,11 @@ export class CPUProfileDataModel extends ProfileTreeModel {
   nodeByIndex(index: number): CPUProfileNode|null {
     return this.samples && this.#idToNode.get(this.samples[index]) || null;
   }
+
+  nodes(): CPUProfileNode[]|null {
+    if (!this.#idToNode) {
+      return null;
+    }
+    return [...this.#idToNode.values()];
+  }
 }

package/front_end/core/sdk/CPUThrottlingManager.ts

@@ -52,7 +52,7 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
   }
 
   async getHardwareConcurrency(): Promise<number> {
-    const target = TargetManager.instance().mainTarget();
+    const target = TargetManager.instance().mainFrameTarget();
     const existingCallback = this.#pendingMainTargetPromise;
 
     // If the main target hasn't attached yet, block callers until it appears.

package/front_end/core/sdk/CSSMatchedStyles.ts

@@ -13,6 +13,14 @@ import {CSSKeyframesRule, CSSStyleRule} from './CSSRule.js';
 import {CSSStyleDeclaration, Type} from './CSSStyleDeclaration.js';
 import {type DOMNode} from './DOMModel.js';
 
+export function parseCSSVariableNameAndFallback(cssVariableValue: string): {
+  variableName: string|null,
+  fallback: string|null,
+} {
+  const match = cssVariableValue.match(/var\(\s*(--(?:[\s\w\P{ASCII}-]|\\.)+),?\s*(.*)\s*\)/u);
+  return {variableName: match && match[1].trim(), fallback: match && match[2]};
+}
+
 export class CSSMatchedStyles {
   readonly #cssModelInternal: CSSModel;
   readonly #nodeInternal: DOMNode;
@@ -571,8 +579,7 @@ export class CSSMatchedStyles {
     fromFallback: boolean,
   }|null {
     const domCascade = this.#styleToDOMCascade.get(style) || null;
-    const cssVariableValueNoSpaces = cssVariableValue.replace(/\s/g, '');
-    return domCascade ? domCascade.computeSingleVariableValue(style, cssVariableValueNoSpaces) : null;
+    return domCascade ? domCascade.computeSingleVariableValue(style, cssVariableValue) : null;
   }
 
   isInherited(style: CSSStyleDeclaration): boolean {
@@ -755,19 +762,11 @@ class DOMInheritanceCascade {
       return null;
     }
     const computedValue = this.innerComputeValue(availableCSSVariables, computedCSSVariables, cssVariableValue);
-    const {variableName} = this.getCSSVariableNameAndFallback(cssVariableValue);
+    const {variableName} = parseCSSVariableNameAndFallback(cssVariableValue);
 
     return {computedValue, fromFallback: variableName !== null && !availableCSSVariables.has(variableName)};
   }
 
-  private getCSSVariableNameAndFallback(cssVariableValue: string): {
-    variableName: string|null,
-    fallback: string|null,
-  } {
-    const match = cssVariableValue.match(/^var\((--[a-zA-Z0-9-_]+)[,]?\s*(.*)\)$/);
-    return {variableName: match && match[1], fallback: match && match[2]};
-  }
-
   private innerComputeCSSVariable(
       availableCSSVariables: Map<string, string|null>, computedCSSVariables: Map<string, string|null>,
       variableName: string): string|null {
@@ -799,7 +798,7 @@ class DOMInheritanceCascade {
         continue;
       }
       // process var() function
-      const {variableName, fallback} = this.getCSSVariableNameAndFallback(result.value);
+      const {variableName, fallback} = parseCSSVariableNameAndFallback(result.value);
       if (!variableName) {
         return null;
       }

package/front_end/core/sdk/ChildTargetManager.ts

@@ -40,7 +40,7 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
       void this.#targetAgent.invoke_setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true, flatten: true});
     }
 
-    if (!parentTarget.parentTarget() && !Host.InspectorFrontendHost.isUnderTest()) {
+    if (parentTarget.parentTarget()?.type() !== Type.Frame && !Host.InspectorFrontendHost.isUnderTest()) {
       void this.#targetAgent.invoke_setDiscoverTargets({discover: true});
       void this.#targetAgent.invoke_setRemoteLocations({locations: [{host: 'localhost', port: 9229}]});
     }

package/front_end/core/sdk/ConsoleModel.ts

@@ -52,7 +52,7 @@ import {
   type ExecutionContext,
   type QueryObjectRequestedEvent,
 } from './RuntimeModel.js';
-import {type Target} from './Target.js';
+import {type Target, Type} from './Target.js';
 import {TargetManager, type Observer} from './TargetManager.js';
 
 const UIStrings = {
@@ -140,7 +140,7 @@ export class ConsoleModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
     }
 
     const resourceTreeModel = target.model(ResourceTreeModel);
-    if (resourceTreeModel && !target.parentTarget()) {
+    if (resourceTreeModel && target.parentTarget()?.type() !== Type.Frame) {
       eventListeners.push(resourceTreeModel.addEventListener(
           ResourceTreeModelEvents.MainFrameNavigated, this.mainFrameNavigated, this));
     }
@@ -153,7 +153,7 @@ export class ConsoleModel extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
           RuntimeModelEvents.ExceptionRevoked, this.exceptionRevoked.bind(this, runtimeModel)));
       eventListeners.push(runtimeModel.addEventListener(
           RuntimeModelEvents.ConsoleAPICalled, this.consoleAPICalled.bind(this, runtimeModel)));
-      if (!target.parentTarget()) {
+      if (target.parentTarget()?.type() !== Type.Frame) {
         eventListeners.push(runtimeModel.debuggerModel().addEventListener(
             DebuggerModelEvents.GlobalObjectCleared, this.clearIfNecessary, this));
       }

package/front_end/core/sdk/DOMModel.ts

@@ -1145,7 +1145,6 @@ export class DOMModel extends SDKModel<EventTypes> {
   private async requestDocumentInternal(): Promise<DOMDocument|null> {
     const response = await this.agent.invoke_getDocument({});
     if (response.getError()) {
-      console.error(response.getError());
       return null;
     }
     const {root: documentPayload} = response;

package/front_end/core/sdk/DebuggerModel.ts

@@ -471,17 +471,11 @@ export class DebuggerModel extends SDKModel<EventTypes> {
   }
 
   async setBreakpointInAnonymousScript(
-      scriptId: Protocol.Runtime.ScriptId, scriptHash: string, lineNumber: number, columnNumber?: number,
-      condition?: string): Promise<SetBreakpointResult> {
+      scriptHash: string, lineNumber: number, columnNumber?: number, condition?: string): Promise<SetBreakpointResult> {
     const response = await this.agent.invoke_setBreakpointByUrl(
         {lineNumber: lineNumber, scriptHash: scriptHash, columnNumber: columnNumber, condition: condition});
-    const error = response.getError();
-    if (error) {
-      // Old V8 backend doesn't support scriptHash argument.
-      if (error !== 'Either url or urlRegex must be specified.') {
-        return {locations: [], breakpointId: null};
-      }
-      return this.setBreakpointBySourceId(scriptId, lineNumber, columnNumber, condition);
+    if (response.getError()) {
+      return {locations: [], breakpointId: null};
     }
     let locations: Location[] = [];
     if (response.locations) {
@@ -490,27 +484,8 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     return {locations, breakpointId: response.breakpointId};
   }
 
-  private async setBreakpointBySourceId(
-      scriptId: Protocol.Runtime.ScriptId, lineNumber: number, columnNumber?: number,
-      condition?: string): Promise<SetBreakpointResult> {
-    // This method is required for backward compatibility with V8 before 6.3.275.
-    const response = await this.agent.invoke_setBreakpoint(
-        {location: {scriptId: scriptId, lineNumber: lineNumber, columnNumber: columnNumber}, condition: condition});
-    if (response.getError()) {
-      return {breakpointId: null, locations: []};
-    }
-    let actualLocation: Location[] = [];
-    if (response.actualLocation) {
-      actualLocation = [Location.fromPayload(this, response.actualLocation)];
-    }
-    return {locations: actualLocation, breakpointId: response.breakpointId};
-  }
-
   async removeBreakpoint(breakpointId: Protocol.Debugger.BreakpointId): Promise<void> {
-    const response = await this.agent.invoke_removeBreakpoint({breakpointId});
-    if (response.getError()) {
-      console.error('Failed to remove breakpoint: ' + response.getError());
-    }
+    await this.agent.invoke_removeBreakpoint({breakpointId});
   }
 
   async getPossibleBreakpoints(startLocation: Location, endLocation: Location|null, restrictToFunction: boolean):
@@ -890,9 +865,6 @@ export class DebuggerModel extends SDKModel<EventTypes> {
       callFrameId: Protocol.Debugger.CallFrameId): Promise<string|undefined> {
     const response = await this.agent.invoke_setVariableValue({scopeNumber, variableName, newValue, callFrameId});
     const error = response.getError();
-    if (error) {
-      console.error(error);
-    }
     return error;
   }
 
@@ -911,9 +883,6 @@ export class DebuggerModel extends SDKModel<EventTypes> {
   async setBlackboxPatterns(patterns: string[]): Promise<boolean> {
     const response = await this.agent.invoke_setBlackboxPatterns({patterns});
     const error = response.getError();
-    if (error) {
-      console.error(error);
-    }
     return !error;
   }
 
@@ -1387,7 +1356,6 @@ export class CallFrame {
     });
     const error = response.getError();
     if (error) {
-      console.error(error);
       return {error: error};
     }
     return {object: runtimeModel.createRemoteObject(response.result), exceptionDetails: response.exceptionDetails};

package/front_end/core/sdk/FrameManager.ts

@@ -21,36 +21,27 @@ let frameManagerInstance: FrameManager|null = null;
  */
 export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDKModelObserver<ResourceTreeModel> {
-  readonly #eventListeners: WeakMap<ResourceTreeModel, Common.EventTarget.EventDescriptor[]>;
-  #frames: Map<string, {
+  readonly #eventListeners = new WeakMap<ResourceTreeModel, Common.EventTarget.EventDescriptor[]>();
+
+  // Maps frameIds to #frames and a count of how many ResourceTreeModels contain this frame.
+  // (OOPIFs are usually first attached to a new target and then detached from their old target,
+  // therefore being contained in 2 models for a short period of time.)
+  #frames = new Map<string, {
     frame: ResourceTreeFrame,
     count: number,
-  }>;
-  readonly #framesForTarget: Map<Protocol.Target.TargetID|'main', Set<Protocol.Page.FrameId>>;
-  #topFrame: ResourceTreeFrame|null;
-  #transferringFramesDataCache: Map<string, {
+  }>();
+
+  readonly #framesForTarget = new Map<Protocol.Target.TargetID|'main', Set<Protocol.Page.FrameId>>();
+  #topFrame: ResourceTreeFrame|null = null;
+  #transferringFramesDataCache = new Map<string, {
     creationStackTrace?: Protocol.Runtime.StackTrace,
     creationStackTraceTarget?: Target,
-    adScriptId?: Protocol.Runtime.ScriptId,
-    debuggerId?: Protocol.Runtime.UniqueDebuggerId,
-  }>;
+  }>();
   #awaitedFrames: Map<string, {notInTarget?: Target, resolve: (frame: ResourceTreeFrame) => void}[]> = new Map();
 
   constructor() {
     super();
-    this.#eventListeners = new WeakMap();
     TargetManager.instance().observeModels(ResourceTreeModel, this);
-
-    // Maps frameIds to #frames and a count of how many ResourceTreeModels contain this frame.
-    // (OOPIFs are usually first attached to a new target and then detached from their old target,
-    // therefore being contained in 2 models for a short period of time.)
-    this.#frames = new Map();
-
-    // Maps targetIds to a set of frameIds.
-    this.#framesForTarget = new Map();
-
-    this.#topFrame = null;
-    this.#transferringFramesDataCache = new Map();
   }
 
   static instance({forceNew}: {
@@ -101,8 +92,6 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
       // In order to not lose the following attributes of a frame during
       // an OOPIF transfer we need to copy them to the new frame
       frame.setCreationStackTrace(frameData.frame.getCreationStackTraceData());
-      frame.setAdScriptId(frameData.frame.getAdScriptId());
-      frame.setDebuggerId(frameData.frame.getDebuggerId());
       this.#frames.set(frame.id, {frame, count: frameData.count + 1});
     } else {
       // If the transferring frame's detached event is received before its frame added
@@ -114,12 +103,6 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
           creationStackTraceTarget: cachedFrameAttributes.creationStackTraceTarget,
         });
       }
-      if (cachedFrameAttributes?.adScriptId) {
-        frame.setAdScriptId(cachedFrameAttributes.adScriptId);
-      }
-      if (cachedFrameAttributes?.debuggerId) {
-        frame.setDebuggerId(cachedFrameAttributes.debuggerId);
-      }
       this.#frames.set(frame.id, {frame, count: 1});
       this.#transferringFramesDataCache.delete(frame.id);
     }
@@ -145,13 +128,9 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
     // so that later on the frame added event in the new target they can be reassigned.
     if (isSwap && !this.#frames.get(frame.id)) {
       const traceData = frame.getCreationStackTraceData();
-      const adScriptId = frame.getAdScriptId();
-      const debuggerId = frame.getDebuggerId();
       const cachedFrameAttributes = {
         ...(traceData.creationStackTrace && {creationStackTrace: traceData.creationStackTrace}),
         ...(traceData.creationStackTrace && {creationStackTraceTarget: traceData.creationStackTraceTarget}),
-        ...(adScriptId && {adScriptId}),
-        ...(debuggerId && {debuggerId}),
       };
       this.#transferringFramesDataCache.set(frame.id, cachedFrameAttributes);
     }

package/front_end/core/sdk/NetworkManager.ts

@@ -520,6 +520,8 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
 
     networkRequest.protocol = response.protocol || '';
 
+    networkRequest.alternateProtocolUsage = response.alternateProtocolUsage;
+
     if (response.serviceWorkerResponseSource) {
       networkRequest.setServiceWorkerResponseSource(response.serviceWorkerResponseSource);
     }
@@ -836,8 +838,9 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
   requestIntercepted({}: Protocol.Network.RequestInterceptedEvent): void {
   }
 
-  requestWillBeSentExtraInfo({requestId, associatedCookies, headers, clientSecurityState, connectTiming}:
-                                 Protocol.Network.RequestWillBeSentExtraInfoEvent): void {
+  requestWillBeSentExtraInfo(
+      {requestId, associatedCookies, headers, clientSecurityState, connectTiming, siteHasCookieInOtherPartition}:
+          Protocol.Network.RequestWillBeSentExtraInfoEvent): void {
     const blockedRequestCookies: BlockedCookieWithReason[] = [];
     const includedRequestCookies = [];
     for (const {blockedReasons, cookie} of associatedCookies) {
@@ -851,8 +854,9 @@ export class NetworkDispatcher implements ProtocolProxyApi.NetworkDispatcher {
       blockedRequestCookies,
       includedRequestCookies,
       requestHeaders: this.headersMapToHeadersArray(headers),
-      clientSecurityState: clientSecurityState,
+      clientSecurityState,
       connectTiming,
+      siteHasCookieInOtherPartition,
     };
     this.getExtraInfoBuilder(requestId).addRequestExtraInfo(extraRequestInfo);
   }
@@ -1482,7 +1486,7 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
   }
 
   async getCertificate(origin: string): Promise<string[]> {
-    const target = TargetManager.instance().mainTarget();
+    const target = TargetManager.instance().mainFrameTarget();
     if (!target) {
       return [];
     }
@@ -1511,12 +1515,13 @@ export class MultitargetNetworkManager extends Common.ObjectWrapper.ObjectWrappe
       headers['Cache-Control'] = 'no-cache';
     }
 
-    const allowFileUNCPaths = Common.Settings.Settings.instance().moduleSetting('network.enable-unc-loading').get();
+    const allowRemoteFilePaths =
+        Common.Settings.Settings.instance().moduleSetting('network.enable-remote-file-loading').get();
 
     return new Promise(
         resolve => Host.ResourceLoader.load(url, headers, (success, _responseHeaders, content, errorDescription) => {
           resolve({success, content, errorDescription});
-        }, allowFileUNCPaths));
+        }, allowRemoteFilePaths));
   }
 }
 
@@ -1571,28 +1576,57 @@ export class InterceptedRequest {
     this.responseHeaders = responseHeaders;
     this.requestId = requestId;
     this.networkRequest = networkRequest;
-    if (this.networkRequest && this.responseHeaders) {
-      // This populates 'NetworkRequest.originalResponseHeaders' with the
-      // response headers from CDP's 'Fetch.requestPaused'. Populating this
-      // field together with 'NetworkRequest.responseHeaders' with the info
-      // from 'Network.responseReceivedExtraInfo' would have been easier, but we
-      // are not sure whether the response headers from the 2 CDP events are
-      // always exactly the same.
-      // Creates a deep copy.
-      this.networkRequest.originalResponseHeaders = this.responseHeaders.map(headerEntry => ({...headerEntry}));
-    }
   }
 
   hasResponded(): boolean {
     return this.#hasRespondedInternal;
   }
 
+  static mergeSetCookieHeaders(
+      originalSetCookieHeaders: Protocol.Fetch.HeaderEntry[],
+      setCookieHeadersFromOverrides: Protocol.Fetch.HeaderEntry[]): Protocol.Fetch.HeaderEntry[] {
+    const malformedHeaders = new Set<string>();
+    const validHeaders = new Map<string, string>();
+    for (const header of originalSetCookieHeaders.concat(setCookieHeadersFromOverrides)) {
+      // The regex matches cookie headers of the form '<header-name>=<header-value>'.
+      // <header-name> is a token as defined in https://www.rfc-editor.org/rfc/rfc9110.html#name-tokens.
+      // The shape of <header-value> is not being validated at all here.
+      const match = header.value.match(/([a-zA-Z0-9!#$%&'*+.^_`|~-]+)=(.*)/);
+      if (match) {
+        // This step merges headers for cookies with the same name, e.g. if there
+        // are both 'set-cookie: foo=original' and 'set-cookie: foo=override',
+        // only the later one will be stored.
+        validHeaders.set(match[1], match[2]);
+      } else {
+        malformedHeaders.add(header.value);
+      }
+    }
+
+    const mergedHeaders: Protocol.Fetch.HeaderEntry[] = [];
+    for (const [cookieName, cookieValue] of validHeaders) {
+      mergedHeaders.push({name: 'set-cookie', value: `${cookieName}=${cookieValue}`});
+    }
+    for (const headerValue of malformedHeaders) {
+      mergedHeaders.push({name: 'set-cookie', value: headerValue});
+    }
+    return mergedHeaders;
+  }
+
   async continueRequestWithContent(
       contentBlob: Blob, encoded: boolean, responseHeaders: Protocol.Fetch.HeaderEntry[],
       isBodyOverridden: boolean): Promise<void> {
     this.#hasRespondedInternal = true;
     const body = encoded ? await contentBlob.text() : await blobToBase64(contentBlob);
     const responseCode = isBodyOverridden ? 200 : (this.responseStatusCode || 200);
+
+    if (this.networkRequest) {
+      const originalSetCookieHeaders =
+          this.networkRequest?.originalResponseHeaders.filter(header => header.name === 'set-cookie') || [];
+      const setCookieHeadersFromOverrides = responseHeaders.filter(header => header.name === 'set-cookie');
+      this.networkRequest.setCookieHeaders =
+          InterceptedRequest.mergeSetCookieHeaders(originalSetCookieHeaders, setCookieHeadersFromOverrides);
+    }
+
     void this.#fetchAgent.invoke_fulfillRequest({requestId: this.requestId, responseCode, body, responseHeaders});
     MultitargetNetworkManager.instance().dispatchEventToListeners(
         MultitargetNetworkManager.Events.RequestFulfilled, this.request.url as Platform.DevToolsPath.UrlString);