chrome-devtools-frontend 1.0.1380117 → 1.0.1386602

package/front_end/panels/timeline/track_appenders/TimingsTrackAppender.test.ts

@@ -38,6 +38,17 @@ describeWithEnvironment('TimingTrackAppender', function() {
     entryTypeByLevel = [];
   });
 
+  function getMockInfo(event?: Trace.Types.Events.Event) {
+    const defaultInfo: Timeline.CompatibilityTracksAppender.PopoverInfo = {
+      title: event ? timingsTrackAppender.titleForEvent(event) : 'title',
+      formattedTime: event ? Timeline.AppenderUtils.getFormattedTime(event.dur) : 'time',
+      warningElements: [],
+      additionalElements: [],
+      url: null,
+    };
+    return defaultInfo;
+  }
+
   describe('appendTrackAtLevel', () => {
     it('marks all levels used by the track with the `TrackAppender` type', () => {
       // 8 levels should be taken:
@@ -208,12 +219,12 @@ describeWithEnvironment('TimingTrackAppender', function() {
     });
   });
 
-  describe('highlightedEntryInfo', () => {
+  describe('popoverInfo', () => {
     it('shows the time of the mark, not the duration, if the event is a performance mark', () => {
       const firstMark = parsedTrace.UserTimings.performanceMarks[0];
-      const highlightedEntryInfo = timingsTrackAppender.highlightedEntryInfo(firstMark);
-      assert.deepEqual(highlightedEntryInfo, {
-        title: '[mark]: myMark',
+      const popoverInfo = getMockInfo(firstMark);
+      timingsTrackAppender.setPopoverInfo(firstMark, popoverInfo);
+      assert.deepInclude(popoverInfo, {
         formattedTime: '1.12\u00A0s',
       });
     });
@@ -221,11 +232,10 @@ describeWithEnvironment('TimingTrackAppender', function() {
     it('shows the time of the mark for an LCP event', () => {
       const largestContentfulPaint = parsedTrace.PageLoadMetrics.allMarkerEvents.find(
           marker => marker.name === 'largestContentfulPaint::Candidate');
-      if (!largestContentfulPaint) {
-        throw new Error('Could not find LCP event');
-      }
-      const highlightedEntryInfo = timingsTrackAppender.highlightedEntryInfo(largestContentfulPaint);
-      assert.deepEqual(highlightedEntryInfo, {
+      assert.exists(largestContentfulPaint);
+      const popoverInfo = getMockInfo(largestContentfulPaint);
+      timingsTrackAppender.setPopoverInfo(largestContentfulPaint, popoverInfo);
+      assert.deepInclude(popoverInfo, {
         title: 'LCP',
         formattedTime: '2.42\u00A0s',
       });
@@ -234,11 +244,10 @@ describeWithEnvironment('TimingTrackAppender', function() {
     it('shows the time of the mark for an FCP event', () => {
       const firstContentfulPaint =
           parsedTrace.PageLoadMetrics.allMarkerEvents.find(marker => marker.name === 'firstContentfulPaint');
-      if (!firstContentfulPaint) {
-        throw new Error('Could not find FCP event');
-      }
-      const highlightedEntryInfo = timingsTrackAppender.highlightedEntryInfo(firstContentfulPaint);
-      assert.deepEqual(highlightedEntryInfo, {
+      assert.exists(firstContentfulPaint);
+      const popoverInfo = getMockInfo(firstContentfulPaint);
+      timingsTrackAppender.setPopoverInfo(firstContentfulPaint, popoverInfo);
+      assert.deepInclude(popoverInfo, {
         title: 'FCP',
         formattedTime: '2.42\u00A0s',
       });
@@ -246,11 +255,10 @@ describeWithEnvironment('TimingTrackAppender', function() {
 
     it('shows the time of the mark for a DCL event', () => {
       const dclEvent = parsedTrace.PageLoadMetrics.allMarkerEvents.find(marker => marker.name === 'MarkDOMContent');
-      if (!dclEvent) {
-        throw new Error('Could not find DCL event');
-      }
-      const highlightedEntryInfo = timingsTrackAppender.highlightedEntryInfo(dclEvent);
-      assert.deepEqual(highlightedEntryInfo, {
+      assert.exists(dclEvent);
+      const popoverInfo = getMockInfo(dclEvent);
+      timingsTrackAppender.setPopoverInfo(dclEvent, popoverInfo);
+      assert.deepInclude(popoverInfo, {
         title: 'DCL',
         formattedTime: '2.42\u00A0s',
       });
@@ -258,26 +266,29 @@ describeWithEnvironment('TimingTrackAppender', function() {
 
     it('shows the time of a console.timestamp event in the hover info', () => {
       const timestampEvent = parsedTrace.UserTimings.timestampEvents[0];
-      const highlightedEntryInfo = timingsTrackAppender.highlightedEntryInfo(timestampEvent);
+      const popoverInfo = getMockInfo(timestampEvent);
+      timingsTrackAppender.setPopoverInfo(timestampEvent, popoverInfo);
 
-      assert.deepEqual(highlightedEntryInfo, {
+      assert.deepInclude(popoverInfo, {
         title: 'TimeStamp: a timestamp',
         formattedTime: '615.25\u00A0ms',
       });
     });
 
     it('returns the info for a performance.measure calls correctly', () => {
-      const performanceMeasures = parsedTrace.UserTimings.performanceMeasures;
-      const highlightedEntryInfo = timingsTrackAppender.highlightedEntryInfo(performanceMeasures[0]);
+      const performanceMeasure = parsedTrace.UserTimings.performanceMeasures[0];
+      const popoverInfo = getMockInfo(performanceMeasure);
+      timingsTrackAppender.setPopoverInfo(performanceMeasure, popoverInfo);
       // The i18n encodes spaces using the u00A0 unicode character.
-      assert.strictEqual(highlightedEntryInfo.formattedTime, ('500.07\u00A0ms'));
+      assert.strictEqual(popoverInfo.formattedTime, ('500.07\u00A0ms'));
     });
 
     it('returns the info for a console.time calls correctly', () => {
-      const consoleTimings = parsedTrace.UserTimings.consoleTimings;
-      const highlightedEntryInfo = timingsTrackAppender.highlightedEntryInfo(consoleTimings[0]);
+      const consoleTiming = parsedTrace.UserTimings.consoleTimings[0];
+      const popoverInfo = getMockInfo(consoleTiming);
+      timingsTrackAppender.setPopoverInfo(consoleTiming, popoverInfo);
       // The i18n encodes spaces using the u00A0 unicode character.
-      assert.strictEqual(highlightedEntryInfo.formattedTime, ('1.60\u00A0s'));
+      assert.strictEqual(popoverInfo.formattedTime, ('1.60\u00A0s'));
     });
   });
 
@@ -328,8 +339,10 @@ describeWithEnvironment('TimingTrackAppender', function() {
 
     it('returns the correct color and title for extension markers', function() {
       const extensionMarkers = parsedTrace.ExtensionTraceData.extensionMarkers;
+      assert.lengthOf(extensionMarkers, 1);
       for (const event of extensionMarkers) {
-        assert.strictEqual(timingsTrackAppender.titleForEvent(event), event.name);
+        // tooltipText is supplied, so the title should be that.
+        assert.notStrictEqual(timingsTrackAppender.titleForEvent(event), event.name);
         if (event.args.color === 'error') {
           // "error" color category is mapped to --ref-palette-error50
           // which is faked out to 10, 10, 10
@@ -366,8 +379,9 @@ describeWithEnvironment('TimingTrackAppender', function() {
       const extensionMarker = parsedTrace.ExtensionTraceData.extensionMarkers.at(0);
       assert.isOk(extensionMarker, 'did not find any extension markers');
 
-      const highlightedEntryInfo = timingsTrackAppender.highlightedEntryInfo(extensionMarker);
-      assert.strictEqual(highlightedEntryInfo.title, 'A mark');
+      const popoverInfo = getMockInfo(extensionMarker);
+      timingsTrackAppender.setPopoverInfo(extensionMarker, popoverInfo);
+      assert.strictEqual(popoverInfo.title, 'A mark');
     });
     describe('toggling', function() {
       it('Does not append extension data when the configuration is set to disabled', async function() {

package/front_end/panels/timeline/utils/EntryName.ts

@@ -4,7 +4,6 @@
 
 import * as Common from '../../../core/common/common.js';
 import * as i18n from '../../../core/i18n/i18n.js';
-import * as Platform from '../../../core/platform/platform.js';
 import * as Trace from '../../../models/trace/trace.js';
 
 import {getEventStyle} from './EntryStyles.js';
@@ -81,7 +80,7 @@ export function nameForEntry(
     const parsedURL = new Common.ParsedURL.ParsedURL(entry.args.data.url);
     const text =
         parsedURL.isValid ? `${parsedURL.displayName} (${parsedURL.host})` : entry.args.data.url || 'Network request';
-    return Platform.StringUtilities.trimEndWithMaxLength(text, 40);
+    return text;
   }
 
   if (Trace.Types.Events.isWebSocketCreate(entry)) {

package/front_end/panels/timeline/utils/Helpers.ts

@@ -2,7 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import '../../../ui/components/markdown_view/markdown_view.js';
+
+import type * as Common from '../../../core/common/common.js';
 import * as Platform from '../../../core/platform/platform.js';
+import * as Marked from '../../../third_party/marked/marked.js';
+import * as LitHtml from '../../../ui/lit-html/lit-html.js';
+
+const {html} = LitHtml;
 
 function createTrimmedUrlSearch(url: URL): string {
   const maxSearchValueLength = 8;
@@ -91,3 +98,15 @@ export function shortenUrl(url: URL, maxChars = 20): string {
 
   return shortenedUrl;
 }
+
+/**
+ * Returns a rendered MarkdownView component.
+ *
+ * This should only be used for markdown that is guaranteed to be valid,
+ * and not contain any user-generated content.
+ */
+export function md(markdown: Common.UIString.LocalizedString): LitHtml.TemplateResult {
+  const tokens = Marked.Marked.lexer(markdown);
+  const data = {tokens};
+  return html`<devtools-markdown-view .data=${data}></devtools-markdown-view>`;
+}

package/front_end/panels/timeline/utils/IgnoreList.test.ts

@@ -4,8 +4,10 @@
 
 import * as Common from '../../../core/common/common.js';
 import type * as Platform from '../../../core/platform/platform.js';
+import * as SDK from '../../../core/sdk/sdk.js';
 import * as Bindings from '../../../models/bindings/bindings.js';
 import * as Trace from '../../../models/trace/trace.js';
+import * as Workspace from '../../../models/workspace/workspace.js';
 import {
   describeWithMockConnection,
 } from '../../../testing/MockConnection.js';
@@ -89,6 +91,8 @@ describeWithMockConnection('isIgnoreListedEntry', () => {
 
        ignoreKnownThirdPartySetting.set(true);
        assert.isTrue(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithMappings));
+       assert.strictEqual(
+           'Marked with ignoreList in source map', Utils.IgnoreList.getIgnoredReasonString(profileCallWithMappings));
 
        ignoreKnownThirdPartySetting.set(false);
        assert.isFalse(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithMappings));
@@ -130,6 +134,7 @@ describeWithMockConnection('isIgnoreListedEntry', () => {
 
     ignoreContentScriptSetting.set(true);
     assert.isTrue(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithContentScript));
+    assert.strictEqual('Content script', Utils.IgnoreList.getIgnoredReasonString(profileCallWithContentScript));
 
     ignoreContentScriptSetting.set(false);
     assert.isFalse(Utils.IgnoreList.isIgnoreListedEntry(profileCallWithContentScript));
@@ -137,4 +142,51 @@ describeWithMockConnection('isIgnoreListedEntry', () => {
     // restore to the original value.
     ignoreContentScriptSetting.set(ignoreContentScriptSettingValue);
   });
+
+  it('get the first matched rule for the ignored script', async () => {
+    const targetManager = SDK.TargetManager.TargetManager.instance();
+    const workspace = Workspace.Workspace.WorkspaceImpl.instance({forceNew: true});
+    const resourceMapping = new Bindings.ResourceMapping.ResourceMapping(targetManager, workspace);
+    const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance(
+        {forceNew: true, resourceMapping, targetManager});
+    Bindings.IgnoreListManager.IgnoreListManager.instance({
+      forceNew: true,
+      debuggerWorkspaceBinding,
+    });
+    ignoreRegex('youtube*');
+    const url = 'https://www.youtube.com/s/desktop/2ebf714b/jsbin/desktop_polymer.vflset/desktop_polymer.js' as
+        Platform.DevToolsPath.UrlString;
+    Bindings.IgnoreListManager.IgnoreListManager.instance().ignoreListURL(url);
+
+    const entry = makeProfileCall(
+        'function name', 10, 100, Trace.Types.Events.ProcessID(1), Trace.Types.Events.ThreadID(1), /* nodeId= */ 1,
+        url);
+    // There are two matched rules (in order)
+    // - youtube*
+    // - \\/desktop_polymer\\.js$ (generated by the URL)
+    // So the first matched one is `youtube*`
+    assert.strictEqual('youtube*', Utils.IgnoreList.getIgnoredReasonString(entry));
+
+    unignoreRegex('youtube*');
+    // Now There is only one matched rule.
+    assert.strictEqual('\\/desktop_polymer\\.js$', Utils.IgnoreList.getIgnoredReasonString(entry));
+  });
 });
+
+function ignoreRegex(regexValue: string): void {
+  const regexPatterns =
+      (Common.Settings.Settings.instance().moduleSetting('skip-stack-frames-pattern') as Common.Settings.RegExpSetting)
+          .getAsArray();
+  regexPatterns.push({pattern: regexValue, disabled: false});
+}
+
+function unignoreRegex(regexValue: string): void {
+  const regexPatterns =
+      (Common.Settings.Settings.instance().moduleSetting('skip-stack-frames-pattern') as Common.Settings.RegExpSetting)
+          .getAsArray();
+  const result =
+      regexPatterns.filter(regexPattern => regexPattern.pattern !== regexValue) as Common.Settings.RegExpSettingItem[];
+
+  (Common.Settings.Settings.instance().moduleSetting('skip-stack-frames-pattern') as Common.Settings.RegExpSetting)
+      .setAsArray(result);
+}

package/front_end/panels/timeline/utils/IgnoreList.ts

@@ -2,16 +2,37 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as i18n from '../../../core/i18n/i18n.js';
 import type * as Platform from '../../../core/platform/platform.js';
 import * as Bindings from '../../../models/bindings/bindings.js';
 import * as Trace from '../../../models/trace/trace.js';
 
 import {SourceMapsResolver} from './SourceMapsResolver.js';
 
-export function isIgnoreListedEntry(entry: Trace.Types.Events.Event): boolean {
-  if (!Trace.Types.Events.isProfileCall(entry)) {
-    return false;
-  }
+const UIStrings = {
+  /**
+   * @description Refers to when skipping content scripts is enabled and the current script is ignored because it's a content script.
+   */
+  skipContentScripts: 'Content script',
+  /**
+   * @description Refers to when skipping known third party scripts is enabled and the current script is ignored because it's a known third party script.
+   */
+  skip3rdPartyScripts: 'Marked with ignoreList in source map',
+  /**
+   * @description Refers to when skipping anonymous scripts is enabled and the current script is ignored because is an anonymous script.
+   */
+  skipAnonymousScripts: 'Anonymous script',
+  /**
+   * @description Refers to when the current script is ignored because of an unknown rule.
+   */
+  unknown: 'Unknown',
+};
+
+const str_ = i18n.i18n.registerUIStrings('panels/timeline/utils/IgnoreList.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+
+function getUrlAndIgnoreListOptions(entry: Trace.Types.Events.SyntheticProfileCall):
+    {url: Platform.DevToolsPath.UrlString, ignoreListOptions: Bindings.IgnoreListManager.IgnoreListGeneralRules} {
   const rawUrl = entry.callFrame.url as Platform.DevToolsPath.UrlString;
 
   const sourceMappedData = SourceMapsResolver.resolvedCodeLocationForEntry(entry);
@@ -21,11 +42,51 @@ export function isIgnoreListedEntry(entry: Trace.Types.Events.Event): boolean {
   const isKnownThirdParty = uiSourceCode?.isKnownThirdParty();
   const isContentScript = script?.isContentScript();
   const ignoreListOptions: Bindings.IgnoreListManager.IgnoreListGeneralRules = {isContentScript, isKnownThirdParty};
-  const urlToUse = resolvedUrl || rawUrl;
-  return isIgnoreListedURL(urlToUse, ignoreListOptions);
+  const url = resolvedUrl || rawUrl;
+  return {url, ignoreListOptions};
 }
 
-export function isIgnoreListedURL(
+export function isIgnoreListedEntry(entry: Trace.Types.Events.Event): boolean {
+  if (!Trace.Types.Events.isProfileCall(entry)) {
+    return false;
+  }
+  const {url, ignoreListOptions} = getUrlAndIgnoreListOptions(entry);
+  return isIgnoreListedURL(url, ignoreListOptions);
+}
+
+function isIgnoreListedURL(
     url: Platform.DevToolsPath.UrlString, options?: Bindings.IgnoreListManager.IgnoreListGeneralRules): boolean {
   return Bindings.IgnoreListManager.IgnoreListManager.instance().isUserIgnoreListedURL(url, options);
 }
+
+/**
+ * Returns the ignore reason for the given entry.
+ *
+ * This function should be called when `isIgnoreListedEntry(entry)` is true
+ */
+export function getIgnoredReasonString(entry: Trace.Types.Events.Event): string {
+  if (!Trace.Types.Events.isProfileCall(entry)) {
+    console.warn('Ignore list feature should only support ProfileCall.');
+    return '';
+  }
+  const {url, ignoreListOptions} = getUrlAndIgnoreListOptions(entry);
+
+  const ignoreListMgr = Bindings.IgnoreListManager.IgnoreListManager.instance();
+  if (ignoreListOptions.isContentScript && ignoreListMgr.skipContentScripts) {
+    return i18nString(UIStrings.skipContentScripts);
+  }
+  if (ignoreListOptions.isKnownThirdParty && ignoreListMgr.automaticallyIgnoreListKnownThirdPartyScripts) {
+    return i18nString(UIStrings.skip3rdPartyScripts);
+  }
+
+  if (!url) {
+    if (ignoreListMgr.skipAnonymousScripts) {
+      return i18nString(UIStrings.skipAnonymousScripts);
+    }
+    // This branch shouldn't be reached because when |skipAnonymousScripts| is false, this url is not ignored.
+    // So just return empty string to make the type check work.
+    return '';
+  }
+  const regex = ignoreListMgr.getFirstMatchedRegex(url);
+  return regex ? regex.source : i18nString(UIStrings.unknown);
+}

package/front_end/panels/timeline/utils/SourceMapsResolver.ts

@@ -68,6 +68,8 @@ export class SourceMapsResolver extends EventTarget {
    * (f.e. if an app is bundled). Thus, beyond a URL we can use code
    * location data like line and column numbers to obtain the specific
    * authored code according to the source mappings.
+   *
+   * TODO(andoli): This can return incorrect scripts if the target page has been reloaded since the trace.
    */
   static resolvedCodeLocationForEntry(entry: Trace.Types.Events.Event): ResolvedCodeLocationData|null {
     let callFrame = null;

package/front_end/panels/webauthn/webauthnPane.css

@@ -116,7 +116,7 @@
   align-items: center;
   margin: auto;
 
-  &:has(span[is="dt-checkbox"]) {
+  &:has(dt-checkbox) {
     padding-bottom: 4px;
   }
 }

package/front_end/panels/whats_new/ReleaseNote.test.ts

@@ -0,0 +1,90 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// 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 * as Root from '../../core/root/root.js';
+// eslint-disable-next-line rulesdir/es_modules_import
+import {
+  deinitializeGlobalVars,
+  initializeGlobalVars,
+} from '../../testing/EnvironmentHelpers.js';
+import * as UI from '../../ui/legacy/legacy.js';
+
+import type * as WhatsNewModule from './whats_new.js';
+
+describe('Release Note', () => {
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  let WhatsNew: typeof WhatsNewModule;
+
+  before(async () => {
+    await initializeGlobalVars();
+
+    WhatsNew = await import('./whats_new.js');
+    WhatsNew.ReleaseNoteText.setReleaseNoteForTest(
+        {
+          version: 99,
+          header: 'Highlights from Chrome 100 update',
+          markdownLinks: [],
+          link: 'https://developers.google.com/web/tools/chrome-devtools/' as Platform.DevToolsPath.UrlString,
+        },
+    );
+
+    // We need to add the What's New view so that an error is not thrown when requesting
+    // to show the release notes when needed.
+    UI.ViewManager.registerViewExtension({
+      location: UI.ViewManager.ViewLocationValues.DRAWER_VIEW,
+      id: 'release-note',
+      title: () => 'What\'s New' as Platform.UIString.LocalizedString,
+      commandPrompt: () => 'Show What\'s New' as Platform.UIString.LocalizedString,
+      persistence: UI.ViewManager.ViewPersistence.CLOSEABLE,
+      order: 1,
+      async loadView() {
+        return WhatsNew.ReleaseNoteView.ReleaseNoteViewWrapper.instance();
+      },
+    });
+
+    // This setting is used to determine if the What's New panel needs to be shown.
+    Common.Settings.registerSettingsForTest([{
+      category: Common.Settings.SettingCategory.APPEARANCE,
+      title: () => 'Show What\'s New after each update' as Platform.UIString.LocalizedString,
+      settingName: 'help.show-release-note',
+      settingType: Common.Settings.SettingType.BOOLEAN,
+      defaultValue: true,
+    }]);
+    Root.Runtime.experiments.clearForTest();
+    await initializeGlobalVars({reset: false});
+  });
+
+  after(async () => await deinitializeGlobalVars());
+
+  it('sets and gets the last seen release note version correctly', () => {
+    const releaseNoteVersionSetting = WhatsNew.WhatsNew.getReleaseNoteVersionSetting();
+    assert.strictEqual(releaseNoteVersionSetting.get(), 0);
+    releaseNoteVersionSetting.set(1);
+    assert.strictEqual(releaseNoteVersionSetting.get(), 1);
+  });
+
+  it('updates the last seen version when the release notes are shown', () => {
+    assert.strictEqual(WhatsNew.WhatsNew.getReleaseNoteVersionSetting().get(), 1);
+    WhatsNew.WhatsNew.showReleaseNoteIfNeeded();
+    assert.strictEqual(WhatsNew.WhatsNew.getReleaseNoteVersionSetting().get(), 99);
+  });
+
+  it('shows the release notes only when needed', () => {
+    const lastSeenVersionSetting = WhatsNew.WhatsNew.getReleaseNoteVersionSetting();
+
+    lastSeenVersionSetting.set(98);
+    assert.isTrue(WhatsNew.WhatsNew.showReleaseNoteIfNeeded());
+
+    lastSeenVersionSetting.set(99);
+    assert.isFalse(WhatsNew.WhatsNew.showReleaseNoteIfNeeded());
+
+    lastSeenVersionSetting.set(0);
+    assert.isFalse(WhatsNew.WhatsNew.showReleaseNoteIfNeeded());
+
+    lastSeenVersionSetting.set(100);
+    assert.isFalse(WhatsNew.WhatsNew.showReleaseNoteIfNeeded());
+  });
+});

package/front_end/panels/whats_new/ReleaseNoteText.ts

@@ -0,0 +1,52 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// NOTE: need to be careful about adding release notes early otherwise it'll
+// be shown in Canary (e.g. make sure the release notes are accurate).
+// https://github.com/ChromeDevTools/devtools-frontend/wiki/Release-Notes
+
+import * as MarkdownView from '../../ui/components/markdown_view/markdown_view.js';
+
+let registeredLinks = false;
+
+interface ReleaseNote {
+  version: number;
+  header: string;
+  markdownLinks: {key: string, link: string}[];
+  link: string;
+}
+
+export function setReleaseNoteForTest(testReleaseNote: ReleaseNote): void {
+  releaseNote = testReleaseNote;
+}
+
+export function getReleaseNote(): ReleaseNote {
+  if (!registeredLinks) {
+    for (const {key, link} of releaseNote.markdownLinks) {
+      MarkdownView.MarkdownLinksMap.markdownLinks.set(key, link);
+    }
+    registeredLinks = true;
+  }
+  return releaseNote;
+}
+
+let releaseNote: ReleaseNote = {
+  version: 73,
+  header: 'Highlights from the Chrome 132 update',
+  markdownLinks: [
+    {
+      key: 'ai-assistance',
+      link: 'https://developer.chrome.com/blog/new-in-devtools-132/#ai-assistance',
+    },
+    {
+      key: 'chat-history',
+      link: 'https://developer.chrome.com/blog/new-in-devtools-132/#chat-history',
+    },
+    {
+      key: 'interaction-phases',
+      link: 'https://developer.chrome.com/blog/new-in-devtools-132/#interaction-phases',
+    },
+  ],
+  link: 'https://developer.chrome.com/blog/new-in-devtools-132/',
+};