chrome-devtools-frontend 1.0.1402249 → 1.0.1418433

package/front_end/core/sdk/ConsoleModel.ts

@@ -403,6 +403,8 @@ export class ConsoleModel extends SDKModel<EventTypes> {
     }
     for (const runtimeModel of TargetManager.instance().models(RuntimeModel)) {
       runtimeModel.discardConsoleEntries();
+      // Runtime.discardConsoleEntries implies Runtime.releaseObjectGroup('console').
+      runtimeModel.releaseObjectGroup('live-expression');
     }
     for (const target of TargetManager.instance().targets()) {
       target.model(ConsoleModel)?.clear();
@@ -521,12 +523,12 @@ export interface CommandEvaluatedEvent {
   exceptionDetails?: Protocol.Runtime.ExceptionDetails|undefined;
 }
 
-export type EventTypes = {
-  [Events.ConsoleCleared]: void,
-  [Events.MessageAdded]: ConsoleMessage,
-  [Events.MessageUpdated]: ConsoleMessage,
-  [Events.CommandEvaluated]: CommandEvaluatedEvent,
-};
+export interface EventTypes {
+  [Events.ConsoleCleared]: void;
+  [Events.MessageAdded]: ConsoleMessage;
+  [Events.MessageUpdated]: ConsoleMessage;
+  [Events.CommandEvaluated]: CommandEvaluatedEvent;
+}
 
 export interface AffectedResources {
   requestId?: Protocol.Network.RequestId;
@@ -586,6 +588,7 @@ export interface ConsoleMessageDetails {
   context?: string;
   affectedResources?: AffectedResources;
   category?: Protocol.Log.LogEntryCategory;
+  isCookieReportIssue?: boolean;
 }
 
 export class ConsoleMessage {
@@ -609,6 +612,7 @@ export class ConsoleMessage {
   #exceptionId?: number = undefined;
   #affectedResources?: AffectedResources;
   category?: Protocol.Log.LogEntryCategory;
+  isCookieReportIssue: boolean = false;
 
   /**
    * The parent frame of the `console.log` call of logpoints or conditional breakpoints
@@ -639,6 +643,7 @@ export class ConsoleMessage {
     this.workerId = details?.workerId;
     this.#affectedResources = details?.affectedResources;
     this.category = details?.category;
+    this.isCookieReportIssue = Boolean(details?.isCookieReportIssue);
 
     if (!this.#executionContextId && this.#runtimeModelInternal) {
       if (this.scriptId) {

package/front_end/core/sdk/CookieModel.test.ts

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type * as Platform from '../../core/platform/platform.js';
+import * as Platform from '../../core/platform/platform.js';
 import * as Protocol from '../../generated/protocol.js';
 import {createTarget} from '../../testing/EnvironmentHelpers.js';
 import {expectCalled} from '../../testing/ExpectStubCall.js';
@@ -15,8 +15,9 @@ import {addChildFrame, createResource, DOMAIN, getMainFrame, navigate} from '../
 
 import * as SDK from './sdk.js';
 
-const MAIN_FRAME_RESOURCE_DOMAIN = 'example.org' as Platform.DevToolsPath.UrlString;
-const CHILD_FRAME_RESOURCE_DOMAIN = 'example.net' as Platform.DevToolsPath.UrlString;
+const {urlString} = Platform.DevToolsPath;
+const MAIN_FRAME_RESOURCE_DOMAIN = urlString`example.org`;
+const CHILD_FRAME_RESOURCE_DOMAIN = urlString`example.net`;
 
 describeWithMockConnection('CookieModel', () => {
   const PROTOCOL_COOKIE = {
@@ -65,7 +66,7 @@ describeWithMockConnection('CookieModel', () => {
 
     const target = createTarget();
     const mainFrame = getMainFrame(target);
-    const resourceUrl = (domain: string) => `https://${domain}/resource` as Platform.DevToolsPath.UrlString;
+    const resourceUrl = (domain: string) => urlString`${`https://${domain}/resource`}`;
     createResource(mainFrame, resourceUrl(MAIN_FRAME_RESOURCE_DOMAIN), 'text/html', '');
     const childFrame = await addChildFrame(target);
     createResource(childFrame, resourceUrl(CHILD_FRAME_RESOURCE_DOMAIN), 'text/html', '');
@@ -113,7 +114,7 @@ describeWithMockConnection('CookieModel', () => {
 
     assert.isEmpty(await model.getCookiesForDomain(`https://${MAIN_FRAME_RESOURCE_DOMAIN}`));
 
-    const resourceUrl = (domain: string) => `https://${domain}/main_resource` as Platform.DevToolsPath.UrlString;
+    const resourceUrl = (domain: string) => urlString`${`https://${domain}/main_resource`}`;
     createResource(mainFrame, resourceUrl(MAIN_FRAME_RESOURCE_DOMAIN), 'text/html', '');
     dispatchLoadingFinished();
     await expectCalled(eventListener);
@@ -142,7 +143,7 @@ describeWithMockConnection('CookieModel', () => {
     const eventListener = sinon.stub();
     model.addEventListener(SDK.CookieModel.Events.COOKIE_LIST_UPDATED, eventListener);
 
-    createResource(mainFrame, `https://${DOMAIN}/main_resource` as Platform.DevToolsPath.UrlString, 'text/html', '');
+    createResource(mainFrame, urlString`${`https://${DOMAIN}/main_resource`}`, 'text/html', '');
     dispatchLoadingFinished();
 
     await expectCalled(eventListener);
@@ -165,7 +166,7 @@ describeWithMockConnection('CookieModel', () => {
     const mainFrame = getMainFrame(target);
     const model = target.model(SDK.CookieModel.CookieModel)!;
 
-    createResource(mainFrame, `https://${DOMAIN}/main_resource` as Platform.DevToolsPath.UrlString, 'text/html', '');
+    createResource(mainFrame, urlString`${`https://${DOMAIN}/main_resource`}`, 'text/html', '');
     dispatchLoadingFinished();
 
     let [readCookie] = await model.getCookiesForDomain(`https://${DOMAIN}`);

package/front_end/core/sdk/CookieModel.ts

@@ -238,6 +238,6 @@ export const enum Events {
   COOKIE_LIST_UPDATED = 'CookieListUpdated',
 }
 
-export type EventTypes = {
-  [Events.COOKIE_LIST_UPDATED]: void,
-};
+export interface EventTypes {
+  [Events.COOKIE_LIST_UPDATED]: void;
+}

package/front_end/core/sdk/DOMDebuggerModel.ts

@@ -271,11 +271,11 @@ export const enum Events {
   DOM_BREAKPOINTS_REMOVED = 'DOMBreakpointsRemoved',
 }
 
-export type EventTypes = {
-  [Events.DOM_BREAKPOINT_ADDED]: DOMBreakpoint,
-  [Events.DOM_BREAKPOINT_TOGGLED]: DOMBreakpoint,
-  [Events.DOM_BREAKPOINTS_REMOVED]: DOMBreakpoint[],
-};
+export interface EventTypes {
+  [Events.DOM_BREAKPOINT_ADDED]: DOMBreakpoint;
+  [Events.DOM_BREAKPOINT_TOGGLED]: DOMBreakpoint;
+  [Events.DOM_BREAKPOINTS_REMOVED]: DOMBreakpoint[];
+}
 
 const Marker = 'breakpoint-marker';
 

package/front_end/core/sdk/DOMModel.ts

@@ -353,6 +353,10 @@ export class DOMNode {
     return this.#pseudoElements;
   }
 
+  checkmarkPseudoElement(): DOMNode|undefined {
+    return this.#pseudoElements.get(Protocol.DOM.PseudoType.Checkmark)?.at(-1);
+  }
+
   beforePseudoElement(): DOMNode|undefined {
     return this.#pseudoElements.get(Protocol.DOM.PseudoType.Before)?.at(-1);
   }
@@ -361,6 +365,10 @@ export class DOMNode {
     return this.#pseudoElements.get(Protocol.DOM.PseudoType.After)?.at(-1);
   }
 
+  pickerIconPseudoElement(): DOMNode|undefined {
+    return this.#pseudoElements.get(Protocol.DOM.PseudoType.PickerIcon)?.at(-1);
+  }
+
   markerPseudoElement(): DOMNode|undefined {
     return this.#pseudoElements.get(Protocol.DOM.PseudoType.Marker)?.at(-1);
   }
@@ -379,6 +387,15 @@ export class DOMNode {
     ];
   }
 
+  carouselPseudoElements(): DOMNode[] {
+    return [
+      ...this.#pseudoElements.get(Protocol.DOM.PseudoType.ScrollButton) || [],
+      ...this.#pseudoElements.get(Protocol.DOM.PseudoType.Column) || [],
+      ...this.#pseudoElements.get(Protocol.DOM.PseudoType.ScrollMarker) || [],
+      ...this.#pseudoElements.get(Protocol.DOM.PseudoType.ScrollMarkerGroup) || [],
+    ];
+  }
+
   hasAssignedSlot(): boolean {
     return this.assignedSlot !== null;
   }
@@ -1474,10 +1491,11 @@ export class DOMModel extends SDKModel<EventTypes> {
       throw new Error('DOMModel._pseudoElementAdded expects pseudoType to be defined.');
     }
     const currentPseudoElements = parent.pseudoElements().get(pseudoType);
-    if (currentPseudoElements) {
-      if (!pseudoType.startsWith('view-transition')) {
+    if (currentPseudoElements && currentPseudoElements.length > 0) {
+      if (!(pseudoType.startsWith('view-transition') || pseudoType.startsWith('scroll-') || pseudoType === 'column')) {
         throw new Error(
-            'DOMModel.pseudoElementAdded expects parent to not already have this pseudo type added; only view-transition* pseudo elements can coexist under the same parent.');
+            'DOMModel.pseudoElementAdded expects parent to not already have this pseudo type added; only view-transition* and scrolling pseudo elements can coexist under the same parent.' +
+            ` ${currentPseudoElements.length} elements of type ${pseudoType} already exist on parent.`);
       }
       currentPseudoElements.push(node);
     } else {
@@ -1684,20 +1702,20 @@ export enum Events {
   /* eslint-enable @typescript-eslint/naming-convention */
 }
 
-export type EventTypes = {
-  [Events.AttrModified]: {node: DOMNode, name: string},
-  [Events.AttrRemoved]: {node: DOMNode, name: string},
-  [Events.CharacterDataModified]: DOMNode,
-  [Events.DOMMutated]: DOMNode,
-  [Events.NodeInserted]: DOMNode,
-  [Events.NodeRemoved]: {node: DOMNode, parent: DOMNode},
-  [Events.DocumentUpdated]: DOMModel,
-  [Events.ChildNodeCountUpdated]: DOMNode,
-  [Events.DistributedNodesChanged]: DOMNode,
-  [Events.MarkersChanged]: DOMNode,
-  [Events.TopLayerElementsChanged]: void,
-  [Events.ScrollableFlagUpdated]: {node: DOMNode},
-};
+export interface EventTypes {
+  [Events.AttrModified]: {node: DOMNode, name: string};
+  [Events.AttrRemoved]: {node: DOMNode, name: string};
+  [Events.CharacterDataModified]: DOMNode;
+  [Events.DOMMutated]: DOMNode;
+  [Events.NodeInserted]: DOMNode;
+  [Events.NodeRemoved]: {node: DOMNode, parent: DOMNode};
+  [Events.DocumentUpdated]: DOMModel;
+  [Events.ChildNodeCountUpdated]: DOMNode;
+  [Events.DistributedNodesChanged]: DOMNode;
+  [Events.MarkersChanged]: DOMNode;
+  [Events.TopLayerElementsChanged]: void;
+  [Events.ScrollableFlagUpdated]: {node: DOMNode};
+}
 
 class DOMDispatcher implements ProtocolProxyApi.DOMDispatcher {
   readonly #domModel: DOMModel;

package/front_end/core/sdk/DebuggerModel.test.ts

@@ -13,10 +13,11 @@ import {
 } from '../../testing/MockConnection.js';
 import {MockProtocolBackend} from '../../testing/MockScopeChain.js';
 import * as Common from '../common/common.js';
-import type * as Platform from '../platform/platform.js';
+import * as Platform from '../platform/platform.js';
 
 import * as SDK from './sdk.js';
 
+const {urlString} = Platform.DevToolsPath;
 const SCRIPT_ID_ONE = '1' as Protocol.Runtime.ScriptId;
 const SCRIPT_ID_TWO = '2' as Protocol.Runtime.ScriptId;
 
@@ -179,7 +180,7 @@ describeWithMockConnection('DebuggerModel', () => {
       const target = createTarget();
       target.markAsNodeJSForTest();
       const model = new SDK.DebuggerModel.DebuggerModel(target);
-      const {breakpointId} = await model.setBreakpointByURL('fs.js' as Platform.DevToolsPath.UrlString, 1);
+      const {breakpointId} = await model.setBreakpointByURL(urlString`fs.js`, 1);
       assert.strictEqual(breakpointId, breakpointId1);
     });
   });
@@ -229,7 +230,7 @@ describeWithMockConnection('DebuggerModel', () => {
     it('Scope.typeName covers every enum value', async () => {
       const target = createTarget();
       const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel) as SDK.DebuggerModel.DebuggerModel;
-      const scriptUrl = 'https://script-host/script.js' as Platform.DevToolsPath.UrlString;
+      const scriptUrl = urlString`https://script-host/script.js`;
       const script = new SDK.Script.Script(
           debuggerModel, SCRIPT_ID_ONE, scriptUrl, 0, 0, 0, 0, 0, '', false, false, undefined, false, 0, null, null,
           null, null, null, null);

package/front_end/core/sdk/DebuggerModel.ts

@@ -1028,22 +1028,22 @@ export enum Events {
   /* eslint-enable @typescript-eslint/naming-convention */
 }
 
-export type EventTypes = {
-  [Events.DebuggerWasEnabled]: DebuggerModel,
-  [Events.DebuggerWasDisabled]: DebuggerModel,
-  [Events.DebuggerPaused]: DebuggerModel,
-  [Events.DebuggerResumed]: DebuggerModel,
-  [Events.ParsedScriptSource]: Script,
-  [Events.DiscardedAnonymousScriptSource]: Script,
-  [Events.GlobalObjectCleared]: DebuggerModel,
-  [Events.CallFrameSelected]: DebuggerModel,
-  [Events.DebuggerIsReadyToPause]: DebuggerModel,
-  [Events.DebugInfoAttached]: Script,
+export interface EventTypes {
+  [Events.DebuggerWasEnabled]: DebuggerModel;
+  [Events.DebuggerWasDisabled]: DebuggerModel;
+  [Events.DebuggerPaused]: DebuggerModel;
+  [Events.DebuggerResumed]: DebuggerModel;
+  [Events.ParsedScriptSource]: Script;
+  [Events.DiscardedAnonymousScriptSource]: Script;
+  [Events.GlobalObjectCleared]: DebuggerModel;
+  [Events.CallFrameSelected]: DebuggerModel;
+  [Events.DebuggerIsReadyToPause]: DebuggerModel;
+  [Events.DebugInfoAttached]: Script;
   [Events.ScriptSourceWasEdited]: {
     script: Script,
     status: Protocol.Debugger.SetScriptSourceResponseStatus,
-  },
-};
+  };
+}
 
 class DebuggerDispatcher implements ProtocolProxyApi.DebuggerDispatcher {
   #debuggerModel: DebuggerModel;

package/front_end/core/sdk/EmulationModel.ts

@@ -2,16 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as Common from '../common/common.js';
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import * as Protocol from '../../generated/protocol.js';
+import * as Common from '../common/common.js';
 
 import {CSSModel} from './CSSModel.js';
 import {MultitargetNetworkManager} from './NetworkManager.js';
 import {Events, OverlayModel} from './OverlayModel.js';
-
-import {Capability, type Target} from './Target.js';
 import {SDKModel} from './SDKModel.js';
+import {Capability, type Target} from './Target.js';
 
 export class EmulationModel extends SDKModel<void> {
   readonly #emulationAgent: ProtocolProxyApi.EmulationApi;

package/front_end/core/sdk/FrameManager.ts

@@ -250,10 +250,10 @@ export const enum Events {
   OUTERMOST_FRAME_NAVIGATED = 'OutermostFrameNavigated',
 }
 
-export type EventTypes = {
-  [Events.FRAME_ADDED_TO_TARGET]: {frame: ResourceTreeFrame},
-  [Events.FRAME_NAVIGATED]: {frame: ResourceTreeFrame},
-  [Events.FRAME_REMOVED]: {frameId: Protocol.Page.FrameId},
-  [Events.RESOURCE_ADDED]: {resource: Resource},
-  [Events.OUTERMOST_FRAME_NAVIGATED]: {frame: ResourceTreeFrame},
-};
+export interface EventTypes {
+  [Events.FRAME_ADDED_TO_TARGET]: {frame: ResourceTreeFrame};
+  [Events.FRAME_NAVIGATED]: {frame: ResourceTreeFrame};
+  [Events.FRAME_REMOVED]: {frameId: Protocol.Page.FrameId};
+  [Events.RESOURCE_ADDED]: {resource: Resource};
+  [Events.OUTERMOST_FRAME_NAVIGATED]: {frame: ResourceTreeFrame};
+}

package/front_end/core/sdk/HeapProfilerModel.ts

@@ -167,13 +167,13 @@ export interface HeapSnapshotProgress {
   finished?: boolean;
 }
 
-export type EventTypes = {
-  [Events.HEAP_STATS_UPDATED]: HeapStatsUpdateSamples,
-  [Events.LAST_SEEN_OBJECT_ID]: LastSeenObjectId,
-  [Events.ADD_HEAP_SNAPSHOT_CHUNK]: string,
-  [Events.REPORT_HEAP_SNAPSHOT_PROGRESS]: HeapSnapshotProgress,
-  [Events.RESET_PROFILES]: HeapProfilerModel,
-};
+export interface EventTypes {
+  [Events.HEAP_STATS_UPDATED]: HeapStatsUpdateSamples;
+  [Events.LAST_SEEN_OBJECT_ID]: LastSeenObjectId;
+  [Events.ADD_HEAP_SNAPSHOT_CHUNK]: string;
+  [Events.REPORT_HEAP_SNAPSHOT_PROGRESS]: HeapSnapshotProgress;
+  [Events.RESET_PROFILES]: HeapProfilerModel;
+}
 
 export interface NativeProfilerCallFrame {
   functionName: string;

package/front_end/core/sdk/IOModel.ts

@@ -2,13 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import type * as Protocol from '../../generated/protocol.js';
 import * as Common from '../common/common.js';
 
 import {RemoteObject} from './RemoteObject.js';
-
-import {Capability, type Target} from './Target.js';
 import {SDKModel} from './SDKModel.js';
-import type * as Protocol from '../../generated/protocol.js';
+import {Capability, type Target} from './Target.js';
 
 export class IOModel extends SDKModel<void> {
   constructor(target: Target) {

package/front_end/core/sdk/IsolateManager.ts

@@ -141,9 +141,9 @@ export const enum Events {
   MEMORY_CHANGED = 'MemoryChanged',
 }
 
-export type EventTypes = {
-  [Events.MEMORY_CHANGED]: Isolate,
-};
+export interface EventTypes {
+  [Events.MEMORY_CHANGED]: Isolate;
+}
 
 export const MemoryTrendWindowMs = 120e3;
 const PollIntervalMs = 2e3;
@@ -185,7 +185,7 @@ export class Isolate {
     if (!usage) {
       return;
     }
-    this.#usedHeapSizeInternal = usage.usedSize;
+    this.#usedHeapSizeInternal = usage.usedSize + usage.embedderHeapUsedSize + usage.backingStorageSize;
     this.#memoryTrend.add(this.#usedHeapSizeInternal);
     IsolateManager.instance().dispatchEventToListeners(Events.MEMORY_CHANGED, this);
   }

package/front_end/core/sdk/IssuesModel.ts

@@ -5,8 +5,11 @@
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import type * as Protocol from '../../generated/protocol.js';
 
-import {Capability, type Target} from './Target.js';
 import {SDKModel} from './SDKModel.js';
+import {
+  Capability,
+  type Target,
+} from './Target.js';
 
 /**
  * The `IssuesModel` is a thin dispatch that does not store issues, but only creates the representation
@@ -60,8 +63,8 @@ export interface IssueAddedEvent {
   inspectorIssue: Protocol.Audits.InspectorIssue;
 }
 
-export type EventTypes = {
-  [Events.ISSUE_ADDED]: IssueAddedEvent,
-};
+export interface EventTypes {
+  [Events.ISSUE_ADDED]: IssueAddedEvent;
+}
 
 SDKModel.register(IssuesModel, {capabilities: Capability.AUDITS, autostart: true});

package/front_end/core/sdk/LogModel.ts

@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as Host from '../host/host.js';
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import * as Protocol from '../../generated/protocol.js';
+import * as Host from '../host/host.js';
 
-import {Capability, type Target} from './Target.js';
 import {SDKModel} from './SDKModel.js';
+import {Capability, type Target} from './Target.js';
 
 export class LogModel extends SDKModel<EventTypes> implements ProtocolProxyApi.LogDispatcher {
   readonly #logAgent: ProtocolProxyApi.LogApi;
@@ -49,8 +49,8 @@ export interface EntryAddedEvent {
   entry: Protocol.Log.LogEntry;
 }
 
-export type EventTypes = {
-  [Events.ENTRY_ADDED]: EntryAddedEvent,
-};
+export interface EventTypes {
+  [Events.ENTRY_ADDED]: EntryAddedEvent;
+}
 
 SDKModel.register(LogModel, {capabilities: Capability.LOG, autostart: true});