chrome-devtools-frontend 1.0.1608453 → 1.0.1609381

package/front_end/panels/profiler/HeapSnapshotDataGrids.ts

@@ -5,7 +5,7 @@
 import * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import type * as SDK from '../../core/sdk/sdk.js';
-import * as HeapSnapshotModel from '../../models/heap_snapshot_model/heap_snapshot_model.js';
+import * as HeapSnapshotModel from '../../models/heap_snapshot/heap_snapshot.js';
 import * as DataGrid from '../../ui/legacy/components/data_grid/data_grid.js';
 import * as Components from '../../ui/legacy/components/utils/utils.js';
 import * as UI from '../../ui/legacy/legacy.js';

package/front_end/panels/profiler/HeapSnapshotGridNodes.ts

@@ -10,7 +10,7 @@ import * as i18n from '../../core/i18n/i18n.js';
 import * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
-import * as HeapSnapshotModel from '../../models/heap_snapshot_model/heap_snapshot_model.js';
+import * as HeapSnapshotModel from '../../models/heap_snapshot/heap_snapshot.js';
 import {createIcon} from '../../ui/kit/kit.js';
 import * as DataGrid from '../../ui/legacy/components/data_grid/data_grid.js';
 import * as UI from '../../ui/legacy/legacy.js';

package/front_end/panels/profiler/HeapSnapshotView.ts

@@ -11,7 +11,7 @@ import * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
 import * as Bindings from '../../models/bindings/bindings.js';
-import * as HeapSnapshotModel from '../../models/heap_snapshot_model/heap_snapshot_model.js';
+import * as HeapSnapshotModel from '../../models/heap_snapshot/heap_snapshot.js';
 import * as DataGrid from '../../ui/legacy/components/data_grid/data_grid.js';
 import * as ObjectUI from '../../ui/legacy/components/object_ui/object_ui.js';
 import * as PerfUI from '../../ui/legacy/components/perf_ui/perf_ui.js';

package/front_end/panels/timeline/TimelinePanel.ts

@@ -2179,7 +2179,7 @@ export class TimelinePanel extends Common.ObjectWrapper.eventMixin<EventTypes, t
     PerfUI.LineLevelProfile.Performance.instance().initialize(cpuProfiles, primaryPageTarget);
 
     // Initialize EntityMapper
-    this.#entityMapper = new Trace.EntityMapper.EntityMapper(parsedTrace);
+    this.#entityMapper = Trace.EntityMapper.EntityMapper.getOrCreate(parsedTrace);
 
     // Set up SourceMapsResolver to ensure we resolve any function names in
     // profile calls.
@@ -2189,9 +2189,6 @@ export class TimelinePanel extends Common.ObjectWrapper.eventMixin<EventTypes, t
         SourceMapsResolver.SourceMappingsUpdated.eventName, this.#onSourceMapsNodeNamesResolvedBound);
     void this.#sourceMapsResolver.install();
 
-    // Initialize EntityMapper
-    this.#entityMapper = new Trace.EntityMapper.EntityMapper(parsedTrace);
-
     this.statusDialog?.updateProgressBar(i18nString(UIStrings.processed), 80);
     this.updateMiniMap();
     this.statusDialog?.updateProgressBar(i18nString(UIStrings.processed), 90);
@@ -3060,7 +3057,6 @@ export class TimelinePanel extends Common.ObjectWrapper.eventMixin<EventTypes, t
 
     return trace;
   }
-
 }
 
 export const enum State {
@@ -3143,7 +3139,7 @@ export class BottomUpProfileRevealer implements Common.Revealer.Revealer<Utils.H
     TraceBounds.TraceBounds.BoundsManager.instance().setTimelineVisibleWindow(
         revealable.bounds, {ignoreMiniMapBounds: true, shouldAnimate: true});
     panel.select(null);
-    panel.getFlameChart().selectDetailsViewTab(Tab.BottomUp, null);
+    panel.getFlameChart().selectDetailsViewTab(Tab.BottomUp, revealable.node ?? null);
   }
 }
 

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

