chrome-devtools-frontend 1.0.1632065 → 1.0.1635648

package/front_end/panels/recorder/models/RecordingPlayer.ts

@@ -43,6 +43,16 @@ function isPageTarget(target: Protocol.Target.TargetInfo): boolean {
       target.type === 'background_page' || target.type === 'webview');
 }
 
+function checkNavigationUrl(url: Platform.DevToolsPath.UrlString): void {
+  const allowedSchemes = ['http:', 'https:', 'data:'];
+  const isAllowed = allowedSchemes.some(scheme => Common.ParsedURL.schemeIs(url, scheme));
+  // We allow only about:blank but any other about: pages are intentionally
+  // blocked as they may navigate to other internal pages.
+  if (!isAllowed && url !== 'about:blank') {
+    throw new Error(`Navigation to ${url} is not allowed, due to blocked schema`);
+  }
+}
+
 export class RecordingPlayer extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   userFlow: UserFlow;
   speed: PlayRecordingSpeed;
@@ -273,9 +283,8 @@ export class RecordingPlayer extends Common.ObjectWrapper.ObjectWrapper<EventTyp
             (step.type === 'setViewport' || step.type === 'navigate')) {
           return;
         }
-        if (step.type === 'navigate' &&
-            Common.ParsedURL.schemeIs(step.url as Platform.DevToolsPath.UrlString, 'chrome:')) {
-          throw new Error('Not allowed to replay on chrome:// URLs');
+        if (step.type === 'navigate') {
+          checkNavigationUrl(step.url as Platform.DevToolsPath.UrlString);
         }
         // Focus the target in case it's not focused.
         await this.page.bringToFront();

package/front_end/panels/recorder/testing/RecorderHelpers.ts

@@ -23,7 +23,9 @@ export const installMocksForRecordingPlayer = (): void => {
       }),
       frames: () => [{
         client: {send: sinon.stub().resolves()},
+        goto: sinon.stub().resolves(),
       }],
+      mainFrame: () => mock.page.frames()[0],
       evaluate: () => '',
       url() {
         return '';

package/front_end/panels/sources/FilteredUISourceCodeListProvider.ts

@@ -126,8 +126,11 @@ export class FilteredUISourceCodeListProvider extends QuickOpen.FilteredListWidg
     }
 
     let multiplier = 10;
