chrome-devtools-frontend 1.0.1642246 → 1.0.1642845

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshot.ts

@@ -1068,6 +1068,17 @@ export abstract class HeapSnapshot {
     this.#progress.updateStatus('Finished processing.');
   }
 
+  nodeIndexForId(nodeId: number): number|undefined {
+    const nodesLength = this.nodes.length;
+    const {nodes, nodeFieldCount, nodeIdOffset} = this;
+    for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
+      if (nodes.getValue(nodeIndex + nodeIdOffset) === nodeId) {
+        return nodeIndex;
+      }
+    }
+    return undefined;
+  }
+
   private startInitStep1InSecondThread(secondWorker: PlatformApi.HostRuntime.WorkerMessagePort):
       Promise<ResultsFromSecondWorker> {
     const resultsFromSecondWorker = new Promise<ResultsFromSecondWorker>((resolve, reject) => {

package/front_end/models/ai_assistance/agents/AccessibilityAgent.ts

@@ -161,10 +161,6 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
     };
   }
 
-  override preambleFeatures(): string[] {
-    return ['function_calling'];
-  }
-
   protected override async preRun(): Promise<void> {
     this.#currentTurnId++;
     const target = SDK.TargetManager.TargetManager.instance().primaryPageTarget();

package/front_end/models/ai_assistance/agents/AiAgent.ts

@@ -530,10 +530,6 @@ export abstract class AiAgent<T> {
     return undefined;
   }
 
-  preambleFeatures(): string[] {
-    return [];
-  }
-
   buildRequest(
       part: Host.AidaClient.Part|Host.AidaClient.Part[],
       role: Host.AidaClient.Role.USER|Host.AidaClient.Role.ROLE_UNSPECIFIED): Host.AidaClient.DoConversationRequest {
@@ -577,8 +573,7 @@ export abstract class AiAgent<T> {
         disable_user_content_logging: !(this.#serverSideLoggingEnabled ?? false),
         string_session_id: this.#sessionId,
         user_tier: userTier,
-        client_version:
-            Root.Runtime.getChromeVersion() + this.preambleFeatures().map(feature => `+${feature}`).join(''),
+        client_version: Root.Runtime.getChromeVersion(),
       },
 
       functionality_type: enableAidaFunctionCalling ? Host.AidaClient.FunctionalityType.AGENTIC_CHAT :

package/front_end/models/ai_assistance/agents/StylingAgent.snapshot.txt

@@ -154,7 +154,7 @@ Content:
     "disable_user_content_logging": false,
     "string_session_id": "sessionId",
     "user_tier": 3,
-    "client_version": "unit_test+function_calling"
+    "client_version": "unit_test"
   },
   "functionality_type": 5,
   "client_feature": 2

package/front_end/models/ai_assistance/agents/StylingAgent.ts

@@ -254,10 +254,6 @@ export class StylingAgent extends AiAgent<SDK.DOMModel.DOMNode> {
     return Boolean(Root.Runtime.hostConfig.devToolsFreestyler?.multimodal);
   }
 
-  override preambleFeatures(): string[] {
-    return ['function_calling'];
-  }
-
   #execJs: typeof executeJsCode;
   #javascriptExecutor: JavascriptExecutor;
 

package/front_end/models/ai_assistance/data_formatters/NetworkRequestFormatter.ts

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as Common from '../../../core/common/common.js';
+import type * as Platform from '../../../core/platform/platform.js';
 import type * as SDK from '../../../core/sdk/sdk.js';
 import * as Protocol from '../../../generated/protocol.js';
 import * as Annotations from '../../annotations/annotations.js';
@@ -68,17 +70,16 @@ export class NetworkRequestFormatter {
     return `${title}\n<binary data>`;
   }
 
-  static formatInitiatorUrl(initiatorUrl: string, allowedOrigin: string): string {
-    try {
-      // Some scheme or URLs might cause errors depending on the runtime environment.
-      const initiatorOrigin = new URL(initiatorUrl).origin;
-      if (initiatorOrigin === allowedOrigin) {
-        return initiatorUrl;
-      }
-      return '<redacted cross-origin initiator URL>';
-    } catch {
-      return '<redacted cross-origin initiator URL>';
+  static formatInitiatorUrl(
+      initiatorUrl: Platform.DevToolsPath.UrlString,
+      allowedOrigin: Platform.DevToolsPath.UrlString,
+      ): string {
+    // We extract the origin, and if it is invalid/empty we default to redacting.
+    const initiatorOrigin = Common.ParsedURL.ParsedURL.extractOrigin(initiatorUrl);
+    if (initiatorOrigin && initiatorOrigin === allowedOrigin) {
+      return initiatorUrl;
     }
+    return '<redacted cross-origin initiator URL>';
   }
 
   static formatStatus(status: {
@@ -196,7 +197,7 @@ Request initiator chain:\n${this.formatRequestInitiatorChain()}`;
    * the request's origin.
    */
   formatRequestInitiatorChain(): string {
-    const allowedOrigin = new URL(this.#request.url()).origin;
+    const allowedOrigin = Common.ParsedURL.ParsedURL.extractOrigin(this.#request.url());
     let initiatorChain = '';
     let lineStart = '- URL: ';
     const graph = Logs.NetworkLog.NetworkLog.instance().initiatorGraphForRequest(this.#request);
@@ -268,7 +269,7 @@ Request initiator chain:\n${this.formatRequestInitiatorChain()}`;
       parentRequest: SDK.NetworkRequest.NetworkRequest,
       initiatorChain: string,
       lineStart: string,
-      allowedOrigin: string,
+      allowedOrigin: Platform.DevToolsPath.UrlString,
       ): string {
     const visited = new Set<SDK.NetworkRequest.NetworkRequest>();
 

package/front_end/models/heap_snapshot/HeapSnapshotProxy.ts

@@ -289,6 +289,10 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callMethodPromise('nodeClassKey', snapshotObjectId);
   }
 
+  nodeIndexForId(nodeId: number): Promise<number|undefined> {
+    return this.callMethodPromise('nodeIndexForId', nodeId);
+  }
+
   createEdgesProvider(nodeIndex: number): HeapSnapshotProviderProxy {
     return this.callFactoryMethod('createEdgesProvider', HeapSnapshotProviderProxy, nodeIndex);
   }

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -6489,6 +6489,22 @@ export const NativeFunctions = [
     name: "XRLayerEvent",
     signatures: [["type","eventInitDict"]]
   },
+  {
+    name: "XRMediaBinding",
+    signatures: [["session"]]
+  },
+  {
+    name: "createQuadLayer",
+    signatures: [["video","init"]]
+  },
+  {
+    name: "createCylinderLayer",
+    signatures: [["video","init"]]
+  },
+  {
+    name: "createEquirectLayer",
+    signatures: [["video","init"]]
+  },
   {
     name: "XRRay",
     signatures: [["transform"],["?origin","?direction"]]

package/front_end/panels/console/SymbolizedErrorWidget.ts

@@ -3,15 +3,108 @@
 // found in the LICENSE file.
 
 import * as Bindings from '../../models/bindings/bindings.js';
+import type * as StackTrace from '../../models/stack_trace/stack_trace.js';
 import type * as Workspace from '../../models/workspace/workspace.js';
+import * as Components from '../../ui/legacy/components/utils/utils.js';
 import * as UI from '../../ui/legacy/legacy.js';
+import * as Lit from '../../ui/lit/lit.js';
+
+const {html, render} = Lit;
 
 export interface ViewInput {
   error: Bindings.SymbolizedError.SymbolizedError;
   ignoreListManager?: Workspace.IgnoreListManager.IgnoreListManager;
 }
 
-const DEFAULT_VIEW = (_input: ViewInput, _output: object, _target: HTMLElement): void => {};
+function renderHeader(content: Lit.LitTemplate|Node|UI.Widget.Widget, isCause: boolean): Lit.LitTemplate {
+  if (isCause) {
+    return html`<div class="symbolized-error-header"><span>Caused by: </span><span class="error-message-text">${
+        content}</span></div>`;
+  }
+  return html`<span class="error-message-text">${content}</span>`;
+}
+
+function renderFramePrefix(
+    frame: StackTrace.StackTrace.ParsedErrorStackFrame,
+    _options: Components.Linkifier.LinkifyOptions): Lit.LitTemplate {
+  const asyncPrefix = frame.isAsync ? 'async ' : '';
+  if (frame.promiseIndex !== undefined) {
+    const name = frame.name || 'Promise.all';
+    return html`${asyncPrefix}${name} (index ${frame.promiseIndex})`;
+  }
+  const constructorPrefix = frame.isConstructor ? 'new ' : '';
+  let name = frame.name || '';
+  const isInline = Boolean(frame.rawName) && frame.name !== frame.rawName;
+  if (!isInline && frame.methodName && name && name !== frame.methodName && !name.endsWith('.' + frame.methodName) &&
+      !name.endsWith(' ' + frame.methodName)) {
+    name += ` [as ${frame.methodName}]`;
+  }
+
+  if (name) {
+    return html`${asyncPrefix}${constructorPrefix}${name} (`;
+  }
+  return html`${asyncPrefix}${constructorPrefix}`;
+}
+
+function renderFrameSuffix(frame: StackTrace.StackTrace.ParsedErrorStackFrame): Lit.LitTemplate {
+  if (frame.promiseIndex !== undefined) {
+    return Lit.nothing;
+  }
+  if (frame.name) {
+    return html`)`;
+  }
+  return Lit.nothing;
+}
+
+const DEFAULT_VIEW = (input: ViewInput, _output: object, target: HTMLElement): void => {
+  const renderError = (error: Bindings.SymbolizedError.SymbolizedError, isCause: boolean): Lit.LitTemplate => {
+    if (!(error instanceof Bindings.SymbolizedError.SymbolizedErrorObject)) {
+      console.error('SymbolizedErrorWidget received an unsupported error type:', error);
+      return Lit.nothing;
+    }
+    const linkOptions: Components.Linkifier.LinkifyOptions = {
+      showColumnNumber: true,
+      inlineFrameIndex: 0,
+      maxLength: UI.UIUtils.MaxLengthForDisplayedURLsInConsole,
+      ignoreListManager: input.ignoreListManager,
+    };
+    const headerContent = html`${error.message}`;
+    const header = renderHeader(headerContent, isCause);
+    const syncFrames = error.stackTrace.syncFragment.frames;
+    // clang-format off
+    return html`
+      <span class=${isCause ? 'console-message-stack-trace-wrapper' : ''}
+      >${header}${syncFrames.length > 0 ? '\n' : ''}${syncFrames.map((frame: StackTrace.StackTrace.ParsedErrorStackFrame, i: number) => {
+          let linkElement: HTMLElement|Lit.LitTemplate = Lit.nothing;
+          let isBuiltin = false;
+          if (frame.promiseIndex !== undefined) {
+            // Promise.all doesn't have a linkable location.
+            isBuiltin = true;
+          } else if (frame.url || frame.uiSourceCode) {
+            const link = Components.Linkifier.Linkifier.linkifyStackTraceFrame(frame, linkOptions);
+            link.tabIndex = -1;
+            linkElement = link;
+          } else {
+            linkElement = html`<span>&lt;anonymous&gt;</span>`;
+            isBuiltin = true;
+          }
+
+          const newline = i < error.stackTrace.syncFragment.frames.length - 1 ? '\n' : '';
+          const frameClass = isBuiltin ? 'formatted-builtin-stack-frame' : 'formatted-stack-frame';
+          return html`
+            <span class=${frameClass}>${'    at '}${renderFramePrefix(frame, linkOptions)}${linkElement}${renderFrameSuffix(frame)}${newline}</span>
+          `;
+        })}
+      </span>
+      ${error.cause ? renderError(error.cause, true) : Lit.nothing}
+    `;
+    // clang-format on
+  };
+
+  // clang-format off
+  render(html`<span class="symbolized-error-widget">${renderError(input.error, false)}</span>`, target);
+  // clang-format on
+};
 
 export class SymbolizedErrorWidget extends UI.Widget.Widget {
   #error?: Bindings.SymbolizedError.SymbolizedError;
@@ -19,7 +112,8 @@ export class SymbolizedErrorWidget extends UI.Widget.Widget {
   #ignoreListManager?: Workspace.IgnoreListManager.IgnoreListManager;
 
   constructor(element?: HTMLElement, view: typeof DEFAULT_VIEW = DEFAULT_VIEW) {
-    super(element);
+    const host = element || document.createElement('span');
+    super(host, {classes: ['symbolized-error-widget-host']});
     this.#view = view;
   }
 

package/front_end/panels/console/symbolizedErrorWidget.css

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2026 The Chromium Authors
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+.symbolized-error-widget {
+  white-space: pre-wrap;
+  word-break: break-all;
+
+  --display-formatted-stack-frame-default: block;
+  --display-ignored-formatted-stack-frame-local: var(--display-ignored-formatted-stack-frame, none);
+
+  &.show-hidden-rows {
+    --display-ignored-formatted-stack-frame-local: var(--display-formatted-stack-frame-default);
+  }
+}
+
+.symbolized-error-widget .formatted-stack-frame {
+  display: var(--display-formatted-stack-frame-default);
+
+  &:has(.ignore-list-link) {
+    display: var(--display-ignored-formatted-stack-frame-local);
+    opacity: 60%;
+
+    /* Subsequent builtin stack frames are also treated as ignored */
+    & + .formatted-builtin-stack-frame {
+      display: var(--display-ignored-formatted-stack-frame-local);
+      opacity: 60%;
+    }
+  }
+}
+
+.symbolized-error-widget .formatted-builtin-stack-frame {
+  display: var(--display-formatted-stack-frame-default);
+}
+
+.symbolized-error-widget-host {
+  display: inline;
+}
+
+.symbolized-error-header {
+  display: block;
+}
+
+.error-message-text {
+  display: inline;
+}

package/front_end/third_party/chromium/README.chromium

@@ -1,7 +1,7 @@
 Name: Dependencies sourced from the upstream `chromium` repository
 URL: Internal
 Version: N/A
-Revision: 3b896e6bd479ace00cb8f591bd5b8905a94459a1
+Revision: 2d046db188ecad76b2859f8baeb9685cb8fe9c08
 Update Mechanism: Manual (https://crbug.com/428069060)
 License: BSD-3-Clause
 License File: LICENSE

package/front_end/ui/visual_logging/LoggingDriver.ts

@@ -80,6 +80,12 @@ export async function addDocument(document: Document): Promise<void> {
   }
   document.addEventListener('visibilitychange', scheduleProcessing);
   document.addEventListener('scroll', scheduleProcessing);
+  const resizeListener = (): void => {
+    viewportRects.delete(document);
+    scheduleProcessing();
+  };
+  document.defaultView?.addEventListener('resize', resizeListener);
+  resizeListeners.set(document, resizeListener);
   observeMutations([document.body]);
 }
 
@@ -90,12 +96,18 @@ export async function stopLogging(): Promise<void> {
   for (const document of documents) {
     document.removeEventListener('visibilitychange', scheduleProcessing);
     document.removeEventListener('scroll', scheduleProcessing);
+    const resizeListener = resizeListeners.get(document);
+    if (resizeListener) {
+      document.defaultView?.removeEventListener('resize', resizeListener);
+      resizeListeners.delete(document);
+    }
   }
   mutationObserver.disconnect();
   resizeObserver.disconnect();
   intersectionObserver.disconnect();
   documents.length = 0;
   viewportRects.clear();
+  resizeListeners.clear();
   processingThrottler = noOpThrottler;
   pendingResize.clear();
   pendingChange.clear();
@@ -130,6 +142,7 @@ export function scheduleProcessing(): void {
 }
 
 const viewportRects = new Map<Document, DOMRect>();
+const resizeListeners = new Map<Document, () => void>();
 const viewportRectFor = (element: Element): DOMRect => {
   const ownerDocument = element.ownerDocument;
   const viewportRect = viewportRects.get(ownerDocument) ||

package/package.json

@@ -92,5 +92,5 @@
     "webidl2": "24.5.0",
     "yargs": "17.7.2"
   },
-  "version": "1.0.1642246"
+  "version": "1.0.1642845"
 }