@@ -138,6 +138,6 @@ export class RevealableTimeRange {
 }
 
 export class RevealableBottomUpProfile {
-  constructor(public bounds: Trace.Types.Timing.TraceWindowMicro) {
+  constructor(public bounds: Trace.Types.Timing.TraceWindowMicro, public node?: Trace.Extras.TraceTree.Node) {
   }
 }

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

package/front_end/ui/legacy/InspectorDrawerView.ts

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type * as Common from '../../core/common/common.js';
+import * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import * as VisualLogging from '../visual_logging/visual_logging.js';
 
@@ -14,11 +14,29 @@ import {ToolbarButton, type ToolbarMenuButton} from './Toolbar.js';
 import type {TabbedViewLocation} from './View.js';
 import {ViewManager} from './ViewManager.js';
 
+const VERTICAL_MINIMIZED_DRAWER_SIZE = 27;
+
 class DrawerTabbedPane extends TabbedPane {
   constructor() {
     super();
     this.registerRequiredCSS(drawerTabbedPaneStyles);
   }
+
+  setVerticalMinimized(isMinimized: boolean): void {
+    this.element.classList.toggle('drawer-minimized-vertical', isMinimized);
+    this.contentElement.classList.toggle('collapsed-vertical-drawer-container', isMinimized);
+    this.tabbedPaneContentElement().classList.toggle('hide-element', isMinimized);
+    this.headerElement().classList.toggle('collapsed-vertical-drawer-header', isMinimized);
+    this.headerContentsElement.classList.toggle('hide-element', isMinimized);
+    this.leftToolbar().classList.toggle('hide-element', isMinimized);
+    this.rightToolbar().classList.toggle('collapsed-vertical-drawer-right-toolbar', isMinimized);
+    this.rightToolbar().classList.toggle('collapsed-vertical-drawer-toolbar-content', isMinimized);
+  }
+
+  restoreAfterVerticalMinimized(): void {
+    this.clearMeasuredWidths();
+    this.headerResized();
+  }
 }
 
 const UIStrings = {
@@ -26,6 +44,14 @@ const UIStrings = {
    * @description Title of more tabs button in the drawer view.
    */
   moreTools: 'More Tools',
+  /**
+   * @description Text that appears when hover over the minimize button on the drawer view.
+   */
+  minimizeDrawer: 'Minimize drawer',
+  /**
+   * @description Text that appears when hover over the expand button on the drawer view.
+   */
+  expandDrawer: 'Expand drawer',
   /**
    * @description Text that appears when hover over the close button on the drawer view.
    */
@@ -44,9 +70,13 @@ interface InspectorDrawerViewOptions {
   revealDrawer: () => void;
   isVisible: () => boolean;
   drawerLabel: string;
+  onToggleMinimized: () => void;
   onHide: () => void;
   onToggleOrientation: () => void;
+  onExpandFromMinimized: () => void;
+  onMinimizeFromTabInteraction: () => void;
   onTabSelected: (tabId: string) => void;
+  isConsoleOpenInMainAndDrawer: (tabId: string) => boolean;
   tabDelegate: TabbedPaneTabDelegate;
   enableOrientationToggle: boolean;
   isVertical: boolean;
@@ -59,10 +89,17 @@ interface InspectorDrawerViewOptions {
   setInspectorMinimumSize: (width: number, height: number) => void;
 }
 
+interface InspectorDrawerPresentation {
+  isVertical: boolean;
+  isMinimized: boolean;
+  verticalExpandedMinimumWidth: number;
+}
+
 export class InspectorDrawerView {
   readonly tabbedLocation: TabbedViewLocation;
   readonly tabbedPane: DrawerTabbedPane;
   readonly #splitWidget: SplitWidget;
+  readonly #drawerMinimizedSetting: Common.Settings.Setting<boolean>;
   readonly #verticalExpandedMinimumWidth: number;
   readonly #minimumSizes: {
     inspectorWidthWhenVertical: number,
@@ -70,17 +107,28 @@ export class InspectorDrawerView {
     inspectorHeight: number,
   };
   readonly #setInspectorMinimumSize: (width: number, height: number) => void;
+  #drawerSizeBeforeMinimize = 0;
+  #wasVerticalAndMinimized = false;
   readonly #toggleOrientationButton: ToolbarButton;
+  readonly #minimizeExpandButton: ToolbarButton;
   readonly #closeDrawerButton: ToolbarButton;
   readonly #moreTabsButton: ToolbarMenuButton|null;
+  readonly #onExpandFromMinimized: () => void;
+  readonly #onMinimizeFromTabInteraction: () => void;
   readonly #onTabSelected: (tabId: string) => void;
+  readonly #isConsoleOpenInMainAndDrawer: (tabId: string) => boolean;
 
   constructor(options: InspectorDrawerViewOptions) {
     this.#splitWidget = options.splitWidget;
     this.#verticalExpandedMinimumWidth = options.verticalExpandedMinimumWidth;
     this.#minimumSizes = options.minimumSizes;
     this.#setInspectorMinimumSize = options.setInspectorMinimumSize;
+    this.#onExpandFromMinimized = options.onExpandFromMinimized;
+    this.#onMinimizeFromTabInteraction = options.onMinimizeFromTabInteraction;
     this.#onTabSelected = options.onTabSelected;
+    this.#isConsoleOpenInMainAndDrawer = options.isConsoleOpenInMainAndDrawer;
+    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());
     this.#moreTabsButton = this.tabbedLocation.enableMoreTabsButton();
@@ -89,8 +137,15 @@ export class InspectorDrawerView {
     this.tabbedPane.element.classList.add('drawer-tabbed-pane');
     this.tabbedPane.element.setAttribute('jslog', `${VisualLogging.drawer()}`);
 
+    this.#minimizeExpandButton = new ToolbarButton(
+        i18nString(UIStrings.minimizeDrawer), options.isVertical ? 'right-panel-close' : 'bottom-panel-close');
+    this.#minimizeExpandButton.element.setAttribute(
+        'jslog', `${VisualLogging.toggle('minimize-drawer').track({click: true})}`);
+    this.#minimizeExpandButton.addEventListener(ToolbarButton.Events.CLICK, options.onToggleMinimized);
+
     this.#closeDrawerButton = new ToolbarButton(i18nString(UIStrings.closeDrawer), 'cross');
-    this.#closeDrawerButton.element.setAttribute('jslog', `${VisualLogging.close().track({click: true})}`);
+    this.#closeDrawerButton.element.setAttribute(
+        'jslog', `${VisualLogging.close('close-drawer').track({click: true})}`);
     this.#closeDrawerButton.addEventListener(ToolbarButton.Events.CLICK, options.onHide);
 
     this.#toggleOrientationButton = new ToolbarButton(
@@ -102,7 +157,9 @@ export class InspectorDrawerView {
     if (options.enableOrientationToggle) {
       this.tabbedPane.rightToolbar().appendToolbarItem(this.#toggleOrientationButton);
     }
+    this.tabbedPane.rightToolbar().appendToolbarItem(this.#minimizeExpandButton);
     this.tabbedPane.rightToolbar().appendToolbarItem(this.#closeDrawerButton);
+    this.tabbedPane.addEventListener(TabbedPaneEvents.TabInvoked, this.#drawerTabInvoked, this);
     this.tabbedPane.addEventListener(TabbedPaneEvents.TabSelected, this.#drawerTabSelected, this);
     this.tabbedPane.setTabDelegate(options.tabDelegate);
     const selectedDrawerTab = this.tabbedPane.selectedTabId;
@@ -120,7 +177,17 @@ export class InspectorDrawerView {
                                                    drag: true,
                                                    keydown: 'ArrowUp|ArrowLeft|ArrowDown|ArrowRight|Enter|Space',
                                                  })}`);
-    this.#updatePresentation();
+    this.#updatePresentation(false);
+  }
+
+  restoreMinimizedStateFromSettings(): void {
+    if (!this.#drawerMinimizedSetting.get()) {
+      return;
+    }
+
+    // The drawer starts hidden; show it first, then minimize.
+    this.#splitWidget.showBoth();
+    this.setMinimized(true);
   }
 
   setVertical(shouldBeVertical: boolean): void {
@@ -129,12 +196,14 @@ export class InspectorDrawerView {
     }
 
     const previousShowMode = this.#splitWidget.showMode();
+    const wasDrawerMinimized = this.isMinimized();
+
     this.#splitWidget.setVertical(shouldBeVertical);
-    this.#updatePresentation();
-    this.applyState(previousShowMode);
+    this.#updatePresentation(wasDrawerMinimized);
+    this.applyState(previousShowMode, wasDrawerMinimized);
   }
 
-  applyState(showMode: ShowMode): void {
+  applyState(showMode: ShowMode, minimized: boolean): void {
     if (this.#splitWidget.showMode() !== showMode) {
       switch (showMode) {
         case ShowMode.BOTH:
@@ -148,22 +217,63 @@ export class InspectorDrawerView {
           break;
       }
     }
-    this.#updatePresentation();
+
+    const shouldBeMinimized = showMode === ShowMode.BOTH && minimized;
+    if (showMode === ShowMode.BOTH) {
+      this.setMinimized(shouldBeMinimized);
+      return;
+    }
+
+    this.#splitWidget.setSidebarMinimized(false);
+    this.#splitWidget.setResizable(false);
+    this.#updatePresentation(false);
+    this.#drawerMinimizedSetting.set(false);
   }
 
   show(hasTargetDrawer: boolean): void {
+    const wasDrawerVisible = this.isVisibleForEvents();
     this.tabbedPane.setAutoSelectFirstItemOnShow(!hasTargetDrawer);
     this.#splitWidget.showBoth();
+    this.#dispatchPaneVisibilityChangedIfNeeded(wasDrawerVisible);
   }
 
   hide(): void {
-    this.#splitWidget.hideSidebar(true);
+    const wasDrawerVisible = this.isVisibleForEvents();
+    const wasMinimized = this.isMinimized();
+    this.#splitWidget.hideSidebar(!wasMinimized);
+    if (wasMinimized) {
+      this.#updatePresentation(false);
+      this.#splitWidget.setSidebarMinimized(false);
+      this.#splitWidget.setResizable(true);
+    }
+    this.#drawerMinimizedSetting.set(false);
+    this.#dispatchPaneVisibilityChangedIfNeeded(wasDrawerVisible);
+  }
+
+  setMinimized(minimized: boolean): void {
+    const wasDrawerVisible = this.isVisibleForEvents();
+    if (minimized && !this.isMinimized()) {
+      this.#drawerSizeBeforeMinimize = this.#splitWidget.sidebarSize();
+    }
+
+    this.#updatePresentation(minimized);
+    this.#splitWidget.setSidebarMinimized(minimized);
+    this.#dispatchPaneVisibilityChangedIfNeeded(wasDrawerVisible);
+    this.#splitWidget.setResizable(!minimized);
+    this.#drawerMinimizedSetting.set(minimized);
+    if (!minimized && this.#drawerSizeBeforeMinimize > 0) {
+      this.#splitWidget.setSidebarSize(this.#drawerSizeBeforeMinimize);
+    }
   }
 
   drawerVisible(): boolean {
     return this.tabbedPane.isShowing();
   }
 
+  isVisibleForEvents(): boolean {
+    return this.#splitWidget.sidebarIsShowing() && !this.isMinimized();
+  }
+
   drawerSize(): number {
     return this.#splitWidget.sidebarSize();
   }
@@ -176,31 +286,94 @@ export class InspectorDrawerView {
     return this.#splitWidget.totalSize();
   }
 
+  isMinimized(): boolean {
+    return this.#splitWidget.isSidebarMinimized();
+  }
+
   isVertical(): boolean {
     return this.#splitWidget.isVertical();
   }
 
-  updatePresentation(isVertical: boolean): void {
+  updatePresentation({isVertical, isMinimized, verticalExpandedMinimumWidth}: InspectorDrawerPresentation): void {
     this.#toggleOrientationButton.setGlyph(isVertical ? 'dock-bottom' : 'dock-right');
+    this.#updateMinimizeExpandButton(isVertical, isMinimized);
 
-    if (isVertical) {
-      this.tabbedPane.setMinimumSize(this.#verticalExpandedMinimumWidth, 27);
+    const isVerticalAndMinimized = isVertical && isMinimized;
+    if (isVerticalAndMinimized) {
+      this.tabbedPane.setMinimumSize(VERTICAL_MINIMIZED_DRAWER_SIZE, VERTICAL_MINIMIZED_DRAWER_SIZE);
+    } else if (isVertical) {
+      this.tabbedPane.setMinimumSize(verticalExpandedMinimumWidth, VERTICAL_MINIMIZED_DRAWER_SIZE);
     } else {
-      this.tabbedPane.setMinimumSize(0, 27);
+      this.tabbedPane.setMinimumSize(0, VERTICAL_MINIMIZED_DRAWER_SIZE);
+    }
+
+    this.tabbedPane.setVerticalMinimized(isVerticalAndMinimized);
+
+    if (this.#moreTabsButton) {
+      this.#moreTabsButton.setVisible(!isVerticalAndMinimized);
     }
+
+    if (!isVerticalAndMinimized && this.#wasVerticalAndMinimized) {
+      this.tabbedPane.restoreAfterVerticalMinimized();
+    }
+    this.#wasVerticalAndMinimized = isVerticalAndMinimized;
+  }
+
+  #updateMinimizeExpandButton(isVertical: boolean, isMinimized: boolean): void {
+    if (isMinimized) {
+      this.#minimizeExpandButton.setGlyph(isVertical ? 'right-panel-open' : 'bottom-panel-open');
+      this.#minimizeExpandButton.setTitle(i18nString(UIStrings.expandDrawer));
+      return;
+    }
+
+    this.#minimizeExpandButton.setGlyph(isVertical ? 'right-panel-close' : 'bottom-panel-close');
+    this.#minimizeExpandButton.setTitle(i18nString(UIStrings.minimizeDrawer));
   }
 
-  #updatePresentation(): void {
+  #updatePresentation(minimized: boolean): void {
     const drawerIsVertical = this.#splitWidget.isVertical();
     this.#setInspectorMinimumSize(
         drawerIsVertical ? this.#minimumSizes.inspectorWidthWhenVertical :
                            this.#minimumSizes.inspectorWidthWhenHorizontal,
         this.#minimumSizes.inspectorHeight);
-    this.updatePresentation(drawerIsVertical);
+    this.updatePresentation({
+      isVertical: drawerIsVertical,
+      isMinimized: minimized,
+      verticalExpandedMinimumWidth: this.#verticalExpandedMinimumWidth,
+    });
+  }
+
+  #dispatchPaneVisibilityChangedIfNeeded(wasDrawerVisible: boolean): void {
+    const isDrawerVisible = this.isVisibleForEvents();
+    if (wasDrawerVisible === isDrawerVisible) {
+      return;
+    }
+    this.tabbedPane.dispatchEventToListeners(TabbedPaneEvents.PaneVisibilityChanged, {isVisible: isDrawerVisible});
   }
 
   #drawerTabSelected(event: Common.EventTarget.EventTargetEvent<EventData>): void {
-    const {tabId} = event.data;
+    const {tabId, prevTabId, isUserGesture} = event.data;
     this.#onTabSelected(tabId);
+
+    if (this.#isConsoleOpenInMainAndDrawer(tabId)) {
+      return;
+    }
+
+    if (isUserGesture && prevTabId && prevTabId !== tabId && this.isMinimized()) {
+      this.#onExpandFromMinimized();
+    }
+  }
+
+  #drawerTabInvoked(event: Common.EventTarget.EventTargetEvent<EventData>): void {
+    const {tabId, isUserGesture} = event.data;
+    if (isUserGesture && this.#isConsoleOpenInMainAndDrawer(tabId)) {
+      if (!this.isMinimized()) {
+        this.#onMinimizeFromTabInteraction();
+      }
+      return;
+    }
+    if (isUserGesture && this.isMinimized()) {
+      this.#onExpandFromMinimized();
+    }
   }
 }