chrome-devtools-frontend 1.0.922782 → 1.0.923788

package/front_end/panels/profiler/HeapProfileView.ts

@@ -123,7 +123,7 @@ function convertToSamplingHeapProfile(profileHeader: SamplingHeapProfileHeader):
 
 export class HeapProfileView extends ProfileView implements UI.SearchableView.Searchable {
   profileHeader: SamplingHeapProfileHeader;
-  readonly profileType: ProfileType;
+  readonly profileType: SamplingHeapProfileTypeBase;
   adjustedTotal: number;
   readonly selectedSizeText: UI.Toolbar.ToolbarText;
   timestamps: number[];
@@ -243,7 +243,8 @@ export class HeapProfileView extends ProfileView implements UI.SearchableView.Se
   }
 }
 
-export class SamplingHeapProfileTypeBase extends ProfileType {
+export class SamplingHeapProfileTypeBase extends
+    Common.ObjectWrapper.eventMixin<SamplingHeapProfileType.EventTypes, typeof ProfileType>(ProfileType) {
   recording: boolean;
   clearedDuringRecording: boolean;
 
@@ -445,6 +446,11 @@ export namespace SamplingHeapProfileType {
     RecordingStopped = 'RecordingStopped',
     StatsUpdate = 'StatsUpdate',
   }
+
+  export type EventTypes = {
+    [Events.RecordingStopped]: void,
+    [Events.StatsUpdate]: Protocol.HeapProfiler.SamplingHeapProfile|null,
+  };
 }
 
 export class SamplingHeapProfileHeader extends WritableProfileHeader {
@@ -505,6 +511,10 @@ export class SamplingHeapProfileHeader extends WritableProfileHeader {
   heapProfilerModel(): SDK.HeapProfilerModel.HeapProfilerModel|null {
     return this.heapProfilerModelInternal;
   }
+
+  override profileType(): SamplingHeapProfileTypeBase {
+    return super.profileType() as SamplingHeapProfileTypeBase;
+  }
 }
 
 export class SamplingHeapProfileNode extends SDK.ProfileTreeModel.ProfileNode {

package/front_end/panels/profiler/HeapSnapshotDataGrids.ts

@@ -28,6 +28,7 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+import * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import * as HeapSnapshotModel from '../../models/heap_snapshot_model/heap_snapshot_model.js';
 import * as DataGrid from '../../ui/legacy/components/data_grid/data_grid.js';
@@ -146,7 +147,11 @@ const str_ = i18n.i18n.registerUIStrings('panels/profiler/HeapSnapshotDataGrids.
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 const adjacencyMap = new WeakMap<DataGrid.DataGrid.DataGridNode<HeapSnapshotGridNode>, HeapSnapshotGridNode[]>();
 
-export class HeapSnapshotSortableDataGrid extends DataGrid.DataGrid.DataGridImpl<HeapSnapshotGridNode> {
+class HeapSnapshotSortableDataGridBase extends DataGrid.DataGrid.DataGridImpl<HeapSnapshotGridNode> {}
+
+export class HeapSnapshotSortableDataGrid extends
+    Common.ObjectWrapper.eventMixin<EventTypes, typeof HeapSnapshotSortableDataGridBase>(
+        HeapSnapshotSortableDataGridBase) {
   snapshot: HeapSnapshotProxy|null;
   selectedNode: HeapSnapshotGridNode|null;
   readonly heapProfilerModelInternal: SDK.HeapProfilerModel.HeapProfilerModel|null;
@@ -402,8 +407,15 @@ export class HeapSnapshotSortableDataGrid extends DataGrid.DataGrid.DataGridImpl
 export enum HeapSnapshotSortableDataGridEvents {
   ContentShown = 'ContentShown',
   SortingComplete = 'SortingComplete',
+  ExpandRetainersComplete = 'ExpandRetainersComplete',
 }
 
+export type EventTypes = {
+  [HeapSnapshotSortableDataGridEvents.ContentShown]: HeapSnapshotSortableDataGrid,
+  [HeapSnapshotSortableDataGridEvents.SortingComplete]: void,
+  [HeapSnapshotSortableDataGridEvents.ExpandRetainersComplete]: void,
+};
+
 export class HeapSnapshotViewportDataGrid extends HeapSnapshotSortableDataGrid {
   topPaddingHeight: number;
   bottomPaddingHeight: number;
@@ -734,6 +746,7 @@ export class HeapSnapshotRetainmentDataGrid extends HeapSnapshotContainmentDataG
 }
 
 // TODO(crbug.com/1167717): Make this a const enum again
+// TODO(crbug.com/1228674): Remove this enum, it is only used in web tests.
 // eslint-disable-next-line rulesdir/const_enum
 export enum HeapSnapshotRetainmentDataGridEvents {
   ExpandRetainersComplete = 'ExpandRetainersComplete',

package/front_end/panels/profiler/HeapSnapshotGridNodes.ts

@@ -39,7 +39,7 @@ import * as UI from '../../ui/legacy/legacy.js';
 
 import type {ChildrenProvider} from './ChildrenProvider.js';
 import type {AllocationDataGrid, HeapSnapshotConstructorsDataGrid, HeapSnapshotDiffDataGrid, HeapSnapshotSortableDataGrid} from './HeapSnapshotDataGrids.js';
-import {HeapSnapshotRetainmentDataGridEvents} from './HeapSnapshotDataGrids.js';
+import {HeapSnapshotSortableDataGridEvents} from './HeapSnapshotDataGrids.js';
 import type {HeapSnapshotProviderProxy, HeapSnapshotProxy} from './HeapSnapshotProxy.js';
 import type {DataDisplayDelegate} from './ProfileHeader.js';
 
@@ -93,7 +93,11 @@ const UIStrings = {
 const str_ = i18n.i18n.registerUIStrings('panels/profiler/HeapSnapshotGridNodes.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
 
-export class HeapSnapshotGridNode extends DataGrid.DataGrid.DataGridNode<HeapSnapshotGridNode> {
+class HeapSnapshotGridNodeBase extends DataGrid.DataGrid.DataGridNode<HeapSnapshotGridNode> {}
+
+export class HeapSnapshotGridNode extends
+    Common.ObjectWrapper.eventMixin<HeapSnapshotGridNode.EventTypes, typeof HeapSnapshotGridNodeBase>(
+        HeapSnapshotGridNodeBase) {
   dataGridInternal: HeapSnapshotSortableDataGrid;
   instanceCount: number;
   readonly savedChildren: Map<number, HeapSnapshotGridNode>;
@@ -469,6 +473,10 @@ export namespace HeapSnapshotGridNode {
   export enum Events {
     PopulateComplete = 'PopulateComplete',
   }
+
+  export type EventTypes = {
+    [Events.PopulateComplete]: void,
+  };
 }
 
 export abstract class HeapSnapshotGenericObjectNode extends HeapSnapshotGridNode {
@@ -847,7 +855,7 @@ export class HeapSnapshotRetainingObjectNode extends HeapSnapshotObjectNode {
         return;
       }
     }
-    this.dataGridInternal.dispatchEventToListeners(HeapSnapshotRetainmentDataGridEvents.ExpandRetainersComplete);
+    this.dataGridInternal.dispatchEventToListeners(HeapSnapshotSortableDataGridEvents.ExpandRetainersComplete);
   }
 }
 

package/front_end/panels/profiler/HeapSnapshotView.ts

@@ -306,7 +306,7 @@ export class HeapSnapshotView extends UI.View.SimpleView implements DataDisplayD
     this.linkifier = new Components.Linkifier.Linkifier();
     const profileType = profile.profileType();
 
-    profileType.addEventListener(HeapSnapshotProfileType.SnapshotReceived, this.onReceiveSnapshot, this);
+    profileType.addEventListener(HeapSnapshotProfileTypeEvents.SnapshotReceived, this.onReceiveSnapshot, this);
     profileType.addEventListener(ProfileTypeEvents.RemoveProfileHeader, this.onProfileHeaderRemoved, this);
 
     const isHeapTimeline = profileType.id === TrackingHeapSnapshotProfileType.TypeId;
@@ -429,7 +429,7 @@ export class HeapSnapshotView extends UI.View.SimpleView implements DataDisplayD
     this.currentPerspectiveIndex = 0;
     this.currentPerspective = this.perspectives[0];
     this.currentPerspective.activate(this);
-    this.dataGrid = (this.currentPerspective.masterGrid(this) as HeapSnapshotSortableDataGrid | null);
+    this.dataGrid = this.currentPerspective.masterGrid(this);
 
     this.populate();
     this.searchThrottler = new Common.Throttler.Throttler(0);
@@ -444,26 +444,27 @@ export class HeapSnapshotView extends UI.View.SimpleView implements DataDisplayD
     this.trackingOverviewGrid = new HeapTimelineOverview();
     this.trackingOverviewGrid.addEventListener(Events.IdsRangeChanged, this.onIdsRangeChanged.bind(this));
     if (!this.profile.fromFile() && profileType.profileBeingRecorded() === this.profile) {
-      profileType.addEventListener(TrackingHeapSnapshotProfileType.HeapStatsUpdate, this.onHeapStatsUpdate, this);
-      profileType.addEventListener(TrackingHeapSnapshotProfileType.TrackingStopped, this.onStopTracking, this);
+      (profileType as TrackingHeapSnapshotProfileType)
+          .addEventListener(TrackingHeapSnapshotProfileTypeEvents.HeapStatsUpdate, this.onHeapStatsUpdate, this);
+      (profileType as TrackingHeapSnapshotProfileType)
+          .addEventListener(TrackingHeapSnapshotProfileTypeEvents.TrackingStopped, this.onStopTracking, this);
       this.trackingOverviewGrid.start();
     }
   }
 
   onStopTracking(): void {
-    this.profile.profileType().removeEventListener(
-        TrackingHeapSnapshotProfileType.HeapStatsUpdate, this.onHeapStatsUpdate, this);
-    this.profile.profileType().removeEventListener(
-        TrackingHeapSnapshotProfileType.TrackingStopped, this.onStopTracking, this);
+    const profileType = this.profile.profileType() as TrackingHeapSnapshotProfileType;
+    profileType.removeEventListener(
+        TrackingHeapSnapshotProfileTypeEvents.HeapStatsUpdate, this.onHeapStatsUpdate, this);
+    profileType.removeEventListener(TrackingHeapSnapshotProfileTypeEvents.TrackingStopped, this.onStopTracking, this);
     if (this.trackingOverviewGrid) {
       this.trackingOverviewGrid.stop();
     }
   }
 
-  onHeapStatsUpdate(event: Common.EventTarget.EventTargetEvent): void {
-    const samples = event.data;
-    if (samples && this.trackingOverviewGrid) {
-      this.trackingOverviewGrid.setSamples(event.data);
+  onHeapStatsUpdate({data: samples}: Common.EventTarget.EventTargetEvent<Samples>): void {
+    if (this.trackingOverviewGrid) {
+      this.trackingOverviewGrid.setSamples(samples);
     }
   }
 
@@ -726,19 +727,22 @@ export class HeapSnapshotView extends UI.View.SimpleView implements DataDisplayD
     return this.profile.profileType().getProfiles();
   }
 
-  selectionChanged(event: Common.EventTarget.EventTargetEvent): void {
+  selectionChanged(event: Common.EventTarget.EventTargetEvent<DataGrid.DataGrid.DataGridNode<HeapSnapshotGridNode>>):
+      void {
     const selectedNode = (event.data as HeapSnapshotGridNode);
     this.setSelectedNodeForDetailsView(selectedNode);
     this.inspectedObjectChanged(event);
   }
 
-  onSelectAllocationNode(event: Common.EventTarget.EventTargetEvent): void {
+  onSelectAllocationNode(
+      event: Common.EventTarget.EventTargetEvent<DataGrid.DataGrid.DataGridNode<HeapSnapshotGridNode>>): void {
     const selectedNode = (event.data as AllocationGridNode);
     this.constructorsDataGrid.setAllocationNodeId(selectedNode.allocationNodeId());
     this.setSelectedNodeForDetailsView(null);
   }
 
-  inspectedObjectChanged(event: Common.EventTarget.EventTargetEvent): void {
+  inspectedObjectChanged(
+      event: Common.EventTarget.EventTargetEvent<DataGrid.DataGrid.DataGridNode<HeapSnapshotGridNode>>): void {
     const selectedNode = (event.data as HeapSnapshotGridNode);
     const heapProfilerModel = this.profile.heapProfilerModel();
     if (heapProfilerModel && selectedNode instanceof HeapSnapshotGenericObjectNode) {
@@ -961,14 +965,14 @@ export class HeapSnapshotView extends UI.View.SimpleView implements DataDisplayD
     profile.addEventListener(ProfileHeaderEvents.ProfileTitleChanged, this.updateControls, this);
   }
 
-  onProfileHeaderRemoved(event: Common.EventTarget.EventTargetEvent): void {
+  onProfileHeaderRemoved(event: Common.EventTarget.EventTargetEvent<ProfileHeader>): void {
     const profile = event.data;
     profile.removeEventListener(ProfileHeaderEvents.ProfileTitleChanged, this.updateControls, this);
 
     if (this.profile === profile) {
       this.detach();
       this.profile.profileType().removeEventListener(
-          HeapSnapshotProfileType.SnapshotReceived, this.onReceiveSnapshot, this);
+          HeapSnapshotProfileTypeEvents.SnapshotReceived, this.onReceiveSnapshot, this);
       this.profile.profileType().removeEventListener(
           ProfileTypeEvents.RemoveProfileHeader, this.onProfileHeaderRemoved, this);
       this.dispose();
@@ -1020,7 +1024,7 @@ export class Perspective {
     heapSnapshotView.splitWidget.detachChildWidgets();
   }
 
-  masterGrid(_heapSnapshotView: HeapSnapshotView): DataGrid.DataGrid.DataGridImpl<HeapSnapshotGridNode>|null {
+  masterGrid(_heapSnapshotView: HeapSnapshotView): HeapSnapshotSortableDataGrid|null {
     return null;
   }
 
@@ -1053,7 +1057,7 @@ export class SummaryPerspective extends Perspective {
     heapSnapshotView.trackingOverviewGrid.updateGrid();
   }
 
-  masterGrid(heapSnapshotView: HeapSnapshotView): DataGrid.DataGrid.DataGridImpl<HeapSnapshotGridNode>|null {
+  masterGrid(heapSnapshotView: HeapSnapshotView): HeapSnapshotSortableDataGrid {
     return heapSnapshotView.constructorsDataGrid;
   }
 
@@ -1075,7 +1079,7 @@ export class ComparisonPerspective extends Perspective {
     heapSnapshotView.classNameFilter.setVisible(true);
   }
 
-  masterGrid(heapSnapshotView: HeapSnapshotView): DataGrid.DataGrid.DataGridImpl<HeapSnapshotGridNode>|null {
+  masterGrid(heapSnapshotView: HeapSnapshotView): HeapSnapshotSortableDataGrid {
     return heapSnapshotView.diffDataGrid;
   }
 
@@ -1095,7 +1099,7 @@ export class ContainmentPerspective extends Perspective {
     heapSnapshotView.splitWidget.show(heapSnapshotView.searchableViewInternal.element);
   }
 
-  masterGrid(heapSnapshotView: HeapSnapshotView): DataGrid.DataGrid.DataGridImpl<HeapSnapshotGridNode>|null {
+  masterGrid(heapSnapshotView: HeapSnapshotView): HeapSnapshotSortableDataGrid {
     return heapSnapshotView.containmentDataGrid;
   }
 }
@@ -1143,7 +1147,7 @@ export class AllocationPerspective extends Perspective {
     super.deactivate(heapSnapshotView);
   }
 
-  masterGrid(heapSnapshotView: HeapSnapshotView): DataGrid.DataGrid.DataGridImpl<HeapSnapshotGridNode>|null {
+  masterGrid(heapSnapshotView: HeapSnapshotView): HeapSnapshotSortableDataGrid|null {
     return heapSnapshotView.allocationDataGrid;
   }
 }
@@ -1157,13 +1161,14 @@ export class StatisticsPerspective extends Perspective {
     heapSnapshotView.statisticsView.show(heapSnapshotView.searchableViewInternal.element);
   }
 
-  masterGrid(_heapSnapshotView: HeapSnapshotView): DataGrid.DataGrid.DataGridImpl<HeapSnapshotGridNode>|null {
+  masterGrid(_heapSnapshotView: HeapSnapshotView): HeapSnapshotSortableDataGrid|null {
     return null;
   }
 }
 
-export class HeapSnapshotProfileType extends ProfileType implements
-    SDK.TargetManager.SDKModelObserver<SDK.HeapProfilerModel.HeapProfilerModel> {
+export class HeapSnapshotProfileType extends
+    Common.ObjectWrapper.eventMixin<HeapSnapshotProfileTypeEventTypes, typeof ProfileType>(ProfileType)
+        implements SDK.TargetManager.SDKModelObserver<SDK.HeapProfilerModel.HeapProfilerModel> {
   readonly treatGlobalObjectsAsRoots: Common.Settings.Setting<boolean>;
   readonly captureNumericValue: Common.Settings.Setting<boolean>;
   customContentInternal: HTMLElement|null;
@@ -1313,16 +1318,27 @@ export class HeapSnapshotProfileType extends ProfileType implements
     if (this.profileBeingRecorded() === profile) {
       this.setProfileBeingRecorded(null);
     }
-    this.dispatchEventToListeners(HeapSnapshotProfileType.SnapshotReceived, profile);
+    this.dispatchEventToListeners(HeapSnapshotProfileTypeEvents.SnapshotReceived, profile);
   }
 
   // eslint-disable-next-line @typescript-eslint/naming-convention
   static readonly TypeId: string = 'HEAP';
+  // TODO(crbug.com/1228674): Remove event string once its no longer used in web tests.
   // eslint-disable-next-line @typescript-eslint/naming-convention
   static readonly SnapshotReceived = 'SnapshotReceived';
 }
 
-export class TrackingHeapSnapshotProfileType extends HeapSnapshotProfileType {
+export const enum HeapSnapshotProfileTypeEvents {
+  SnapshotReceived = 'SnapshotReceived',
+}
+
+export type HeapSnapshotProfileTypeEventTypes = {
+  [HeapSnapshotProfileTypeEvents.SnapshotReceived]: ProfileHeader,
+};
+
+export class TrackingHeapSnapshotProfileType extends
+    Common.ObjectWrapper.eventMixin<TrackingHeapSnapshotProfileTypeEventTypes, typeof HeapSnapshotProfileType>(
+        HeapSnapshotProfileType) {
   readonly recordAllocationStacksSettingInternal: Common.Settings.Setting<boolean>;
   customContentInternal: UI.UIUtils.CheckboxLabel|null;
   recording: boolean;
@@ -1380,7 +1396,9 @@ export class TrackingHeapSnapshotProfileType extends HeapSnapshotProfileType {
     if (profileSamples.totalTime < timestamp - profileSamples.timestamps[0]) {
       profileSamples.totalTime *= 2;
     }
-    this.dispatchEventToListeners(TrackingHeapSnapshotProfileType.HeapStatsUpdate, this.profileSamples);
+    if (this.profileSamples) {
+      this.dispatchEventToListeners(TrackingHeapSnapshotProfileTypeEvents.HeapStatsUpdate, this.profileSamples);
+    }
     const profile = this.profileBeingRecorded();
     if (profile) {
       profile.updateStatus(null, true);
@@ -1445,7 +1463,7 @@ export class TrackingHeapSnapshotProfileType extends HeapSnapshotProfileType {
     this.recording = true;
     this.addProfile((this.profileBeingRecorded() as ProfileHeader));
     (this.profileBeingRecorded() as HeapProfileHeader).updateStatus(i18nString(UIStrings.recording));
-    this.dispatchEventToListeners(TrackingHeapSnapshotProfileType.TrackingStarted);
+    this.dispatchEventToListeners(TrackingHeapSnapshotProfileTypeEvents.TrackingStarted);
     return heapProfilerModel;
   }
 
@@ -1455,7 +1473,7 @@ export class TrackingHeapSnapshotProfileType extends HeapSnapshotProfileType {
     const stopPromise =
         (profile.heapProfilerModel() as SDK.HeapProfilerModel.HeapProfilerModel).stopTrackingHeapObjects(true);
     this.recording = false;
-    this.dispatchEventToListeners(TrackingHeapSnapshotProfileType.TrackingStopped);
+    this.dispatchEventToListeners(TrackingHeapSnapshotProfileTypeEvents.TrackingStopped);
     await stopPromise;
     profile = (this.profileBeingRecorded() as HeapProfileHeader);
     if (!profile) {
@@ -1506,6 +1524,7 @@ export class TrackingHeapSnapshotProfileType extends HeapSnapshotProfileType {
 
   // eslint-disable-next-line @typescript-eslint/naming-convention
   static readonly TypeId = 'HEAP-RECORD';
+  // TODO(crbug.com/1228674): Remove event strings once they are no longer used in web tests.
   // eslint-disable-next-line @typescript-eslint/naming-convention
   static readonly HeapStatsUpdate = 'HeapStatsUpdate';
   // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -1514,6 +1533,18 @@ export class TrackingHeapSnapshotProfileType extends HeapSnapshotProfileType {
   static readonly TrackingStopped = 'TrackingStopped';
 }
 
+export const enum TrackingHeapSnapshotProfileTypeEvents {
+  HeapStatsUpdate = 'HeapStatsUpdate',
+  TrackingStarted = 'TrackingStarted',
+  TrackingStopped = 'TrackingStopped',
+}
+
+export type TrackingHeapSnapshotProfileTypeEventTypes = {
+  [TrackingHeapSnapshotProfileTypeEvents.HeapStatsUpdate]: Samples,
+  [TrackingHeapSnapshotProfileTypeEvents.TrackingStarted]: void,
+  [TrackingHeapSnapshotProfileTypeEvents.TrackingStopped]: void,
+};
+
 export class HeapProfileHeader extends ProfileHeader {
   readonly heapProfilerModelInternal: SDK.HeapProfilerModel.HeapProfilerModel|null;
   maxJSObjectId: number;
@@ -1736,6 +1767,10 @@ export class HeapProfileHeader extends ProfileHeader {
     }
     return success ? null : reader.error();
   }
+
+  override profileType(): HeapSnapshotProfileType {
+    return super.profileType() as HeapSnapshotProfileType;
+  }
 }
 
 export class HeapSnapshotStatisticsView extends UI.Widget.VBox {

package/front_end/panels/profiler/ProfileHeader.ts

@@ -104,7 +104,7 @@ export type EventTypes = {
   [Events.ProfileTitleChanged]: ProfileHeader,
 };
 
-export abstract class ProfileType extends Common.ObjectWrapper.ObjectWrapper {
+export class ProfileType extends Common.ObjectWrapper.ObjectWrapper<ProfileEventTypes> {
   readonly idInternal: string;
   readonly nameInternal: string;
   profiles: ProfileHeader[];
@@ -212,7 +212,9 @@ export abstract class ProfileType extends Common.ObjectWrapper.ObjectWrapper {
     return profile.loadFromFile(file);
   }
 
-  abstract createProfileLoadedFromFile(title: string): ProfileHeader;
+  createProfileLoadedFromFile(_title: string): ProfileHeader {
+    throw new Error('Not implemented');
+  }
 
   addProfile(profile: ProfileHeader): void {
     this.profiles.push(profile);
@@ -272,6 +274,13 @@ export enum ProfileEvents {
   ViewUpdated = 'view-updated',
 }
 
+export type ProfileEventTypes = {
+  [ProfileEvents.AddProfileHeader]: ProfileHeader,
+  [ProfileEvents.ProfileComplete]: ProfileHeader,
+  [ProfileEvents.RemoveProfileHeader]: ProfileHeader,
+  [ProfileEvents.ViewUpdated]: void,
+};
+
 export interface DataDisplayDelegate {
   showProfile(profile: ProfileHeader|null): UI.Widget.Widget|null;
   showObject(snapshotObjectId: string, perspectiveName: string): void;

package/front_end/panels/profiler/ProfilesPanel.ts

@@ -327,16 +327,17 @@ export class ProfilesPanel extends UI.Panel.PanelWithSidebar implements DataDisp
     profileTypeSection.childrenListElement.addEventListener(
         'contextmenu', this.handleContextMenuEvent.bind(this), false);
 
-    function onAddProfileHeader(this: ProfilesPanel, event: Common.EventTarget.EventTargetEvent): void {
-      this.addProfileHeader((event.data as ProfileHeader));
+    function onAddProfileHeader(this: ProfilesPanel, event: Common.EventTarget.EventTargetEvent<ProfileHeader>): void {
+      this.addProfileHeader(event.data);
     }
 
-    function onRemoveProfileHeader(this: ProfilesPanel, event: Common.EventTarget.EventTargetEvent): void {
-      this.removeProfileHeader((event.data as ProfileHeader));
+    function onRemoveProfileHeader(
+        this: ProfilesPanel, event: Common.EventTarget.EventTargetEvent<ProfileHeader>): void {
+      this.removeProfileHeader(event.data);
     }
 
-    function profileComplete(this: ProfilesPanel, event: Common.EventTarget.EventTargetEvent): void {
-      this.showProfile((event.data as ProfileHeader));
+    function profileComplete(this: ProfilesPanel, event: Common.EventTarget.EventTargetEvent<ProfileHeader>): void {
+      this.showProfile(event.data);
     }
 
     profileType.addEventListener(ProfileTypeEvents.ViewUpdated, this.updateProfileTypeSpecificUI, this);

package/front_end/panels/sources/SourcesPanel.ts

@@ -363,8 +363,7 @@ export class SourcesPanel extends UI.Panel.Panel implements UI.ContextMenu.Provi
     }
   }
 
-  private onCurrentTargetChanged(event: Common.EventTarget.EventTargetEvent): void {
-    const target = (event.data as SDK.Target.Target | null);
+  private onCurrentTargetChanged({data: target}: Common.EventTarget.EventTargetEvent<SDK.Target.Target|null>): void {
     this.setTarget(target);
   }
   paused(): boolean {

package/front_end/panels/sources/ThreadsSidebarPane.ts

@@ -134,9 +134,8 @@ export class ThreadsSidebarPane extends UI.Widget.VBox implements
     this.items.remove(this.items.indexOf(debuggerModel));
   }
 
-  private targetFlavorChanged(event: Common.EventTarget.EventTargetEvent): void {
+  private targetFlavorChanged({data: target}: Common.EventTarget.EventTargetEvent<SDK.Target.Target>): void {
     const hadFocus = this.hasFocus();
-    const target = (event.data as SDK.Target.Target);
     const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
     this.list.selectItem(debuggerModel);
     if (debuggerModel) {

package/front_end/panels/timeline/TimelineUIUtils.ts

@@ -3605,7 +3605,7 @@ export class EventDispatchTypeDescriptor {
   }
 }
 
-export class TimelineCategory extends Common.ObjectWrapper.ObjectWrapper {
+export class TimelineCategory {
   name: string;
   title: string;
   visible: boolean;
@@ -3614,7 +3614,6 @@ export class TimelineCategory extends Common.ObjectWrapper.ObjectWrapper {
   private hiddenInternal?: boolean;
 
   constructor(name: string, title: string, visible: boolean, childColor: string, color: string) {
-    super();
     this.name = name;
     this.title = title;
     this.visible = visible;

package/front_end/panels/web_audio/WebAudioModel.ts

@@ -6,7 +6,7 @@ import * as SDK from '../../core/sdk/sdk.js';
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import type * as Protocol from '../../generated/protocol.js';
 
-export class WebAudioModel extends SDK.SDKModel.SDKModel implements ProtocolProxyApi.WebAudioDispatcher {
+export class WebAudioModel extends SDK.SDKModel.SDKModel<EventTypes> implements ProtocolProxyApi.WebAudioDispatcher {
   private enabled: boolean;
   private readonly agent: ProtocolProxyApi.WebAudioApi;
   constructor(target: SDK.Target.Target) {
@@ -138,3 +138,21 @@ export const enum Events {
   NodeParamConnected = 'NodeParamConnected',
   NodeParamDisconnected = 'NodeParamDisconnected',
 }
+
+export type EventTypes = {
+  [Events.ContextCreated]: Protocol.WebAudio.BaseAudioContext,
+  [Events.ContextDestroyed]: Protocol.WebAudio.GraphObjectId,
+  [Events.ContextChanged]: Protocol.WebAudio.BaseAudioContext,
+  [Events.ModelReset]: void,
+  [Events.ModelSuspend]: void,
+  [Events.AudioListenerCreated]: Protocol.WebAudio.AudioListener,
+  [Events.AudioListenerWillBeDestroyed]: Protocol.WebAudio.AudioListenerWillBeDestroyedEvent,
+  [Events.AudioNodeCreated]: Protocol.WebAudio.AudioNode,
+  [Events.AudioNodeWillBeDestroyed]: Protocol.WebAudio.AudioNodeWillBeDestroyedEvent,
+  [Events.AudioParamCreated]: Protocol.WebAudio.AudioParam,
+  [Events.AudioParamWillBeDestroyed]: Protocol.WebAudio.AudioParamWillBeDestroyedEvent,
+  [Events.NodesConnected]: Protocol.WebAudio.NodesConnectedEvent,
+  [Events.NodesDisconnected]: Protocol.WebAudio.NodesDisconnectedEvent,
+  [Events.NodeParamConnected]: Protocol.WebAudio.NodeParamConnectedEvent,
+  [Events.NodeParamDisconnected]: Protocol.WebAudio.NodeParamDisconnectedEvent,
+};

package/front_end/panels/web_audio/WebAudioView.ts

@@ -154,20 +154,20 @@ export class WebAudioView extends UI.ThrottledWidget.ThrottledWidget implements
     webAudioModel.removeEventListener(ModelEvents.NodeParamDisconnected, this.nodeParamDisconnected, this);
   }
 
-  private contextCreated(event: Common.EventTarget.EventTargetEvent): void {
-    const context = (event.data as Protocol.WebAudio.BaseAudioContext);
+  private contextCreated(event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.BaseAudioContext>): void {
+    const context = event.data;
     this.graphManager.createContext(context.contextId);
     this.contextSelector.contextCreated(event);
   }
 
-  private contextDestroyed(event: Common.EventTarget.EventTargetEvent): void {
-    const contextId = (event.data as string);
+  private contextDestroyed(event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.GraphObjectId>): void {
+    const contextId = event.data;
     this.graphManager.destroyContext(contextId);
     this.contextSelector.contextDestroyed(event);
   }
 
-  private contextChanged(event: Common.EventTarget.EventTargetEvent): void {
-    const context = (event.data as Protocol.WebAudio.BaseAudioContext);
+  private contextChanged(event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.BaseAudioContext>): void {
+    const context = event.data;
     if (!this.graphManager.hasContext(context.contextId)) {
       return;
     }
@@ -189,8 +189,8 @@ export class WebAudioView extends UI.ThrottledWidget.ThrottledWidget implements
     this.graphManager.clearGraphs();
   }
 
-  private audioListenerCreated(event: Common.EventTarget.EventTargetEvent): void {
-    const listener = (event.data as Protocol.WebAudio.AudioListener);
+  private audioListenerCreated(event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.AudioListener>): void {
+    const listener = event.data;
     const graph = this.graphManager.getGraph(listener.contextId);
     if (!graph) {
       return;
@@ -203,7 +203,8 @@ export class WebAudioView extends UI.ThrottledWidget.ThrottledWidget implements
     });
   }
 
-  private audioListenerWillBeDestroyed(event: Common.EventTarget.EventTargetEvent): void {
+  private audioListenerWillBeDestroyed(
+      event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.AudioListenerWillBeDestroyedEvent>): void {
     const {contextId, listenerId} = event.data;
     const graph = this.graphManager.getGraph(contextId);
     if (!graph) {
@@ -212,8 +213,8 @@ export class WebAudioView extends UI.ThrottledWidget.ThrottledWidget implements
     graph.removeNode(listenerId);
   }
 
-  private audioNodeCreated(event: Common.EventTarget.EventTargetEvent): void {
-    const node = (event.data as Protocol.WebAudio.AudioNode);
+  private audioNodeCreated(event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.AudioNode>): void {
+    const node = event.data;
     const graph = this.graphManager.getGraph(node.contextId);
     if (!graph) {
       return;
@@ -226,7 +227,8 @@ export class WebAudioView extends UI.ThrottledWidget.ThrottledWidget implements
     });
   }
 
-  private audioNodeWillBeDestroyed(event: Common.EventTarget.EventTargetEvent): void {
+  private audioNodeWillBeDestroyed(
+      event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.AudioNodeWillBeDestroyedEvent>): void {
     const {contextId, nodeId} = event.data;
     const graph = this.graphManager.getGraph(contextId);
     if (!graph) {
@@ -235,8 +237,8 @@ export class WebAudioView extends UI.ThrottledWidget.ThrottledWidget implements
     graph.removeNode(nodeId);
   }
 
-  private audioParamCreated(event: Common.EventTarget.EventTargetEvent): void {
-    const param = (event.data as Protocol.WebAudio.AudioParam);
+  private audioParamCreated(event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.AudioParam>): void {
+    const param = event.data;
     const graph = this.graphManager.getGraph(param.contextId);
     if (!graph) {
       return;
@@ -248,7 +250,8 @@ export class WebAudioView extends UI.ThrottledWidget.ThrottledWidget implements
     });
   }
 
-  private audioParamWillBeDestroyed(event: Common.EventTarget.EventTargetEvent): void {
+  private audioParamWillBeDestroyed(
+      event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.AudioParamWillBeDestroyedEvent>): void {
     const {contextId, paramId} = event.data;
     const graph = this.graphManager.getGraph(contextId);
     if (!graph) {
@@ -257,7 +260,7 @@ export class WebAudioView extends UI.ThrottledWidget.ThrottledWidget implements
     graph.removeParam(paramId);
   }
 
-  private nodesConnected(event: Common.EventTarget.EventTargetEvent): void {
+  private nodesConnected(event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.NodesConnectedEvent>): void {
     const {contextId, sourceId, destinationId, sourceOutputIndex, destinationInputIndex} = event.data;
     const graph = this.graphManager.getGraph(contextId);
     if (!graph) {
@@ -271,7 +274,8 @@ export class WebAudioView extends UI.ThrottledWidget.ThrottledWidget implements
     });
   }
 
-  private nodesDisconnected(event: Common.EventTarget.EventTargetEvent): void {
+  private nodesDisconnected(event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.NodesDisconnectedEvent>):
+      void {
     const {contextId, sourceId, destinationId, sourceOutputIndex, destinationInputIndex} = event.data;
     const graph = this.graphManager.getGraph(contextId);
     if (!graph) {
@@ -285,7 +289,8 @@ export class WebAudioView extends UI.ThrottledWidget.ThrottledWidget implements
     });
   }
 
-  private nodeParamConnected(event: Common.EventTarget.EventTargetEvent): void {
+  private nodeParamConnected(event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.NodeParamConnectedEvent>):
+      void {
     const {contextId, sourceId, destinationId, sourceOutputIndex} = event.data;
     const graph = this.graphManager.getGraph(contextId);
     if (!graph) {
@@ -305,7 +310,8 @@ export class WebAudioView extends UI.ThrottledWidget.ThrottledWidget implements
     });
   }
 
-  private nodeParamDisconnected(event: Common.EventTarget.EventTargetEvent): void {
+  private nodeParamDisconnected(
+      event: Common.EventTarget.EventTargetEvent<Protocol.WebAudio.NodeParamDisconnectedEvent>): void {
     const {contextId, sourceId, destinationId, sourceOutputIndex} = event.data;
     const graph = this.graphManager.getGraph(contextId);
     if (!graph) {