chrome-devtools-frontend 1.0.974080 → 1.0.974575

package/front_end/core/sdk/DOMModel.ts

@@ -1243,10 +1243,10 @@ export class DOMModel extends SDKModel<EventTypes> {
 
   documentUpdated(): void {
     // If we have this.#pendingDocumentRequestPromise in flight,
-    // if it hits backend post #document update, it will contain most recent result.
-    const documentWasRequested = this.#document || this.#pendingDocumentRequestPromise;
+    // it will contain most recent result.
+    const documentWasRequested = this.#pendingDocumentRequestPromise;
     this.setDocument(null);
-    if (this.parentModel() && documentWasRequested) {
+    if (this.parentModel() && !documentWasRequested) {
       void this.requestDocument();
     }
   }

package/front_end/generated/InspectorBackendCommands.js

@@ -113,11 +113,7 @@ export function registerCommands(inspectorBackend) {
       ['nodes']);
   inspectorBackend.registerCommand(
       'Accessibility.getFullAXTree',
-      [
-        {'name': 'depth', 'type': 'number', 'optional': true},
-        {'name': 'max_depth', 'type': 'number', 'optional': true},
-        {'name': 'frameId', 'type': 'string', 'optional': true}
-      ],
+      [{'name': 'depth', 'type': 'number', 'optional': true}, {'name': 'frameId', 'type': 'string', 'optional': true}],
       ['nodes']);
   inspectorBackend.registerCommand(
       'Accessibility.getRootAXNode', [{'name': 'frameId', 'type': 'string', 'optional': true}], ['node']);
@@ -211,6 +207,7 @@ export function registerCommands(inspectorBackend) {
     MixedContentWarning: 'MixedContentWarning'
   });
   inspectorBackend.registerEnum('Audits.MixedContentResourceType', {
+    AttributionSrc: 'AttributionSrc',
     Audio: 'Audio',
     Beacon: 'Beacon',
     CSPReport: 'CSPReport',
@@ -520,6 +517,8 @@ export function registerCommands(inspectorBackend) {
       'CSS.getPlatformFontsForNode', [{'name': 'nodeId', 'type': 'number', 'optional': false}], ['fonts']);
   inspectorBackend.registerCommand(
       'CSS.getStyleSheetText', [{'name': 'styleSheetId', 'type': 'string', 'optional': false}], ['text']);
+  inspectorBackend.registerCommand(
+      'CSS.getLayersForNode', [{'name': 'nodeId', 'type': 'number', 'optional': false}], ['rootLayer']);
   inspectorBackend.registerCommand(
       'CSS.trackComputedStyleUpdates', [{'name': 'propertiesToTrack', 'type': 'object', 'optional': false}], []);
   inspectorBackend.registerCommand('CSS.takeComputedStyleUpdates', [], ['nodeIds']);
@@ -656,10 +655,11 @@ export function registerCommands(inspectorBackend) {
     ScrollbarCorner: 'scrollbar-corner',
     Resizer: 'resizer',
     InputListButton: 'input-list-button',
-    Transition: 'transition',
-    TransitionContainer: 'transition-container',
-    TransitionOldContent: 'transition-old-content',
-    TransitionNewContent: 'transition-new-content'
+    PageTransition: 'page-transition',
+    PageTransitionContainer: 'page-transition-container',
+    PageTransitionImageWrapper: 'page-transition-image-wrapper',
+    PageTransitionOutgoingImage: 'page-transition-outgoing-image',
+    PageTransitionIncomingImage: 'page-transition-incoming-image'
   });
   inspectorBackend.registerEnum('DOM.ShadowRootType', {UserAgent: 'user-agent', Open: 'open', Closed: 'closed'});
   inspectorBackend.registerEnum(
@@ -1153,6 +1153,8 @@ export function registerCommands(inspectorBackend) {
         {'name': 'userAgentMetadata', 'type': 'object', 'optional': true}
       ],
       []);
+  inspectorBackend.registerCommand(
+      'Emulation.setAutomationOverride', [{'name': 'enabled', 'type': 'boolean', 'optional': false}], []);
 
   // HeadlessExperimental.
   inspectorBackend.registerEnum('HeadlessExperimental.ScreenshotParamsFormat', {Jpeg: 'jpeg', Png: 'png'});

package/front_end/generated/protocol-mapping.d.ts

@@ -976,6 +976,14 @@ export namespace ProtocolMapping {
      */
     'CSS.getStyleSheetText':
         {paramsType: [Protocol.CSS.GetStyleSheetTextRequest]; returnType: Protocol.CSS.GetStyleSheetTextResponse;};
+    /**
+     * Returns all layers parsed by the rendering engine for the tree scope of a node.
+     * Given a DOM element identified by nodeId, getLayersForNode returns the root
+     * layer for the nearest ancestor document or shadow root. The layer root contains
+     * the full layer tree for the tree scope and their ordering.
+     */
+    'CSS.getLayersForNode':
+        {paramsType: [Protocol.CSS.GetLayersForNodeRequest]; returnType: Protocol.CSS.GetLayersForNodeResponse;};
     /**
      * Starts tracking the given computed styles for updates. The specified array of properties
      * replaces the one previously specified. Pass empty array to disable tracking.
@@ -1593,6 +1601,11 @@ export namespace ProtocolMapping {
      * Allows overriding user agent with the given string.
      */
     'Emulation.setUserAgentOverride': {paramsType: [Protocol.Emulation.SetUserAgentOverrideRequest]; returnType: void;};
+    /**
+     * Allows overriding the automation flag.
+     */
+    'Emulation.setAutomationOverride':
+        {paramsType: [Protocol.Emulation.SetAutomationOverrideRequest]; returnType: void;};
     /**
      * Sends a BeginFrame to the target and returns when the frame was completed. Optionally captures a
      * screenshot from the resulting frame. Requires that the target was created with enabled

package/front_end/generated/protocol-proxy-api.d.ts

@@ -592,6 +592,15 @@ declare namespace ProtocolProxyApi {
     invoke_getStyleSheetText(params: Protocol.CSS.GetStyleSheetTextRequest):
         Promise<Protocol.CSS.GetStyleSheetTextResponse>;
 
+    /**
+     * Returns all layers parsed by the rendering engine for the tree scope of a node.
+     * Given a DOM element identified by nodeId, getLayersForNode returns the root
+     * layer for the nearest ancestor document or shadow root. The layer root contains
+     * the full layer tree for the tree scope and their ordering.
+     */
+    invoke_getLayersForNode(params: Protocol.CSS.GetLayersForNodeRequest):
+        Promise<Protocol.CSS.GetLayersForNodeResponse>;
+
     /**
      * Starts tracking the given computed styles for updates. The specified array of properties
      * replaces the one previously specified. Pass empty array to disable tracking.
@@ -1468,6 +1477,12 @@ declare namespace ProtocolProxyApi {
      */
     invoke_setUserAgentOverride(params: Protocol.Emulation.SetUserAgentOverrideRequest):
         Promise<Protocol.ProtocolResponseWithError>;
+
+    /**
+     * Allows overriding the automation flag.
+     */
+    invoke_setAutomationOverride(params: Protocol.Emulation.SetAutomationOverrideRequest):
+        Promise<Protocol.ProtocolResponseWithError>;
   }
   export interface EmulationDispatcher {
     /**

package/front_end/generated/protocol.ts

@@ -307,10 +307,6 @@ export namespace Accessibility {
      * If omitted, the full tree is returned.
      */
     depth?: integer;
-    /**
-     * Deprecated. This parameter has been renamed to `depth`. If depth is not provided, max_depth will be used.
-     */
-    max_depth?: integer;
     /**
      * The frame for whose document the AX tree should be retrieved.
      * If omited, the root frame is used.
@@ -758,6 +754,7 @@ export namespace Audits {
   }
 
   export const enum MixedContentResourceType {
+    AttributionSrc = 'AttributionSrc',
     Audio = 'Audio',
     Beacon = 'Beacon',
     CSPReport = 'CSPReport',
@@ -1059,7 +1056,7 @@ export namespace Audits {
   /**
    * Represents the failure reason when a federated authentication reason fails.
    * Should be updated alongside RequestIdTokenStatus in
-   * third_party/blink/public/mojom/webid/federated_auth_request.mojom to include
+   * third_party/blink/public/mojom/devtools/inspector_issue.mojom to include
    * all cases except for success.
    */
   export const enum FederatedAuthRequestIssueReason {
@@ -1924,6 +1921,11 @@ export namespace CSS {
      * The array enumerates @supports at-rules starting with the innermost one, going outwards.
      */
     supports?: CSSSupports[];
+    /**
+     * Cascade layer array. Contains the layer hierarchy that this rule belongs to starting
+     * with the innermost layer and going outwards.
+     */
+    layers?: CSSLayer[];
   }
 
   /**
@@ -2185,6 +2187,44 @@ export namespace CSS {
     styleSheetId?: StyleSheetId;
   }
 
+  /**
+   * CSS Layer at-rule descriptor.
+   */
+  export interface CSSLayer {
+    /**
+     * Layer name.
+     */
+    text: string;
+    /**
+     * The associated rule header range in the enclosing stylesheet (if
+     * available).
+     */
+    range?: SourceRange;
+    /**
+     * Identifier of the stylesheet containing this object (if exists).
+     */
+    styleSheetId?: StyleSheetId;
+  }
+
+  /**
+   * CSS Layer data.
+   */
+  export interface CSSLayerData {
+    /**
+     * Layer name.
+     */
+    name: string;
+    /**
+     * Direct sub-layers
+     */
+    subLayers?: CSSLayerData[];
+    /**
+     * Layer order. The order determines the order of the layer in the cascade order.
+     * A higher number has higher priority in the cascade order.
+     */
+    order: number;
+  }
+
   /**
    * Information about amount of glyphs that were rendered with given font.
    */
@@ -2495,6 +2535,14 @@ export namespace CSS {
     text: string;
   }
 
+  export interface GetLayersForNodeRequest {
+    nodeId: DOM.NodeId;
+  }
+
+  export interface GetLayersForNodeResponse extends ProtocolResponseWithError {
+    rootLayer: CSSLayerData;
+  }
+
   export interface TrackComputedStyleUpdatesRequest {
     propertiesToTrack: CSSComputedStyleProperty[];
   }
@@ -2951,10 +2999,11 @@ export namespace DOM {
     ScrollbarCorner = 'scrollbar-corner',
     Resizer = 'resizer',
     InputListButton = 'input-list-button',
-    Transition = 'transition',
-    TransitionContainer = 'transition-container',
-    TransitionOldContent = 'transition-old-content',
-    TransitionNewContent = 'transition-new-content',
+    PageTransition = 'page-transition',
+    PageTransitionContainer = 'page-transition-container',
+    PageTransitionImageWrapper = 'page-transition-image-wrapper',
+    PageTransitionOutgoingImage = 'page-transition-outgoing-image',
+    PageTransitionIncomingImage = 'page-transition-incoming-image',
   }
 
   /**
@@ -5351,6 +5400,13 @@ export namespace Emulation {
      */
     userAgentMetadata?: UserAgentMetadata;
   }
+
+  export interface SetAutomationOverrideRequest {
+    /**
+     * Whether the override should be enabled.
+     */
+    enabled: boolean;
+  }
 }
 
 /**

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -2634,7 +2634,7 @@ export const NativeFunctions = [
   },
   {
     name: 'transitionWhile',
-    signatures: [['newNavigationAction']]
+    signatures: [['newNavigationAction','?options']]
   },
   {
     name: 'updateCurrent',
@@ -2783,6 +2783,10 @@ export const NativeFunctions = [
     name: 'CSSKeywordValue',
     signatures: [['keyword']]
   },
+  {
+    name: 'CSSMathClamp',
+    signatures: [['lower','value','upper']]
+  },
   {
     name: 'CSSMathInvert',
     signatures: [['arg']]
@@ -2907,6 +2911,14 @@ export const NativeFunctions = [
     name: 'vh',
     signatures: [['value']]
   },
+  {
+    name: 'vi',
+    signatures: [['value']]
+  },
+  {
+    name: 'vb',
+    signatures: [['value']]
+  },
   {
     name: 'vmin',
     signatures: [['value']]
@@ -2915,6 +2927,78 @@ export const NativeFunctions = [
     name: 'vmax',
     signatures: [['value']]
   },
+  {
+    name: 'svw',
+    signatures: [['value']]
+  },
+  {
+    name: 'svh',
+    signatures: [['value']]
+  },
+  {
+    name: 'svi',
+    signatures: [['value']]
+  },
+  {
+    name: 'svb',
+    signatures: [['value']]
+  },
+  {
+    name: 'svmin',
+    signatures: [['value']]
+  },
+  {
+    name: 'svmax',
+    signatures: [['value']]
+  },
+  {
+    name: 'lvw',
+    signatures: [['value']]
+  },
+  {
+    name: 'lvh',
+    signatures: [['value']]
+  },
+  {
+    name: 'lvi',
+    signatures: [['value']]
+  },
+  {
+    name: 'lvb',
+    signatures: [['value']]
+  },
+  {
+    name: 'lvmin',
+    signatures: [['value']]
+  },
+  {
+    name: 'lvmax',
+    signatures: [['value']]
+  },
+  {
+    name: 'dvw',
+    signatures: [['value']]
+  },
+  {
+    name: 'dvh',
+    signatures: [['value']]
+  },
+  {
+    name: 'dvi',
+    signatures: [['value']]
+  },
+  {
+    name: 'dvb',
+    signatures: [['value']]
+  },
+  {
+    name: 'dvmin',
+    signatures: [['value']]
+  },
+  {
+    name: 'dvmax',
+    signatures: [['value']]
+  },
   {
     name: 'qw',
     signatures: [['value']]
@@ -3625,14 +3709,6 @@ export const NativeFunctions = [
     name: 'dispatchEvent',
     signatures: [['event']]
   },
-  {
-    name: 'Event',
-    signatures: [['type','?eventInitDict']]
-  },
-  {
-    name: 'initEvent',
-    signatures: [['type','?bubbles','?cancelable']]
-  },
   {
     name: 'MutationObserver',
     signatures: [['callback']]
@@ -4513,7 +4589,8 @@ export const NativeFunctions = [
   },
   {
     name: 'end',
-    signatures: [['index']]
+    signatures: [['index']],
+    receiver: 'TimeRanges'
   },
   {
     name: 'getTrackById',
@@ -6659,11 +6736,6 @@ export const NativeFunctions = [
     name: 'requestAll',
     signatures: [['permissions']]
   },
-  {
-    name: 'requestPictureInPicture',
-    signatures: [['?options']],
-    receiver: 'HTMLElement'
-  },
   {
     name: 'PictureInPictureEvent',
     signatures: [['type','eventInitDict']]
@@ -8544,10 +8616,6 @@ export const NativeFunctions = [
     name: 'requestAdapter',
     signatures: [['?options']]
   },
-  {
-    name: 'provide',
-    signatures: [['?id_token']]
-  },
   {
     name: 'MIDIConnectionEvent',
     signatures: [['type','?eventInitDict']]

package/front_end/panels/console/ConsolePrompt.ts

@@ -41,6 +41,10 @@ export class ConsolePrompt extends Common.ObjectWrapper.eventMixin<EventTypes, t
   private readonly eagerEvalSetting: Common.Settings.Setting<boolean>;
   private previewRequestForTest: Promise<void>|null;
   private highlightingNode: boolean;
+  // The CodeMirror state field that controls whether the argument hints are showing.
+  // If they are, the escape key will clear them. However, if they aren't, then the
+  // console drawer should be hidden as a whole.
+  #argumentHintsState: CodeMirror.StateField<CodeMirror.Tooltip|null>;
 
   constructor() {
     super();
@@ -70,13 +74,15 @@ export class ConsolePrompt extends Common.ObjectWrapper.eventMixin<EventTypes, t
     this.element.tabIndex = 0;
     this.previewRequestForTest = null;
     this.highlightingNode = false;
+    const argumentHints = TextEditor.JavaScript.argumentHints();
+    this.#argumentHintsState = argumentHints[0];
 
     const editorState = CodeMirror.EditorState.create({
       doc: this.initialText,
       extensions: [
         CodeMirror.keymap.of(this.editorKeymap()),
         CodeMirror.EditorView.updateListener.of(update => this.editorUpdate(update)),
-        TextEditor.JavaScript.argumentHints(),
+        argumentHints,
         TextEditor.JavaScript.completion(),
         TextEditor.Config.showCompletionHint,
         CodeMirror.javascript.javascript(),
@@ -212,8 +218,7 @@ export class ConsolePrompt extends Common.ObjectWrapper.eventMixin<EventTypes, t
       {
         key: 'Escape',
         run: (): boolean => {
-          TextEditor.JavaScript.closeArgumentsHintsTooltip(this.editor.editor);
-          return true;
+          return TextEditor.JavaScript.closeArgumentsHintsTooltip(this.editor.editor, this.#argumentHintsState);
         },
       },
       {
@@ -266,7 +271,7 @@ export class ConsolePrompt extends Common.ObjectWrapper.eventMixin<EventTypes, t
   private async handleEnter(): Promise<void> {
     if (await this.enterWillEvaluate()) {
       this.appendCommand(this.text(), true);
-      TextEditor.JavaScript.closeArgumentsHintsTooltip(this.editor.editor);
+      TextEditor.JavaScript.closeArgumentsHintsTooltip(this.editor.editor, this.#argumentHintsState);
       this.editor.dispatch({
         changes: {from: 0, to: this.editor.state.doc.length},
         scrollIntoView: true,

package/front_end/ui/components/text_editor/cursor_tooltip.ts

@@ -4,11 +4,12 @@
 
 import * as CodeMirror from '../../../third_party/codemirror.next/codemirror.next.js';
 
+export type ArgumentHintsTooltip = [CodeMirror.StateField<CodeMirror.Tooltip|null>, CodeMirror.ViewPlugin<{}>];
 export const closeTooltip = CodeMirror.StateEffect.define<null>();
 
 export function cursorTooltip(
     source: (state: CodeMirror.EditorState, pos: number) => Promise<(() => CodeMirror.TooltipView)|null>,
-    ): CodeMirror.Extension {
+    ): ArgumentHintsTooltip {
   const openTooltip = CodeMirror.StateEffect.define<() => CodeMirror.TooltipView>();
 
   const state = CodeMirror.StateField.define<null|CodeMirror.Tooltip>({

package/front_end/ui/components/text_editor/javascript.ts

@@ -8,7 +8,7 @@ import * as JavaScriptMetaData from '../../../models/javascript_metadata/javascr
 import * as CodeMirror from '../../../third_party/codemirror.next/codemirror.next.js';
 import * as UI from '../../legacy/legacy.js';
 
-import {closeTooltip, cursorTooltip} from './cursor_tooltip.js';
+import {type ArgumentHintsTooltip, closeTooltip, cursorTooltip} from './cursor_tooltip.js';
 
 export function completion(): CodeMirror.Extension {
   return CodeMirror.javascript.javascriptLanguage.data.of({
@@ -421,12 +421,19 @@ export async function isExpressionComplete(expression: string): Promise<boolean>
   return false;
 }
 
-export function argumentHints(): CodeMirror.Extension {
+export function argumentHints(): ArgumentHintsTooltip {
   return cursorTooltip(getArgumentHints);
 }
 
-export function closeArgumentsHintsTooltip(view: CodeMirror.EditorView): void {
+export function closeArgumentsHintsTooltip(
+    view: CodeMirror.EditorView, tooltip: CodeMirror.StateField<CodeMirror.Tooltip|null>): boolean {
+  // If the tooltip is currently showing, the state will reflect its properties.
+  // If it isn't showing, the state is explicitly set to `null`.
+  if (view.state.field(tooltip) === null) {
+    return false;
+  }
   view.dispatch({effects: closeTooltip.of(null)});
+  return true;
 }
 
 async function getArgumentHints(

package/front_end/ui/legacy/Toolbar.ts

@@ -542,6 +542,7 @@ export class ToolbarButton extends ToolbarItem<ToolbarButton.EventTypes> {
   private textElement: HTMLElement;
   private text?: string;
   private glyph?: string;
+  private icon?: HTMLElement;
   /**
    * TODO(crbug.com/1126026): remove glyph parameter in favor of icon.
    */
@@ -557,11 +558,8 @@ export class ToolbarButton extends ToolbarItem<ToolbarButton.EventTypes> {
     this.textElement = this.element.createChild('div', 'toolbar-text hidden');
 
     this.setTitle(title);
-    if (glyphOrIcon instanceof HTMLElement) {
-      glyphOrIcon.classList.add('toolbar-icon');
-      this.element.append(glyphOrIcon);
-    } else if (glyphOrIcon) {
-      this.setGlyph(glyphOrIcon);
+    if (glyphOrIcon) {
+      this.setGlyphOrIcon(glyphOrIcon);
     }
     this.setText(text || '');
     this.title = '';
@@ -580,6 +578,20 @@ export class ToolbarButton extends ToolbarItem<ToolbarButton.EventTypes> {
     this.text = text;
   }
 
+  setGlyphOrIcon(glyphOrIcon: string|HTMLElement): void {
+    if (glyphOrIcon instanceof HTMLElement) {
+      glyphOrIcon.classList.add('toolbar-icon');
+      if (this.icon) {
+        this.icon.replaceWith(glyphOrIcon);
+      } else {
+        this.element.appendChild(glyphOrIcon);
+      }
+      this.icon = glyphOrIcon;
+    } else if (glyphOrIcon) {
+      this.setGlyph(glyphOrIcon);
+    }
+  }
+
   setGlyph(glyph: string): void {
     if (this.glyph === glyph) {
       return;
@@ -739,14 +751,14 @@ export namespace ToolbarInput {
 
 export class ToolbarToggle extends ToolbarButton {
   private toggledInternal: boolean;
-  private readonly untoggledGlyph: string|undefined;
-  private readonly toggledGlyph: string|undefined;
+  private readonly untoggledGlyphOrIcon: string|HTMLElement|undefined;
+  private readonly toggledGlyphOrIcon: string|HTMLElement|undefined;
 
-  constructor(title: string, glyph?: string, toggledGlyph?: string) {
-    super(title, glyph, '');
+  constructor(title: string, glyphOrIcon?: string|HTMLElement, toggledGlyphOrIcon?: string|HTMLElement) {
+    super(title, glyphOrIcon, '');
     this.toggledInternal = false;
-    this.untoggledGlyph = glyph;
-    this.toggledGlyph = toggledGlyph;
+    this.untoggledGlyphOrIcon = glyphOrIcon;
+    this.toggledGlyphOrIcon = toggledGlyphOrIcon;
     this.element.classList.add('toolbar-state-off');
     ARIAUtils.setPressed(this.element, false);
   }
@@ -763,8 +775,8 @@ export class ToolbarToggle extends ToolbarButton {
     this.element.classList.toggle('toolbar-state-on', toggled);
     this.element.classList.toggle('toolbar-state-off', !toggled);
     ARIAUtils.setPressed(this.element, toggled);
-    if (this.toggledGlyph && this.untoggledGlyph) {
-      this.setGlyph(toggled ? this.toggledGlyph : this.untoggledGlyph);
+    if (this.toggledGlyphOrIcon && this.untoggledGlyphOrIcon) {
+      this.setGlyphOrIcon(toggled ? this.toggledGlyphOrIcon : this.untoggledGlyphOrIcon);
     }
   }
 

package/package.json

@@ -54,5 +54,5 @@
     "unittest": "scripts/test/run_unittests.py --no-text-coverage",
     "watch": "third_party/node/node.py --output scripts/watch_build.js"
   },
-  "version": "1.0.974080"
+  "version": "1.0.974575"
 }