chrome-devtools-frontend 1.0.1626437 → 1.0.1626840

package/front_end/panels/profiler/LiveHeapProfileView.ts

@@ -1,405 +0,0 @@
-// Copyright 2019 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-/* eslint-disable @devtools/no-imperative-dom-api */
-
-import '../../ui/legacy/legacy.js';
-
-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 SDK from '../../core/sdk/sdk.js';
-import type * as Protocol from '../../generated/protocol.js';
-import * as Workspace from '../../models/workspace/workspace.js';
-import * as DataGrid from '../../ui/legacy/components/data_grid/data_grid.js';
-import * as UI from '../../ui/legacy/legacy.js';
-
-import liveHeapProfileStyles from './liveHeapProfile.css.js';
-
-const UIStrings = {
-  /**
-   * @description Text for a heap profile type
-   */
-  jsHeap: 'JS Heap',
-  /**
-   * @description Text in Live Heap Profile View of a profiler tool
-   */
-  allocatedJsHeapSizeCurrentlyIn: 'Allocated JS heap size currently in use',
-  /**
-   * @description Text in Live Heap Profile View of a profiler tool
-   */
-  vms: 'VMs',
-  /**
-   * @description Text in Live Heap Profile View of a profiler tool
-   */
-  numberOfVmsSharingTheSameScript: 'Number of VMs sharing the same script source',
-  /**
-   * @description Text in Live Heap Profile View of a profiler tool
-   */
-  scriptUrl: 'Script URL',
-  /**
-   * @description Text in Live Heap Profile View of a profiler tool
-   */
-  urlOfTheScriptSource: 'URL of the script source',
-  /**
-   * @description Data grid name for Heap Profile data grids
-   */
-  heapProfile: 'Heap Profile',
-  /**
-   * @description Text in Live Heap Profile View of a profiler tool
-   * @example {1} PH1
-   */
-  anonymousScriptS: '(Anonymous Script {PH1})',
-  /**
-   * @description A unit
-   */
-  kb: 'kB',
-} as const;
-const str_ = i18n.i18n.registerUIStrings('panels/profiler/LiveHeapProfileView.ts', UIStrings);
-const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-let liveHeapProfileViewInstance: LiveHeapProfileView;
-export class LiveHeapProfileView extends UI.Widget.VBox {
-  readonly gridNodeByUrl: Map<string, GridNode>;
-  setting: Common.Settings.Setting<boolean>;
-  readonly toggleRecordAction: UI.ActionRegistration.Action;
-  readonly toggleRecordButton: UI.Toolbar.ToolbarToggle;
-  readonly startWithReloadButton: UI.Toolbar.ToolbarButton|undefined;
-  readonly dataGrid: DataGrid.SortableDataGrid.SortableDataGrid<GridNode>;
-  currentPollId: number;
-
-  private constructor() {
-    super({useShadowDom: true});
-    this.gridNodeByUrl = new Map();
-    this.registerRequiredCSS(liveHeapProfileStyles);
-
-    this.setting = Common.Settings.Settings.instance().moduleSetting('memory-live-heap-profile');
-    const toolbar = this.contentElement.createChild('devtools-toolbar', 'live-heap-profile-toolbar');
-    this.toggleRecordAction =
-        UI.ActionRegistry.ActionRegistry.instance().getAction('live-heap-profile.toggle-recording');
-    this.toggleRecordButton =
-        (UI.Toolbar.Toolbar.createActionButton(this.toggleRecordAction) as UI.Toolbar.ToolbarToggle);
-    this.toggleRecordButton.setToggled(this.setting.get());
-    toolbar.appendToolbarItem(this.toggleRecordButton);
-
-    const mainTarget = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
-    if (mainTarget?.model(SDK.ResourceTreeModel.ResourceTreeModel)) {
-      const startWithReloadAction =
-          UI.ActionRegistry.ActionRegistry.instance().getAction('live-heap-profile.start-with-reload');
-      this.startWithReloadButton = UI.Toolbar.Toolbar.createActionButton(startWithReloadAction);
-      toolbar.appendToolbarItem(this.startWithReloadButton);
-    }
-
-    this.dataGrid = this.createDataGrid();
-    this.dataGrid.asWidget().show(this.contentElement);
-
-    this.currentPollId = 0;
-  }
-
-  static instance(): LiveHeapProfileView {
-    if (!liveHeapProfileViewInstance) {
-      liveHeapProfileViewInstance = new LiveHeapProfileView();
-    }
-    return liveHeapProfileViewInstance;
-  }
-
-  createDataGrid(): DataGrid.SortableDataGrid.SortableDataGrid<GridNode> {
-    const defaultColumnConfig = {
-      title: Common.UIString.LocalizedEmptyString,
-      fixedWidth: true,
-      sortable: true,
-      align: DataGrid.DataGrid.Align.RIGHT,
-      sort: DataGrid.DataGrid.Order.Descending,
-    };
-    const columns: Array<{tooltip: Common.UIString.LocalizedString}&DataGrid.DataGrid.ColumnDescriptor> = [
-      {
-        ...defaultColumnConfig,
-        id: 'size',
-        title: i18nString(UIStrings.jsHeap),
-        width: '72px',
-        fixedWidth: true,
-        sortable: true,
-        align: DataGrid.DataGrid.Align.RIGHT,
-        sort: DataGrid.DataGrid.Order.Descending,
-        tooltip: i18nString(UIStrings.allocatedJsHeapSizeCurrentlyIn),
-      },
-      {
-        ...defaultColumnConfig,
-        id: 'isolates',
-        title: i18nString(UIStrings.vms),
-        width: '40px',
-        fixedWidth: true,
-        align: DataGrid.DataGrid.Align.RIGHT,
-        tooltip: i18nString(UIStrings.numberOfVmsSharingTheSameScript),
-      },
-      {
-        ...defaultColumnConfig,
-        id: 'url',
-        title: i18nString(UIStrings.scriptUrl),
-        fixedWidth: false,
-        sortable: true,
-        tooltip: i18nString(UIStrings.urlOfTheScriptSource),
-      },
-    ];
-    const dataGrid = new DataGrid.SortableDataGrid.SortableDataGrid({
-      displayName: i18nString(UIStrings.heapProfile),
-      columns,
-    });
-    dataGrid.setResizeMethod(DataGrid.DataGrid.ResizeMethod.LAST);
-    dataGrid.element.classList.add('flex-auto');
-    dataGrid.element.addEventListener('keydown', this.onKeyDown.bind(this), false);
-    dataGrid.addEventListener(DataGrid.DataGrid.Events.OPENED_NODE, this.revealSourceForSelectedNode, this);
-    dataGrid.addEventListener(DataGrid.DataGrid.Events.SORTING_CHANGED, this.sortingChanged, this);
-    for (const info of columns) {
-      const headerCell = dataGrid.headerTableHeader(info.id);
-      if (headerCell) {
-        headerCell.setAttribute('title', info.tooltip);
-      }
-    }
-    return dataGrid;
-  }
-
-  override wasShown(): void {
-    super.wasShown();
-    void this.poll();
-    this.setting.addChangeListener(this.settingChanged, this);
-  }
-
-  override willHide(): void {
-    super.willHide();
-    ++this.currentPollId;
-    this.setting.removeChangeListener(this.settingChanged, this);
-  }
-
-  settingChanged(value: Common.EventTarget.EventTargetEvent<boolean>): void {
-    this.toggleRecordButton.setToggled(value.data);
-  }
-
-  async poll(): Promise<void> {
-    const pollId = this.currentPollId;
-    do {
-      const isolates = Array.from(SDK.IsolateManager.IsolateManager.instance().isolates());
-      const profiles = await Promise.all(isolates.map(isolate => {
-        const heapProfilerModel = isolate.heapProfilerModel();
-        if (!heapProfilerModel) {
-          return null;
-        }
-
-        return heapProfilerModel.getSamplingProfile();
-      }));
-      if (this.currentPollId !== pollId) {
-        return;
-      }
-      this.update(isolates, profiles);
-      await new Promise(r => window.setTimeout(r, 3000));
-    } while (this.currentPollId === pollId);
-  }
-
-  update(
-      isolates: SDK.IsolateManager.Isolate[] = [],
-      profiles: Array<Protocol.HeapProfiler.SamplingHeapProfile|null> = []): void {
-    const dataByUrl = new Map<string, {
-      size: number,
-      isolates: Set<SDK.IsolateManager.Isolate>,
-    }>();
-    profiles.forEach((profile, index) => {
-      if (profile) {
-        processNodeTree(isolates[index], '', profile.head);
-      }
-    });
-
-    const rootNode = this.dataGrid.rootNode();
-    const existingNodes = new Set<GridNode>();
-    for (const pair of dataByUrl) {
-      const url = (pair[0]);
-      const size = (pair[1].size);
-      const isolateCount = (pair[1].isolates.size);
-      if (!url) {
-        console.info(`Node with empty URL: ${size} bytes`);  // eslint-disable-line no-console
-        continue;
-      }
-      let node = this.gridNodeByUrl.get(url);
-      if (node) {
-        node.updateNode(size, isolateCount);
-      } else {
-        node = new GridNode(url, size, isolateCount);
-        this.gridNodeByUrl.set(url, node);
-        rootNode.appendChild(node);
-      }
-      existingNodes.add(node);
-    }
-
-    for (const node of rootNode.children.slice()) {
-      const gridNode = node as GridNode;
-      if (!existingNodes.has(gridNode)) {
-        gridNode.remove();
-      }
-      this.gridNodeByUrl.delete(gridNode.url);
-    }
-
-    this.sortingChanged();
-
-    function processNodeTree(
-        isolate: SDK.IsolateManager.Isolate, parentUrl: string,
-        node: Protocol.HeapProfiler.SamplingHeapProfileNode): void {
-      const url = node.callFrame.url || parentUrl || systemNodeName(node) || anonymousScriptName(node);
-      node.children.forEach(processNodeTree.bind(null, isolate, url));
-      if (!node.selfSize) {
-        return;
-      }
-      let data = dataByUrl.get(url);
-      if (!data) {
-        data = {size: 0, isolates: new Set()};
-        dataByUrl.set(url, data);
-      }
-      data.size += node.selfSize;
-      data.isolates.add(isolate);
-    }
-
-    function systemNodeName(node: Protocol.HeapProfiler.SamplingHeapProfileNode): string {
-      const name = node.callFrame.functionName;
-      return name.startsWith('(') && name !== '(root)' ? name : '';
-    }
-
-    function anonymousScriptName(node: Protocol.HeapProfiler.SamplingHeapProfileNode): string {
-      return Number(node.callFrame.scriptId) ? i18nString(UIStrings.anonymousScriptS, {PH1: node.callFrame.scriptId}) :
-                                               '';
-    }
-  }
-
-  onKeyDown(event: KeyboardEvent): void {
-    if (!(event.key === 'Enter')) {
-      return;
-    }
-    event.consume(true);
-    this.revealSourceForSelectedNode();
-  }
-
-  revealSourceForSelectedNode(): void {
-    const node = (this.dataGrid.selectedNode as GridNode);
-    if (!node?.url) {
-      return;
-    }
-    const sourceCode =
-        Workspace.Workspace.WorkspaceImpl.instance().uiSourceCodeForURL(node.url as Platform.DevToolsPath.UrlString);
-    if (sourceCode) {
-      void Common.Revealer.reveal(sourceCode);
-    }
-  }
-
-  sortingChanged(): void {
-    const columnId = this.dataGrid.sortColumnId();
-    if (!columnId) {
-      return;
-    }
-
-    function sortByUrl(
-        a: DataGrid.SortableDataGrid.SortableDataGridNode<GridNode>,
-        b: DataGrid.SortableDataGrid.SortableDataGridNode<GridNode>): number {
-      return (b as GridNode).url.localeCompare((a as GridNode).url);
-    }
-
-    function sortBySize(
-        a: DataGrid.SortableDataGrid.SortableDataGridNode<GridNode>,
-        b: DataGrid.SortableDataGrid.SortableDataGridNode<GridNode>): number {
-      return (b as GridNode).size - (a as GridNode).size;
-    }
-
-    const sortFunction = columnId === 'url' ? sortByUrl : sortBySize;
-    this.dataGrid.sortNodes(sortFunction, this.dataGrid.isSortOrderAscending());
-  }
-
-  toggleRecording(): void {
-    const enable = !this.setting.get();
-    if (enable) {
-      this.startRecording(false);
-    } else {
-      void this.stopRecording();
-    }
-  }
-
-  startRecording(reload?: boolean): void {
-    this.setting.set(true);
-    if (!reload) {
-      return;
-    }
-    const mainTarget = SDK.TargetManager.TargetManager.instance().primaryPageTarget();
-    if (!mainTarget) {
-      return;
-    }
-    const resourceTreeModel = (mainTarget.model(SDK.ResourceTreeModel.ResourceTreeModel));
-    if (resourceTreeModel) {
-      resourceTreeModel.reloadPage();
-    }
-  }
-
-  async stopRecording(): Promise<void> {
-    this.setting.set(false);
-  }
-}
-
-export class GridNode extends DataGrid.SortableDataGrid.SortableDataGridNode<unknown> {
-  url: string;
-  size: number;
-  isolateCount: number;
-
-  constructor(url: string, size: number, isolateCount: number) {
-    super();
-    this.url = url;
-    this.size = size;
-    this.isolateCount = isolateCount;
-  }
-
-  updateNode(size: number, isolateCount: number): void {
-    if (this.size === size && this.isolateCount === isolateCount) {
-      return;
-    }
-    this.size = size;
-    this.isolateCount = isolateCount;
-    this.refresh();
-  }
-
-  override createCell(columnId: string): HTMLElement {
-    const cell = this.createTD(columnId);
-    switch (columnId) {
-      case 'url':
-        cell.textContent = this.url;
-        break;
-      case 'size':
-        cell.textContent = Platform.NumberUtilities.withThousandsSeparator(Math.round(this.size / 1e3));
-        cell.createChild('span', 'size-units').textContent = i18nString(UIStrings.kb);
-        break;
-      case 'isolates':
-        cell.textContent = `${this.isolateCount}`;
-        break;
-    }
-    return cell;
-  }
-}
-
-export class ActionDelegate implements UI.ActionRegistration.ActionDelegate {
-  handleAction(_context: UI.Context.Context, actionId: string): boolean {
-    void (async () => {
-      const profileViewId = 'live-heap-profile';
-      await UI.ViewManager.ViewManager.instance().showView(profileViewId);
-      const view = UI.ViewManager.ViewManager.instance().view(profileViewId);
-      if (view) {
-        const widget = await view.widget();
-        this.innerHandleAction((widget as LiveHeapProfileView), actionId);
-      }
-    })();
-    return true;
-  }
-
-  innerHandleAction(profilerView: LiveHeapProfileView, actionId: string): void {
-    switch (actionId) {
-      case 'live-heap-profile.toggle-recording':
-        profilerView.toggleRecording();
-        break;
-      case 'live-heap-profile.start-with-reload':
-        profilerView.startRecording(true);
-        break;
-      default:
-        console.assert(false, `Unknown action: ${actionId}`);
-    }
-  }
-}

