chrome-devtools-frontend 1.0.1632065 → 1.0.1635648

package/front_end/models/ai_assistance/AiConversation.ts

@@ -429,16 +429,7 @@ export class AiConversation {
         throw new Error('cross-origin context data should not be included');
       }
 
-      const userQuery: UserQuery = {
-        type: ResponseType.USER_QUERY,
-        query: initialQuery,
-        imageInput: options.multimodalInput?.input,
-        imageId: options.multimodalInput?.id,
-      };
-      void this.addHistoryItem(userQuery);
-      yield userQuery;
-
-      yield* this.#runAgent(initialQuery, options);
+      yield* this.#runAgent(initialQuery, options, {isInitialCall: true});
     } finally {
       targetManager.removeModelListener(
           SDK.ResourceTreeModel.ResourceTreeModel, SDK.ResourceTreeModel.Events.PrimaryPageChanged, listener, this);
@@ -456,6 +447,7 @@ export class AiConversation {
             signal?: AbortSignal,
             multimodalInput?: MultimodalInput,
           } = {},
+          runOptions: {isInitialCall?: boolean} = {},
           ): AsyncGenerator<ResponseData, void, void> {
     this.#setOriginIfEmpty(this.selectedContext?.getOrigin());
     if (this.isBlockedByOrigin) {
@@ -466,6 +458,17 @@ export class AiConversation {
       return;
     }
 
+    if (runOptions.isInitialCall) {
+      const userQuery: UserQuery = {
+        type: ResponseType.USER_QUERY,
+        query: initialQuery,
+        imageInput: options.multimodalInput?.input,
+        imageId: options.multimodalInput?.id,
+      };
+      void this.addHistoryItem(userQuery);
+      yield userQuery;
+    }
+
     function shouldAddToHistory(data: ResponseData): boolean {
       if (data.type === ResponseType.CONTEXT_CHANGE) {
         return false;
@@ -499,7 +502,9 @@ export class AiConversation {
       // requery with the specialized agent.
       if (data.type === ResponseType.CONTEXT_CHANGE) {
         this.setContext(data.context);
-        yield* this.#runAgent(this.#getQueryAfterSelection(initialQuery, data.description), options);
+        yield*
+            this.#runAgent(
+                this.#getQueryAfterSelection(initialQuery, data.description), options, {isInitialCall: false});
         return;
       }
     }

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

@@ -236,7 +236,18 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
     if (!nodeId) {
       return null;
     }
-    return domModel.nodeForId(nodeId);
+    const node = domModel.nodeForId(nodeId);
+    if (!node) {
+      return null;
+    }
+
+    const resourceTreeModel = target.model(SDK.ResourceTreeModel.ResourceTreeModel);
+    const mainFrameId = resourceTreeModel?.mainFrame?.id;
+    if (node.frameId() !== mainFrameId) {
+      return null;
+    }
+
+    return node;
   }
 
   #declareFunctions(): void {
@@ -281,7 +292,7 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
         const audits = new LighthouseFormatter().audits(report, 'accessibility');
         return {
           result: {audits},
-          widgets: [{name: 'LIGHTHOUSE_REPORT', data: {report}}],
+          widgets: [{name: 'LIGHTHOUSE_REPORT', data: {report, snapshotReport: true}}],
         };
       }
     });

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

@@ -13,6 +13,8 @@ import type * as Trace from '../../trace/trace.js';
 import type * as Workspace from '../../workspace/workspace.js';
 import {debugLog, isStructuredLogEnabled} from '../debug.js';
 