-    if (uiSourceCode.project().type() === Workspace.Workspace.projectTypes.FileSystem &&
-        !Persistence.Persistence.PersistenceImpl.instance().binding(uiSourceCode)) {
+    const isSnippet = Common.ParsedURL.schemeIs(uiSourceCode.url(), 'snippet:');
+    const isUnboundLocalFile = uiSourceCode.project().type() === Workspace.Workspace.projectTypes.FileSystem &&
+        !Persistence.Persistence.PersistenceImpl.instance().binding(uiSourceCode) && !isSnippet;
+
+    if (isUnboundLocalFile) {
       multiplier = 5;
     }
 

package/front_end/panels/timeline/timeline-meta.ts

@@ -329,26 +329,30 @@ Common.Settings.registerSettingExtension({
 Common.Settings.registerSettingExtension({
   category: Common.Settings.SettingCategory.PERFORMANCE,
   storageType: Common.Settings.SettingStorageType.SYNCED,
-  title: i18nLazyString(UIStrings.timelineShowAllEvents),
-  settingName: 'timeline-show-all-events',
+  title: i18nLazyString(UIStrings.timelineInvalidationTracking),
+  settingName: 'timeline-invalidation-tracking',
   settingType: Common.Settings.SettingType.BOOLEAN,
   defaultValue: false,
 });
 
+// IMPORTANT: if you are updating this, you should also update the setting in
+// js_timeline-meta.
 Common.Settings.registerSettingExtension({
   category: Common.Settings.SettingCategory.PERFORMANCE,
   storageType: Common.Settings.SettingStorageType.SYNCED,
-  title: i18nLazyString(UIStrings.timelineDebugMode),
-  settingName: 'timeline-debug-mode',
+  title: i18nLazyString(UIStrings.timelineShowAllEvents),
+  settingName: 'timeline-show-all-events',
   settingType: Common.Settings.SettingType.BOOLEAN,
   defaultValue: false,
 });
 
+// IMPORTANT: if you are updating this, you should also update the setting in
+// js_timeline-meta.
 Common.Settings.registerSettingExtension({
   category: Common.Settings.SettingCategory.PERFORMANCE,
   storageType: Common.Settings.SettingStorageType.SYNCED,
-  title: i18nLazyString(UIStrings.timelineInvalidationTracking),
-  settingName: 'timeline-invalidation-tracking',
+  title: i18nLazyString(UIStrings.timelineDebugMode),
+  settingName: 'timeline-debug-mode',
   settingType: Common.Settings.SettingType.BOOLEAN,
   defaultValue: false,
 });

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: e366695d7cbe930bcbfb3a3372dca968d453feeb
+Revision: 268971579b74f0369f828111e6c8f5bafbacd5ee
 Update Mechanism: Manual (https://crbug.com/428069060)
 License: BSD-3-Clause
 License File: LICENSE

package/front_end/ui/legacy/InspectorDrawerView.ts

@@ -130,7 +130,8 @@ export class InspectorDrawerView {
     this.#drawerMinimizedSetting =
         Common.Settings.Settings.instance().createLocalSetting('inspector.drawer-minimized', false);
     this.tabbedLocation = ViewManager.instance().createTabbedLocation(
-        options.revealDrawer, 'drawer-view', true, true, undefined, options.isVisible, () => new DrawerTabbedPane());
+        options.revealDrawer, 'drawer-view', true, true,
+        {isLocationVisible: options.isVisible, tabbedPaneFactory: () => new DrawerTabbedPane()});
     this.#moreTabsButton = this.tabbedLocation.enableMoreTabsButton();
     this.#moreTabsButton.setTitle(i18nString(UIStrings.moreTools));
     this.tabbedPane = this.tabbedLocation.tabbedPane() as DrawerTabbedPane;

package/front_end/ui/legacy/InspectorView.ts

@@ -228,7 +228,7 @@ export class InspectorView extends VBox implements ViewLocationResolver {
     this.tabbedLocation = ViewManager.instance().createTabbedLocation(
         Host.InspectorFrontendHost.InspectorFrontendHostInstance.bringToFront.bind(
             Host.InspectorFrontendHost.InspectorFrontendHostInstance),
-        'panel', true, true, Root.Runtime.Runtime.queryParam('panel'));
+        'panel', true, true, {defaultTab: Root.Runtime.Runtime.queryParam('panel')});
 
     this.tabbedPane = this.tabbedLocation.tabbedPane();
     this.tabbedPane.setMinimumSize(MIN_MAIN_PANEL_WIDTH, 0);

package/front_end/ui/legacy/PlusButton.ts

@@ -0,0 +1,269 @@
+// 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.
+
+// Side-effect import: registers the `<devtools-menu-button>` custom element
+// used by `PLUS_BUTTON_VIEW` below. The named imports are type-only.
+import './ContextMenu.js';
+
+import * as Host from '../../core/host/host.js';
+import * as i18n from '../../core/i18n/i18n.js';
+import type * as Platform from '../../core/platform/platform.js';
+import {Directives, html, render} from '../lit/lit.js';
+
+import type {ContextMenu, MenuButton} from './ContextMenu.js';
+import type {View} from './View.js';
+import {ViewLocationValues} from './ViewRegistration.js';
+
+const UIStrings = {
+  /**
+   * @description Default tooltip / accessible name of the "plus" button shown
+   * after the visible tabs in a tab strip. Clicking it opens a menu listing
+   * tools that are not currently shown as a visible tab.
+   */
+  moreTools: 'More tools',
+} as const;
+const str_ = i18n.i18n.registerUIStrings('ui/legacy/PlusButton.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+
+/** Declarative configuration for the plus button. */
+export interface PlusButtonOptions {
+  title?: Platform.UIString.LocalizedString;
+  jslogContext?: string;
+}
+
+/**
+ * Minimal `TabbedPane` surface read by the populator. Defined as an
+ * interface so test doubles can satisfy it without an `as unknown as
+ * TabbedPane` double-cast.
+ */
+export interface PlusButtonTabbedPane {
+  element: HTMLElement;
+  hiddenTabs(): ReadonlyArray<{id: string, title: string, jslogContext?: string}>;
+  hasTab(id: string): boolean;
+  firstHiddenTabIndex(): number;
+  moveTab(tabId: string, newIndex: number): void;
+  selectTab(tabId: string, userGesture?: boolean, forceFocus?: boolean): boolean;
+}
+
+export interface PlusButtonMenuContext {
+  tabbedPane: PlusButtonTabbedPane;
+  location: string;
+  /**
+   * Production callers pass `() => location.views.values()` (NOT
+   * `manager.viewsForLocation(location)`) so views moved in via
+   * `appendView` are reflected immediately. Called fresh on every
+   * menu open.
+   */
+  views: () => Iterable<View>;
+  manager: {
+    viewsForLocation(location: string): View[],
+    moveView(viewId: string, locationName: string): void,
+  };
+  showView: (view: View) => void;
+}
+
+interface AddToolEntry {
+  title: string;
+  jslogContext: string;
+  isPreviewFeature: boolean;
+  action: () => void;
+}
+
+export interface OverflowTabModel {
+  id: string;
+  title: string;
+  jslogContext?: string;
+}
+
+export interface PlusButtonMenuModel {
+  overflowTabs: readonly OverflowTabModel[];
+  addToolEntries: readonly AddToolEntry[];
+}
+
+/**
+ * Presenter (MVP) for the plus-button menu. {@link buildModel} is called
+ * fresh on every menu open so newly-registered views — or views that
+ * just left the visible tab strip — are reflected immediately.
+ */
+export class PlusButtonPresenter {
+  readonly #context: PlusButtonMenuContext;
+
+  constructor(context: PlusButtonMenuContext) {
+    this.#context = context;
+  }
+
+  buildModel(): PlusButtonMenuModel {
+    const {tabbedPane, location, views, manager} = this.#context;
+    const overflowTabs: readonly OverflowTabModel[] =
+        tabbedPane.hiddenTabs().map(tab => ({id: tab.id, title: tab.title, jslogContext: tab.jslogContext}));
+
+    const addToolEntries: AddToolEntry[] = [];
+    // Seed dedup sets from the overflowed tabs so an addable entry
+    // (e.g. a closeable view in the other main location) sharing an id
+    // or title with an overflowed tab is not listed twice.
+    const seenIds = new Set<string>(overflowTabs.map(tab => tab.id));
+    const seenTitles = new Set<string>(overflowTabs.map(tab => tab.title));
+
+    for (const view of views()) {
+      // Skip views that already have a tab. Hidden tabs are already listed
+      // in the overflow section above, and visible tabs are accessible
+      // directly in the tab strip.
+      if (tabbedPane.hasTab(view.viewId())) {
+        continue;
+      }
+      // Transient views are not user-addable.
+      if (view.isTransient()) {
+        continue;
+      }
+      if (seenIds.has(view.viewId()) || seenTitles.has(view.title())) {
+        continue;
+      }
+      seenIds.add(view.viewId());
+      seenTitles.add(view.title());
+      const isIssuesPane = view.viewId() === 'issues-pane';
+      addToolEntries.push({
+        title: view.title(),
+        jslogContext: view.viewId(),
+        isPreviewFeature: view.isPreviewFeature(),
+        action: () => {
+          if (isIssuesPane) {
+            // Distinct from `HAMBURGER_MENU` so plus-button opens are
+            // not conflated with three-dot-menu opens in the dashboard.
+            Host.userMetrics.issuesPanelOpenedFrom(Host.UserMetrics.IssueOpener.MORE_TOOLS_MENU);
+          }
+          this.#context.showView(view);
+        },
+      });
+    }
+
+    // Offer cross-location moves between the two main surfaces: the
+    // panel plus button lists drawer views and vice versa.
+    const otherLocation = location === ViewLocationValues.PANEL ? ViewLocationValues.DRAWER_VIEW :
+        location === ViewLocationValues.DRAWER_VIEW             ? ViewLocationValues.PANEL :
+                                                                  null;
+    if (otherLocation) {
+      for (const view of manager.viewsForLocation(otherLocation)) {
+        // Non-closeable views (e.g. Console) cannot be moved between
+        // locations, so they're excluded here. They still appear in the
+        // overflow section when their own location's tab strip overflows.
+        if (view.isTransient() || !view.isCloseable() || seenIds.has(view.viewId()) || seenTitles.has(view.title())) {
+          continue;
+        }
+        seenIds.add(view.viewId());
+        seenTitles.add(view.title());
+        const viewId = view.viewId();
+        addToolEntries.push({
+          title: view.title(),
+          jslogContext: viewId,
+          isPreviewFeature: view.isPreviewFeature(),
+          action: () => manager.moveView(viewId, location),
+        });
+      }
+    }
+
+    addToolEntries.sort((a, b) => a.title.localeCompare(b.title));
+
+    return {overflowTabs, addToolEntries};
+  }
+}
+
+/**
+ * Renders the plus-button menu by asking {@link PlusButtonPresenter}
+ * for a model and pushing it into `contextMenu`. Overflowed tabs (in
+ * tab order) come first, followed by deduplicated "add tool" entries
+ * sorted alphabetically.
+ */
+export function populatePlusButtonMenu(contextMenu: ContextMenu, context: PlusButtonMenuContext): void {
+  const model = new PlusButtonPresenter(context).buildModel();
+  const hasOverflow = model.overflowTabs.length > 0;
+
+  // When there are no overflowed tabs, surface the add-tool entries in
+  // the default section so they are not visually demoted to a footer.
+  for (const tab of model.overflowTabs) {
+    contextMenu.defaultSection().appendItem(
+        tab.title, () => revealOverflowTab(context.tabbedPane, tab.id), {jslogContext: tab.jslogContext ?? tab.id});
+  }
+  const addToolSection = hasOverflow ? contextMenu.footerSection() : contextMenu.defaultSection();
+  for (const entry of model.addToolEntries) {
+    addToolSection.appendItem(
+        entry.title, entry.action, {isPreviewFeature: entry.isPreviewFeature, jslogContext: entry.jslogContext});
+  }
+}
+
+/**
+ * Reveals an overflowed tab and persists its new position via
+ * `moveTab(firstHidden - 1)` so the tab stays in the visible region
+ * after a reload — independent of any runtime `currentTab` /
+ * `lastSelectedOverflowTab` priority logic. The previously-last-visible
+ * tab is pushed to the start of the overflow region, matching the
+ * intuition that the newly opened tab replaces the one the user
+ * implicitly stopped using.
+ *
+ * Exported only for testing.
+ */
+export function revealOverflowTab(tabbedPane: PlusButtonTabbedPane, tabId: string): void {
+  const firstHidden = tabbedPane.firstHiddenTabIndex();
+  if (firstHidden > 0) {
+    // `firstHidden - 1` is the index of the last currently-visible tab.
+    tabbedPane.moveTab(tabId, firstHidden - 1);
+  }
+  tabbedPane.selectTab(tabId, /* userGesture */ true, /* forceFocus */ true);
+}
+
+interface PlusButtonViewInput {
+  title: string;
+  jslogContext: string;
+  populateMenuCall: (menu: ContextMenu) => void;
+}
+
+/**
+ * Standard `(input, output, target)` view function so `Lit.render` is
+ * called inside a view (per `@devtools/no-lit-render-outside-of-view`).
+ * `output.button` is captured via `ref` to avoid a `querySelector`
+ * round-trip in {@link installPlusButton}.
+ *
+ * `slot` is set declaratively in the template so the attribute is
+ * present on the very first connection — the first `slotchange` then
+ * sees the button as the trailing-slot target and no extra layout pass
+ * is needed.
+ */
+export const PLUS_BUTTON_VIEW =
+    (input: PlusButtonViewInput, output: {button?: MenuButton}, target: HTMLElement): void => {
+      render(
+          html`
+        <devtools-menu-button
+            ${Directives.ref(el => {
+            output.button = el as MenuButton | undefined;
+          })}
+            slot="trailing-button"
+            .iconName=${'plus'}
+            .title=${input.title}
+            .jslogContext=${input.jslogContext}
+            .populateMenuCall=${input.populateMenuCall}>
+        </devtools-menu-button>`,
+          target);
+    };
+
+/**
+ * Renders a `<devtools-menu-button>` configured as the plus button into
+ * `tabbedPane`'s `trailing-button` slot and returns the slotted host.
+ * The returned `MenuButton` is used by the next CL to toggle visibility
+ * (e.g. when the drawer is minimized).
+ */
+export function installPlusButton(context: PlusButtonMenuContext, options: PlusButtonOptions = {}): MenuButton {
+  const output: {button?: MenuButton} = {};
+  // `render` is synchronous and the `ref` directive fires during render,
+  // so `output.button` is assigned by the time the view returns.
+  PLUS_BUTTON_VIEW(
+      {
+        title: options.title ?? i18nString(UIStrings.moreTools),
+        jslogContext: options.jslogContext ?? '',
+        populateMenuCall: menu => populatePlusButtonMenu(menu, context),
+      },
+      output, context.tabbedPane.element);
+  if (!output.button) {
+    throw new Error('installPlusButton: ref directive did not capture <devtools-menu-button>');
+  }
+  return output.button;
+}

package/front_end/ui/legacy/ViewManager.ts

@@ -9,7 +9,7 @@ import * as Common from '../../core/common/common.js';
 import * as Host from '../../core/host/host.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import * as Platform from '../../core/platform/platform.js';
-import type * as Root from '../../core/root/root.js';
+import * as Root from '../../core/root/root.js';
 import type * as Foundation from '../../foundation/foundation.js';
 import {createIcon, type Icon} from '../kit/kit.js';
 import {render, type TemplateResult} from '../lit/lit.js';
@@ -17,6 +17,7 @@ import * as VisualLogging from '../visual_logging/visual_logging.js';
 
 import * as ARIAUtils from './ARIAUtils.js';
 import type {ContextMenu} from './ContextMenu.js';
+import * as PlusButton from './PlusButton.js';
 import {type EventData, Events as TabbedPaneEvents, TabbedPane} from './TabbedPane.js';
 import {type ItemsProvider, type ToolbarItem, ToolbarMenuButton} from './Toolbar.js';
 import {createTextChild} from './UIUtils.js';
@@ -397,11 +398,8 @@ export class ViewManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
 
   createTabbedLocation(
       revealCallback: (() => void), location: string, restoreSelection?: boolean, allowReorder?: boolean,
-      defaultTab?: string|null, isLocationVisible?: (() => boolean),
-      tabbedPaneFactory?: TabbedPaneFactory): TabbedViewLocation {
-    return new TabbedLocation(
-        this, revealCallback, location, restoreSelection, allowReorder, defaultTab, isLocationVisible,
-        tabbedPaneFactory);
+      options?: TabbedLocationOptions): TabbedViewLocation {
+    return new TabbedLocation(this, revealCallback, location, restoreSelection, allowReorder, options);
   }
 
   createStackLocation(revealCallback?: (() => void), location?: string, jslogContext?: string): ViewLocation {
@@ -648,6 +646,17 @@ type CloseableTabSetting = Record<string, boolean>;
 
 type TabOrderSetting = Record<string, number>;
 
+export interface TabbedLocationOptions {
+  defaultTab?: string|null;
+  isLocationVisible?: () => boolean;
+  tabbedPaneFactory?: TabbedPaneFactory;
+  /**
+   * Installed into the `TabbedPane`'s `trailing-button` slot before any
+   * tabs are appended, so the very first layout pass reserves width for it.
+   */
+  plusButton?: PlusButton.PlusButtonOptions;
+}
+
 class TabbedLocation extends Location implements TabbedViewLocation {
   #tabbedPane: TabbedPane;
   private readonly location: string;
@@ -661,9 +670,8 @@ class TabbedLocation extends Location implements TabbedViewLocation {
 
   constructor(
       manager: ViewManager, revealCallback: (() => void), location: string, restoreSelection?: boolean,
-      allowReorder?: boolean, defaultTab?: string|null, isLocationVisible?: (() => boolean),
-      tabbedPaneFactory?: TabbedPaneFactory) {
-    const tabbedPane = tabbedPaneFactory ? tabbedPaneFactory() : new TabbedPane();
+      allowReorder?: boolean, options?: TabbedLocationOptions) {
+    const tabbedPane = options?.tabbedPaneFactory ? options.tabbedPaneFactory() : new TabbedPane();
     if (allowReorder) {
       tabbedPane.setAllowTabReorder(true);
     }
@@ -687,8 +695,27 @@ class TabbedLocation extends Location implements TabbedViewLocation {
     if (restoreSelection) {
       this.lastSelectedTabSetting = Common.Settings.Settings.instance().createSetting(location + '-selected-tab', '');
     }
-    this.defaultTab = defaultTab;
-    this.isLocationVisible = isLocationVisible;
+    this.defaultTab = options?.defaultTab;
+    this.isLocationVisible = options?.isLocationVisible;
+
+    // Install before `appendApplicableItems` so the very first layout pass
+    // reserves width for the button and we avoid a reflow that snaps the
+    // last tab into the overflow menu.
+    if (options?.plusButton && Root.Runtime.hostConfig.devToolsPlusButton?.enabled) {
+      PlusButton.installPlusButton(
+          {
+            tabbedPane: this.#tabbedPane,
+            location: this.location,
+            // Use the local `views` map (not `manager.viewsForLocation`) so
+            // cross-location moves added via `appendView` are reflected.
+            views: () => this.views.values(),
+            manager: this.manager,
+            showView: view => {
+              this.showView(view, undefined, /* userGesture */ true).catch(err => console.error(err));
+            },
+          },
+          options.plusButton);
+    }
 
     if (location) {
       this.appendApplicableItems(location);

package/front_end/ui/legacy/components/source_frame/ImageView.ts

@@ -37,6 +37,7 @@ import * as i18n from '../../../../core/i18n/i18n.js';
 import * as Platform from '../../../../core/platform/platform.js';
 import * as TextUtils from '../../../../models/text_utils/text_utils.js';
 import * as Workspace from '../../../../models/workspace/workspace.js';
+import {createIcon} from '../../../kit/kit.js';
 import * as VisualLogging from '../../../visual_logging/visual_logging.js';
 import * as UI from '../../legacy.js';
 
@@ -82,6 +83,10 @@ const UIStrings = {
    * @description The default file name when downloading a file
    */
   download: 'download',
+  /**
+   * @description Text indicating an image is too large to display and offering to open it in a new tab
+   */
+  thisImageIsTooBig: 'This image is too big to display in DevTools. Click here to open it in a new tab.',
 } as const;
 const str_ = i18n.i18n.registerUIStrings('ui/legacy/components/source_frame/ImageView.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
@@ -97,6 +102,7 @@ export class ImageView extends UI.View.SimpleView {
   private readonly mimeTypeLabel: UI.Toolbar.ToolbarText;
   private readonly container: HTMLElement;
   private imagePreviewElement: HTMLImageElement;
+  private imageUnavailableElement: HTMLElement;
   private cachedContent?: TextUtils.ContentData.ContentData;
   constructor(mimeType: string, contentProvider: TextUtils.ContentProvider.ContentProvider) {
     super({
@@ -125,6 +131,14 @@ export class ImageView extends UI.View.SimpleView {
     this.container = this.element.createChild('div', 'image');
     this.imagePreviewElement = this.container.createChild('img', 'resource-image-view');
     this.imagePreviewElement.addEventListener('contextmenu', this.contextMenu.bind(this), true);
+
+    const link = document.createElement('devtools-link');
+    link.setAttribute('href', this.url);
+    link.classList.add('resource-image-unavailable', 'hidden');
+    link.appendChild(createIcon('open-externally'));
+    link.appendChild(document.createTextNode(i18nString(UIStrings.thisImageIsTooBig)));
+    this.container.appendChild(link);
+    this.imageUnavailableElement = link;
   }
 
   override async toolbarItems(): Promise<UI.Toolbar.ToolbarItem[]> {
@@ -165,8 +179,10 @@ export class ImageView extends UI.View.SimpleView {
     this.cachedContent = content;
     const imageSrc = content.asImagePreviewUrl();
     if (imageSrc === null) {
+      this.imageUnavailableElement.classList.remove('hidden');
       return;
     }
+    this.imageUnavailableElement.classList.add('hidden');
     const loadPromise = new Promise(x => {
       this.imagePreviewElement.onload = x;
     });

package/front_end/ui/legacy/components/source_frame/imageView.css

@@ -21,3 +21,16 @@
   user-select: text;
   -webkit-user-drag: auto;
 }
+
+.resource-image-unavailable {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: var(--sys-size-4);
+}
+
+.resource-image-unavailable devtools-icon {
+  color: var(--sys-color-primary);
+  width: var(--sys-size-7);
+  height: var(--sys-size-7);
+}

package/front_end/ui/legacy/components/utils/Linkifier.ts

@@ -1112,7 +1112,7 @@ export class ContentProviderContextMenuProvider implements
     if (!Common.ParsedURL.schemeIs(contentUrl, 'file:')) {
       contextMenu.revealSection().appendItem(
           UI.UIUtils.openLinkExternallyLabel(),
-          () => Host.InspectorFrontendHost.InspectorFrontendHostInstance.openInNewTab(
+          () => UIHelpers.openInNewTab(
               contentUrl.endsWith(':formatted') ?
                   Common.ParsedURL.ParsedURL.slice(contentUrl, 0, contentUrl.lastIndexOf(':')) :
                   contentUrl),

package/front_end/ui/legacy/legacy.ts

@@ -29,6 +29,7 @@ import * as ListControl from './ListControl.js';
 import * as ListModel from './ListModel.js';
 import * as ListWidget from './ListWidget.js';
 import * as Panel from './Panel.js';
+import * as PlusButton from './PlusButton.js';
 import * as PopoverHelper from './PopoverHelper.js';
 import * as ProgressIndicator from './ProgressIndicator.js';
 import * as RemoteDebuggingTerminatedScreen from './RemoteDebuggingTerminatedScreen.js';
@@ -82,6 +83,7 @@ export {
   ListModel,
   ListWidget,
   Panel,
+  PlusButton,
   PopoverHelper,
   ProgressIndicator,
   RemoteDebuggingTerminatedScreen,

package/front_end/ui/visual_logging/KnownContextValues.ts

@@ -1074,21 +1074,37 @@ export const knownContextValues = new Set([
   'copy-xpath',
   'core-web-vitals',
   'corner',
+  'corner-block-end',
   'corner-block-end-shape',
+  'corner-block-start',
   'corner-block-start-shape',
+  'corner-bottom',
+  'corner-bottom-left',
   'corner-bottom-left-shape',
+  'corner-bottom-right',
   'corner-bottom-right-shape',
   'corner-bottom-shape',
+  'corner-end-end',
   'corner-end-end-shape',
+  'corner-end-start',
   'corner-end-start-shape',
+  'corner-inline-end',
   'corner-inline-end-shape',
+  'corner-inline-start',
   'corner-inline-start-shape',
+  'corner-left',
   'corner-left-shape',
+  'corner-right',
   'corner-right-shape',
   'corner-shape',
+  'corner-start-end',
   'corner-start-end-shape',
+  'corner-start-start',
   'corner-start-start-shape',
+  'corner-top',
+  'corner-top-left',
   'corner-top-left-shape',
+  'corner-top-right',
   'corner-top-right-shape',
   'corner-top-shape',
   'corners',
@@ -2316,6 +2332,7 @@ export const knownContextValues = new Set([
   'lighthouse',
   'lighthouse-report-widget',
   'lighthouse-show-settings-toolbar',
+  'lighthouse-snapshot-report-widget',
   'lighthouse.audit-summary.average',
   'lighthouse.audit-summary.fail',
   'lighthouse.audit-summary.informative',
@@ -3053,6 +3070,7 @@ export const knownContextValues = new Set([
   'play-recording',
   'player',
   'playing',
+  'plus-button',
   'pointer',
   'pointer-32-bit',
   'pointer-64-bit',
@@ -3441,6 +3459,7 @@ export const knownContextValues = new Set([
   'script-text-node',
   'scripting',
   'scroll',
+  'scroll-axis-lock',
   'scroll-behavior',
   'scroll-initial-target',
   'scroll-into-view',

package/mcp/mcp.ts

@@ -38,7 +38,7 @@ export {
 } from '../front_end/models/ai_assistance/data_formatters/PerformanceTraceFormatter.js';
 export {AgentFocus} from '../front_end/models/ai_assistance/performance/AIContext.js';
 export {DebuggerWorkspaceBinding} from '../front_end/models/bindings/DebuggerWorkspaceBinding.js';
-export {CrUXManager} from '../front_end/models/crux-manager/CrUXManager.js';
+export * as CrUXManager from '../front_end/models/crux-manager/CrUXManager.js';
 export * as Formatter from '../front_end/models/formatter/formatter.js';
 export * as HeapSnapshotModel from '../front_end/models/heap_snapshot/heap_snapshot.js';
 export {Issue} from '../front_end/models/issues_manager/Issue.js';

package/package.json

@@ -105,5 +105,5 @@
     "ip-address": "10.1.0",
     "basic-ftp": "5.2.2"
   },
-  "version": "1.0.1632065"
+  "version": "1.0.1635648"
 }