package/front_end/panels/profiler/liveHeapProfile.css

@@ -1,22 +0,0 @@
-/*
- * Copyright 2019 The Chromium Authors
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-.data-grid {
-  border: none;
-}
-
-.data-grid td .size-units {
-  margin-left: 4px;
-  font-size: 75%;
-}
-
-.data-grid tr:not(.selected) td .size-units {
-  color: var(--sys-color-token-subtle);
-}
-
-devtools-toolbar {
-  border-bottom: 1px solid var(--sys-color-divider);
-}

package/front_end/ui/legacy/components/perf_ui/LiveHeapProfile.ts

@@ -1,113 +0,0 @@
-// Copyright 2019 The Chromium Authors
-// 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 * as Host from '../../../../core/host/host.js';
-import * as SDK from '../../../../core/sdk/sdk.js';
-import type * as Protocol from '../../../../generated/protocol.js';
-
-import {Memory} from './LineLevelProfile.js';
-
-let liveHeapProfileInstance: LiveHeapProfile;
-export class LiveHeapProfile implements Common.Runnable.Runnable,
-                                        SDK.TargetManager.SDKModelObserver<SDK.HeapProfilerModel.HeapProfilerModel> {
-  private running: boolean;
-  private sessionId: number;
-  private loadEventCallback: (arg0?: () => void|null) => void;
-  private readonly setting: Common.Settings.Setting<boolean>;
-
-  private constructor() {
-    this.running = false;
-    this.sessionId = 0;
-    this.loadEventCallback = () => {};
-    this.setting = Common.Settings.Settings.instance().moduleSetting('memory-live-heap-profile');
-    this.setting.addChangeListener(event => event.data ? this.startProfiling() : this.stopProfiling());
-    if (this.setting.get()) {
-      void this.startProfiling();
-    }
-  }
-
-  static instance(opts: {forceNew: boolean|null} = {forceNew: null}): LiveHeapProfile {
-    const {forceNew} = opts;
-    if (!liveHeapProfileInstance || forceNew) {
-      liveHeapProfileInstance = new LiveHeapProfile();
-    }
-
-    return liveHeapProfileInstance;
-  }
-
-  async run(): Promise<void> {
-    return;
-  }
-
-  modelAdded(model: SDK.HeapProfilerModel.HeapProfilerModel): void {
-    void model.startSampling(1e4);
-  }
-
-  modelRemoved(_model: SDK.HeapProfilerModel.HeapProfilerModel): void {
-    // Cannot do much when the model has already been removed.
-  }
-
-  private async startProfiling(): Promise<void> {
-    if (this.running) {
-      return;
-    }
-    this.running = true;
-    const sessionId = this.sessionId;
-    SDK.TargetManager.TargetManager.instance().observeModels(SDK.HeapProfilerModel.HeapProfilerModel, this);
-    SDK.TargetManager.TargetManager.instance().addModelListener(
-        SDK.ResourceTreeModel.ResourceTreeModel, SDK.ResourceTreeModel.Events.Load, this.loadEventFired, this);
-
-    do {
-      const models = SDK.TargetManager.TargetManager.instance().models(SDK.HeapProfilerModel.HeapProfilerModel);
-      const profiles = await Promise.all(models.map(model => model.getSamplingProfile()));
-      if (sessionId !== this.sessionId) {
-        break;
-      }
-
-      const profilesAndTargets: Array<{
-        profile: Protocol.HeapProfiler.SamplingHeapProfile,
-        target: SDK.Target.Target,
-      }> = [];
-      for (let i = 0; i < profiles.length; ++i) {
-        const profile = profiles[i];
-        if (!profile) {
-          continue;
-        }
-
-        const target = models[i].target();
-        profilesAndTargets.push({profile, target});
-      }
-
-      Memory.instance().initialize(profilesAndTargets);
-
-      await Promise.race([
-        new Promise(r => window.setTimeout(r, Host.InspectorFrontendHost.isUnderTest() ? 10 : 5000)),
-        new Promise(r => {
-          this.loadEventCallback = r;
-        }),
-      ]);
-    } while (sessionId === this.sessionId);
-
-    SDK.TargetManager.TargetManager.instance().unobserveModels(SDK.HeapProfilerModel.HeapProfilerModel, this);
-    SDK.TargetManager.TargetManager.instance().removeModelListener(
-        SDK.ResourceTreeModel.ResourceTreeModel, SDK.ResourceTreeModel.Events.Load, this.loadEventFired, this);
-    for (const model of SDK.TargetManager.TargetManager.instance().models(SDK.HeapProfilerModel.HeapProfilerModel)) {
-      void model.stopSampling();
-    }
-    Memory.instance().reset();
-  }
-
-  private stopProfiling(): void {
-    if (!this.running) {
-      return;
-    }
-    this.running = false;
-    this.sessionId++;
-  }
-
-  private loadEventFired(): void {
-    this.loadEventCallback();
-  }
-}