+const MAX_SUGGESTION_LENGTH = 200;
+
 export const enum ResponseType {
   CONTEXT = 'context',
   TITLE = 'title',
@@ -35,6 +37,21 @@ export const enum ErrorType {
   CROSS_ORIGIN = 'cross-origin'
 }
 
+/**
+ * Returns true if the origin is considered opaque and should be blocked from
+ * AI assistance to prevent potential data leakage.
+ *
+ * @see https://crbug.com/513732588
+ */
+export function isOpaqueOrigin(origin: string): boolean {
+  /**
+   * Origins starting with 'about' (like about:blank or about:srcdoc) are
+   * considered opaque. 'about://' is the sentinel used by DevTools
+   * ParsedURL.securityOrigin() for these.
+   */
+  return origin === 'null' || origin === 'data:' || origin.startsWith('about') || origin.startsWith('detached');
+}
+
 export const enum MultimodalInputType {
   SCREENSHOT = 'screenshot',
   UPLOADED_IMAGE = 'uploaded-image',
@@ -185,15 +202,30 @@ export abstract class ConversationContext<T> {
   abstract getItem(): T;
   abstract getTitle(): string;
 
-  isOriginAllowed(agentOrigin: string|undefined): boolean {
-    if (!agentOrigin) {
+  /**
+   * Returns true if this data context (e.g., a DOM node or Network Request) is
+   * allowed to be included in a conversation that is locked to the provided
+   * `establishedOrigin`.
+   *
+   * A conversation is "locked" to an origin once the first query is made.
+   * This method ensures that we don't mix data from different origins in the
+   * same conversation.
+   *
+   * @param establishedOrigin The origin that the current conversation is locked to.
+   * If undefined, the conversation has not yet been locked to an origin.
+   */
+  isOriginAllowed(establishedOrigin: string|undefined): boolean {
+    const dataOrigin = this.getOrigin();
+    // Opaque origins are never allowed to be used as context.
+    if (isOpaqueOrigin(dataOrigin)) {
+      return false;
+    }
+    // If no origin is established yet, this context will be the one to lock the conversation.
+    if (!establishedOrigin) {
       return true;
     }
-    // Currently does not handle opaque origins because they
-    // are not available to DevTools, instead checks
-    // that serialization of the origin is the same
-    // https://html.spec.whatwg.org/#ascii-serialisation-of-an-origin.
-    return this.getOrigin() === agentOrigin;
+    // Only allow data that matches the origin the conversation is already locked to.
+    return dataOrigin === establishedOrigin;
   }
 
   /**
@@ -294,6 +326,7 @@ export interface LighthouseReportAiWidget {
   name: 'LIGHTHOUSE_REPORT';
   data: {
     report: LHModel.ReporterTypes.ReportJSON,
+    snapshotReport?: boolean,
   };
 }
 
@@ -545,8 +578,7 @@ export abstract class AiAgent<T> {
       const trimmed = line.trim();
       if (trimmed.startsWith('SUGGESTIONS:')) {
         try {
-          // TODO: Do basic validation this is an array with strings
-          suggestions = JSON.parse(trimmed.substring('SUGGESTIONS:'.length).trim());
+          suggestions = sanitizeSuggestions(trimmed.substring('SUGGESTIONS:'.length).trim());
         } catch {
         }
       } else {
@@ -559,8 +591,7 @@ export abstract class AiAgent<T> {
     if (!suggestions && answerLines.at(-1)?.includes('SUGGESTIONS:')) {
       const [answer, suggestionsText] = answerLines[answerLines.length - 1].split('SUGGESTIONS:', 2);
       try {
-        // TODO: Do basic validation this is an array with strings
-        suggestions = JSON.parse(suggestionsText.trim().substring('SUGGESTIONS:'.length).trim());
+        suggestions = sanitizeSuggestions(suggestionsText.trim());
       } catch {
       }
       answerLines[answerLines.length - 1] = answer;
@@ -967,3 +998,26 @@ export abstract class AiAgent<T> {
     };
   }
 }
+
+function sanitizeSuggestions(suggestions: string): [string, ...string[]]|undefined {
+  const parsed = JSON.parse(suggestions);
+  if (!Array.isArray(parsed)) {
+    return undefined;
+  }
+  const sanitized: string[] = [];
+  for (const item of parsed) {
+    if (typeof item !== 'string') {
+      continue;
+    }
+    // Collapse multiple whitespace/newlines into a single space.
+    const noExtraWhitespace = item.replace(/\s+/g, ' ').trim();
+    if (noExtraWhitespace.length === 0) {
+      continue;
+    }
+    sanitized.push(noExtraWhitespace.substring(0, MAX_SUGGESTION_LENGTH));
+  }
+  if (sanitized.length === 0) {
+    return undefined;
+  }
+  return sanitized as [string, ...string[]];
+}

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

@@ -20,6 +20,7 @@ import {
   AiAgent,
   type AllowedOriginResult,
   type ContextResponse,
+  isOpaqueOrigin,
   type RequestOptions,
 } from './AiAgent.js';
 import {FileContext} from './FileAgent.js';
@@ -126,6 +127,11 @@ export class ContextSelectionAgent extends AiAgent<never> {
           };
         }
         const origin = allowedOriginResult.origin;
+        if (origin && isOpaqueOrigin(origin)) {
+          return {
+            error: 'No requests recorded by DevTools',
+          };
+        }
 
         let hasCrossOriginRequest = false;
         for (const request of Logs.NetworkLog.NetworkLog.instance().requests()) {
@@ -196,6 +202,11 @@ export class ContextSelectionAgent extends AiAgent<never> {
           };
         }
         const origin = allowedOriginResult.origin;
+        if (origin && isOpaqueOrigin(origin)) {
+          return {
+            error: 'No request found',
+          };
+        }
         const request = Logs.NetworkLog.NetworkLog.instance().requests().find(req => {
           if (req.requestId() !== id) {
             return false;
@@ -235,8 +246,23 @@ export class ContextSelectionAgent extends AiAgent<never> {
         };
       },
       handler: async () => {
+        const allowedOriginResult = this.#allowedOrigin();
+        if ('blocked' in allowedOriginResult) {
+          return {
+            error: 'Cross-origin access blocked due to navigation. Please start a new chat.',
+          };
+        }
+        const origin = allowedOriginResult.origin;
+
         const files: Array<{file: string, id: number | undefined}> = [];
         for (const file of ContextSelectionAgent.getUISourceCodes()) {
+          const fileUrl = file.url();
+          const fileOrigin = Common.ParsedURL.ParsedURL.extractOrigin(fileUrl);
+
+          if (origin && fileOrigin !== origin) {
+            continue;
+          }
+
           files.push({
             file: file.fullDisplayName(),
             id: ContextSelectionAgent.uiSourceCodeId.get(file),
@@ -272,8 +298,22 @@ export class ContextSelectionAgent extends AiAgent<never> {
         };
       },
       handler: async params => {
-        const file = ContextSelectionAgent.getUISourceCodes().find(
-            file => ContextSelectionAgent.uiSourceCodeId.get(file) === params.id);
+        const allowedOriginResult = this.#allowedOrigin();
+        if ('blocked' in allowedOriginResult) {
+          return {
+            error: 'Cross-origin access blocked due to navigation. Please start a new chat.',
+          };
+        }
+        const origin = allowedOriginResult.origin;
+
+        const file = ContextSelectionAgent.getUISourceCodes().find(file => {
+          if (ContextSelectionAgent.uiSourceCodeId.get(file) !== params.id) {
+            return false;
+          }
+          const fileUrl = file.url();
+          const fileOrigin = Common.ParsedURL.ParsedURL.extractOrigin(fileUrl);
+          return !origin || fileOrigin === origin;
+        });
 
         if (!file) {
           return {

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

@@ -14,6 +14,7 @@ import * as Logs from '../../logs/logs.js';
 import * as SourceMapScopes from '../../source_map_scopes/source_map_scopes.js';
 import * as TextUtils from '../../text_utils/text_utils.js';
 import * as Trace from '../../trace/trace.js';
+import {sanitizeHeaders} from '../data_formatters/NetworkRequestFormatter.js';
 import {
   PerformanceInsightFormatter,
 } from '../data_formatters/PerformanceInsightFormatter.js';
@@ -1060,7 +1061,35 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
         }
 
         // TODO(b/425270067): Format in the same way that "Summary" detail tab does.
-        const details = JSON.stringify(event);
+        let details;
+        if (Trace.Types.Events.isSyntheticNetworkRequest(event)) {
+          const eventToSerialize = {
+            ...event,
+            args: {
+              ...event.args,
+              data: {
+                ...event.args.data,
+                responseHeaders: event.args.data.responseHeaders ? sanitizeHeaders(event.args.data.responseHeaders) :
+                                                                   null,
+              },
+            },
+          };
+          details = JSON.stringify(eventToSerialize);
+        } else if (Trace.Types.Events.isResourceReceiveResponse(event)) {
+          const eventToSerialize = {
+            ...event,
+            args: {
+              ...event.args,
+              data: {
+                ...event.args.data,
+                headers: event.args.data.headers ? sanitizeHeaders(event.args.data.headers) : undefined,
+              },
+            },
+          };
+          details = JSON.stringify(eventToSerialize);
+        } else {
+          details = JSON.stringify(event);
+        }
 
         const key = `getEventByKey('${params.eventKey}')`;
         this.#cacheFunctionResult(focus, key, details);

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

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import * as Common from '../../../core/common/common.js';
+import type * as CrUXManager from '../../crux-manager/crux-manager.js';
 import * as Trace from '../../trace/trace.js';
 import type {ConversationSuggestions} from '../agents/AiAgent.js';
 import type {AgentFocus} from '../performance/AIContext.js';
@@ -48,8 +49,9 @@ export class PerformanceInsightFormatter {
   #insight: Trace.Insights.Types.InsightModel;
   #parsedTrace: Trace.TraceModel.ParsedTrace;
 
-  constructor(focus: AgentFocus, insight: Trace.Insights.Types.InsightModel) {
-    this.#traceFormatter = new PerformanceTraceFormatter(focus);
+  constructor(
+      focus: AgentFocus, insight: Trace.Insights.Types.InsightModel, deviceScope: CrUXManager.DeviceScope|null = null) {
+    this.#traceFormatter = new PerformanceTraceFormatter(focus, deviceScope);
     this.#insight = insight;
     this.#parsedTrace = focus.parsedTrace;
   }

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

@@ -35,15 +35,17 @@ export class PerformanceTraceFormatter {
   #insightSet: Trace.Insights.Types.InsightSet|null;
   #eventsSerializer: Trace.EventsSerializer.EventsSerializer;
   #formattedFunctionCodes = new Set<string>();
+  #deviceScope: CrUXManager.DeviceScope|null;
   resolveFunctionCode?:
       (url: Platform.DevToolsPath.UrlString, line: number,
        column: number) => Promise<SourceMapScopes.FunctionCodeResolver.FunctionCode|null>;
 
-  constructor(focus: AgentFocus) {
+  constructor(focus: AgentFocus, deviceScope: CrUXManager.DeviceScope|null = null) {
     this.#focus = focus;
     this.#parsedTrace = focus.parsedTrace;
     this.#insightSet = focus.primaryInsightSet;
     this.#eventsSerializer = focus.eventsSerializer;
+    this.#deviceScope = deviceScope;
   }
 
   serializeEvent(event: Trace.Types.Events.Event): string {
@@ -64,7 +66,8 @@ export class PerformanceTraceFormatter {
       return [];
     }
     try {
-      const cruxScope = CrUXManager.CrUXManager.instance().getSelectedScope();
+      const cruxScope: CrUXManager.Scope = this.#deviceScope ? {pageScope: 'url', deviceScope: this.#deviceScope} :
+                                                               CrUXManager.CrUXManager.instance().getSelectedScope();
       const parts: string[] = [];
       const fieldMetrics =
           Trace.Insights.Common.getFieldMetricsForInsightSet(insightSet, this.#parsedTrace.metadata, cruxScope);

package/front_end/models/extensions/RecorderExtensionEndpoint.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 type * as Platform from '../../core/platform/platform.js';
+
 import {PrivateAPI} from './ExtensionAPI.js';
 import {ExtensionEndpoint} from './ExtensionEndpoint.js';
 import {RecorderPluginManager} from './RecorderPluginManager.js';
@@ -10,20 +12,26 @@ export class RecorderExtensionEndpoint extends ExtensionEndpoint {
   private readonly name: string;
   private readonly mediaType?: string;
   private readonly capabilities: PrivateAPI.RecordingExtensionPluginCapability[];
+  readonly #extensionOrigin: Platform.DevToolsPath.UrlString;
 
   constructor(
       name: string, port: MessagePort, capabilities: PrivateAPI.RecordingExtensionPluginCapability[],
-      mediaType?: string) {
+      extensionOrigin: Platform.DevToolsPath.UrlString, mediaType?: string) {
     super(port);
     this.name = name;
     this.mediaType = mediaType;
     this.capabilities = capabilities;
+    this.#extensionOrigin = extensionOrigin;
   }
 
   getName(): string {
     return this.name;
   }
 
+  getOrigin(): Platform.DevToolsPath.UrlString {
+    return this.#extensionOrigin;
+  }
+
   getCapabilities(): PrivateAPI.RecordingExtensionPluginCapability[] {
     return this.capabilities;
   }

package/front_end/models/extensions/RecorderPluginManager.ts

@@ -14,6 +14,7 @@ export interface ViewDescriptor {
   pagePath: string;
   onShown: () => void;
   onHidden: () => void;
+  extensionOrigin: string;
 }
 
 export class RecorderPluginManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {

package/front_end/models/trace/handlers/FramesHandler.ts

@@ -507,26 +507,28 @@ export class TimelineFrameBeginFrameQueue {
   private queueFrames: number[] = [];
 
   // Maps frameSeqId to BeginFrameInfo.
-  private mapFrames: Record<number, BeginFrameInfo> = {};
+  private mapFrames = new Map<number, BeginFrameInfo>();
 
   // Add a BeginFrame to the queue, if it does not already exit.
   addFrameIfNotExists(seqId: number, startTime: Types.Timing.Micro, isDropped: boolean, isPartial: boolean): void {
-    if (!(seqId in this.mapFrames)) {
-      this.mapFrames[seqId] = new BeginFrameInfo(seqId, startTime, isDropped, isPartial);
+    if (!this.mapFrames.has(seqId)) {
+      this.mapFrames.set(seqId, new BeginFrameInfo(seqId, startTime, isDropped, isPartial));
       this.queueFrames.push(seqId);
     }
   }
 
   // Set a BeginFrame in queue as dropped.
   setDropped(seqId: number, isDropped: boolean): void {
-    if (seqId in this.mapFrames) {
-      this.mapFrames[seqId].isDropped = isDropped;
+    const frame = this.mapFrames.get(seqId);
+    if (frame) {
+      frame.isDropped = isDropped;
     }
   }
 
   setPartial(seqId: number, isPartial: boolean): void {
-    if (seqId in this.mapFrames) {
-      this.mapFrames[seqId].isPartial = isPartial;
+    const frame = this.mapFrames.get(seqId);
+    if (frame) {
+      frame.isPartial = isPartial;
     }
   }
 
@@ -535,7 +537,7 @@ export class TimelineFrameBeginFrameQueue {
 
     // Do not visualize this frame in the rare case where the current DrawFrame
     // does not have a corresponding BeginFrame.
-    if (seqId in this.mapFrames) {
+    if (this.mapFrames.has(seqId)) {
       // Pop all BeginFrames before the current frame, and add only the dropped
       // ones in |frames_to_visualize|.
       // Non-dropped frames popped here are BeginFrames that are never
@@ -544,17 +546,21 @@ export class TimelineFrameBeginFrameQueue {
       // be naturally presented as continuationss of other frames.
       while (this.queueFrames[0] !== seqId) {
         const currentSeqId = this.queueFrames[0];
-        if (this.mapFrames[currentSeqId].isDropped) {
-          framesToVisualize.push(this.mapFrames[currentSeqId]);
+        const currentFrame = this.mapFrames.get(currentSeqId);
+        if (currentFrame && currentFrame.isDropped) {
+          framesToVisualize.push(currentFrame);
         }
 
-        delete this.mapFrames[currentSeqId];
+        this.mapFrames.delete(currentSeqId);
         this.queueFrames.shift();
       }
 
       // Pop the BeginFrame associated with the current DrawFrame.
-      framesToVisualize.push(this.mapFrames[seqId]);
-      delete this.mapFrames[seqId];
+      const frame = this.mapFrames.get(seqId);
+      if (frame) {
+        framesToVisualize.push(frame);
+      }
+      this.mapFrames.delete(seqId);
       this.queueFrames.shift();
     }
     return framesToVisualize;

package/front_end/panels/ai_assistance/components/AccessibilityAgentMarkdownRenderer.ts

@@ -123,6 +123,9 @@ export class AccessibilityAgentMarkdownRenderer extends MarkdownRendererWithCode
     if (!node) {
       return;
     }
+    if (node.frameId() !== this.mainFrameId) {
+      return;
+    }
     const linkedNode = PanelsCommon.DOMLinkifier.Linkifier.instance().linkify(node, {textContent: label});
     return linkedNode;
   }

package/front_end/panels/ai_assistance/components/ChatInput.ts

@@ -530,9 +530,11 @@ export class ChatInput extends UI.Widget.Widget implements SDK.TargetManager.Obs
 
   setInputValue(text: string): void {
     if (this.#textAreaRef.value) {
-      this.#textAreaRef.value.value = text;
+      const maxLength = this.#textAreaRef.value.maxLength;
+      const truncatedText = (maxLength >= 0) ? text.substring(0, maxLength) : text;
+      this.#textAreaRef.value.value = truncatedText;
       // Place the cursor at the end of the new value.
-      this.#textAreaRef.value.setSelectionRange(text.length, text.length);
+      this.#textAreaRef.value.setSelectionRange(truncatedText.length, truncatedText.length);
     }
     this.performUpdate();
   }

package/front_end/panels/ai_assistance/components/ChatMessage.ts

@@ -2090,11 +2090,13 @@ async function makeLighthouseReportWidget(widgetData: LighthouseReportAiWidget):
     return null;
   }
 
+  const snapshotReport = widgetData.data.snapshotReport;
+
   return {
     renderedWidget: html`<div class="lighthouse-report-widget">${reportEl}</div>`,
     revealable: new Lighthouse.LighthousePanel.ActiveLighthouseReport(widgetData.data.report),
     accessibleRevealLabel: lockedString(UIStringsNotTranslate.revealLighthouse),
     title: lockedString(UIStringsNotTranslate.lighthouseReport),
-    jslogContext: 'lighthouse-report-widget',
+    jslogContext: snapshotReport ? 'lighthouse-snapshot-report-widget' : 'lighthouse-report-widget',
   };
 }

package/front_end/panels/application/preloading/components/PreloadingString.ts

@@ -11,11 +11,6 @@ import * as Protocol from '../../../../generated/protocol.js';
 import * as Bindings from '../../../../models/bindings/bindings.js';
 
 const UIStrings = {
-  /**
-   * @description Descrption text for Prefetch status PrefetchCancelledOnUserNavigation.
-   */
-  PrefetchCancelledOnUserNavigation:
-      'The prefetch was cancelled because the user navigated the page before the prefetch finished',
   /**
    * @description  Description text for Prefetch status PrefetchFailedIneligibleRedirect.
    */
@@ -459,7 +454,6 @@ export const PrefetchReasonDescription: Record<string, {name: () => Platform.UIS
   PrefetchNotEligibleRedirectFromServiceWorker: {name: () => i18n.i18n.lockedString('Unknown')},
   PrefetchNotEligibleRedirectToServiceWorker: {name: () => i18n.i18n.lockedString('Unknown')},
   PrefetchEvictedAfterBrowsingDataRemoved: {name: i18nLazyString(UIStrings.PrefetchEvictedAfterBrowsingDataRemoved)},
-  PrefetchCancelledOnUserNavigation: {name: i18nLazyString(UIStrings.PrefetchCancelledOnUserNavigation)},
 };
 
 /** Decoding PrefetchFinalStatus prefetchAttempt to failure description. **/
@@ -546,8 +540,6 @@ export function prefetchFailureReason(
       return PrefetchReasonDescription['PrefetchNotEligibleRedirectToServiceWorker'].name();
     case Protocol.Preload.PrefetchStatus.PrefetchEvictedAfterBrowsingDataRemoved:
       return PrefetchReasonDescription['PrefetchEvictedAfterBrowsingDataRemoved'].name();
-    case Protocol.Preload.PrefetchStatus.PrefetchCancelledOnUserNavigation:
-      return PrefetchReasonDescription['PrefetchCancelledOnUserNavigation'].name();
     default:
       // Note that we use switch and exhaustiveness check to prevent to
       // forget updating these strings, but allow to handle unknown