chrome-devtools-frontend 1.0.923319 → 1.0.925171

package/front_end/panels/layers/LayersPanel.ts

@@ -169,11 +169,10 @@ export class LayersPanel extends UI.Panel.PanelWithSidebar implements SDK.Target
     return Promise.resolve();
   }
 
-  private onLayerPainted(event: Common.EventTarget.EventTargetEvent): void {
+  private onLayerPainted({data: layer}: Common.EventTarget.EventTargetEvent<SDK.LayerTreeBase.Layer>): void {
     if (!this.model) {
       return;
     }
-    const layer = event.data as SDK.LayerTreeBase.Layer;
     const selection = this.layerViewHost.selection();
     if (selection && selection.layer() === layer) {
       this.layerDetailsView.update();
@@ -212,8 +211,8 @@ export class LayersPanel extends UI.Panel.PanelWithSidebar implements SDK.Target
     }
   }
 
-  private onScaleChanged(event: Common.EventTarget.EventTargetEvent): void {
-    this.paintProfilerView.setScale(event.data as number);
+  private onScaleChanged(event: Common.EventTarget.EventTargetEvent<number>): void {
+    this.paintProfilerView.setScale(event.data);
   }
 }
 

package/front_end/panels/lighthouse/LighthouseReportRenderer.ts

@@ -160,6 +160,7 @@ export class LighthouseReportUIFeatures extends LighthouseReport.ReportUIFeature
     super(dom);
     this.beforePrint = null;
     this.afterPrint = null;
+    this._topbar._print = this._print.bind(this);
   }
 
   setBeforePrint(beforePrint: (() => void)|null): void {

package/front_end/panels/media/MainView.ts

@@ -8,7 +8,7 @@ import * as UI from '../../ui/legacy/legacy.js';
 import type * as Protocol from '../../generated/protocol.js';
 
 import type {PlayerEvent} from './MediaModel.js';
-import {MediaModel, ProtocolTriggers} from './MediaModel.js';
+import {MediaModel, Events} from './MediaModel.js';
 import {PlayerDetailView} from './PlayerDetailView.js';
 import {PlayerListView} from './PlayerListView.js';
 
@@ -196,19 +196,19 @@ export class MainView extends UI.Panel.PanelWithSidebar implements SDK.TargetMan
 
   private addEventListeners(mediaModel: MediaModel): void {
     mediaModel.ensureEnabled();
-    mediaModel.addEventListener(ProtocolTriggers.PlayerPropertiesChanged, this.propertiesChanged, this);
-    mediaModel.addEventListener(ProtocolTriggers.PlayerEventsAdded, this.eventsAdded, this);
-    mediaModel.addEventListener(ProtocolTriggers.PlayerMessagesLogged, this.messagesLogged, this);
-    mediaModel.addEventListener(ProtocolTriggers.PlayerErrorsRaised, this.errorsRaised, this);
-    mediaModel.addEventListener(ProtocolTriggers.PlayersCreated, this.playersCreated, this);
+    mediaModel.addEventListener(Events.PlayerPropertiesChanged, this.propertiesChanged, this);
+    mediaModel.addEventListener(Events.PlayerEventsAdded, this.eventsAdded, this);
+    mediaModel.addEventListener(Events.PlayerMessagesLogged, this.messagesLogged, this);
+    mediaModel.addEventListener(Events.PlayerErrorsRaised, this.errorsRaised, this);
+    mediaModel.addEventListener(Events.PlayersCreated, this.playersCreated, this);
   }
 
   private removeEventListeners(mediaModel: MediaModel): void {
-    mediaModel.removeEventListener(ProtocolTriggers.PlayerPropertiesChanged, this.propertiesChanged, this);
-    mediaModel.removeEventListener(ProtocolTriggers.PlayerEventsAdded, this.eventsAdded, this);
-    mediaModel.removeEventListener(ProtocolTriggers.PlayerMessagesLogged, this.messagesLogged, this);
-    mediaModel.removeEventListener(ProtocolTriggers.PlayerErrorsRaised, this.errorsRaised, this);
-    mediaModel.removeEventListener(ProtocolTriggers.PlayersCreated, this.playersCreated, this);
+    mediaModel.removeEventListener(Events.PlayerPropertiesChanged, this.propertiesChanged, this);
+    mediaModel.removeEventListener(Events.PlayerEventsAdded, this.eventsAdded, this);
+    mediaModel.removeEventListener(Events.PlayerMessagesLogged, this.messagesLogged, this);
+    mediaModel.removeEventListener(Events.PlayerErrorsRaised, this.errorsRaised, this);
+    mediaModel.removeEventListener(Events.PlayersCreated, this.playersCreated, this);
   }
 
   private onPlayerCreated(playerID: string): void {
@@ -217,25 +217,29 @@ export class MainView extends UI.Panel.PanelWithSidebar implements SDK.TargetMan
     this.downloadStore.addPlayer(playerID);
   }
 
-  private propertiesChanged(event: Common.EventTarget.EventTargetEvent): void {
+  private propertiesChanged(event: Common.EventTarget.EventTargetEvent<Protocol.Media.PlayerPropertiesChangedEvent>):
+      void {
     for (const property of event.data.properties) {
       this.onProperty(event.data.playerId, property);
     }
   }
 
-  private eventsAdded(event: Common.EventTarget.EventTargetEvent): void {
+  private eventsAdded(event: Common.EventTarget.EventTargetEvent<Protocol.Media.PlayerEventsAddedEvent>): void {
     for (const ev of event.data.events) {
-      this.onEvent(event.data.playerId, ev);
+      // TODO(crbug.com/1228674): The conversion from Protocol.Media.PlayerEvent to PlayerEvent happens implicitly
+      // by augmenting the protocol type with some additional property in various places. This needs to be cleaned up
+      // in a conversion function that takes the protocol type and produces the PlayerEvent type.
+      this.onEvent(event.data.playerId, ev as PlayerEvent);
     }
   }
 
-  private messagesLogged(event: Common.EventTarget.EventTargetEvent): void {
+  private messagesLogged(event: Common.EventTarget.EventTargetEvent<Protocol.Media.PlayerMessagesLoggedEvent>): void {
     for (const message of event.data.messages) {
       this.onMessage(event.data.playerId, message);
     }
   }
 
-  private errorsRaised(event: Common.EventTarget.EventTargetEvent): void {
+  private errorsRaised(event: Common.EventTarget.EventTargetEvent<Protocol.Media.PlayerErrorsRaisedEvent>): void {
     for (const error of event.data.errors) {
       this.onError(event.data.playerId, error);
     }
@@ -281,9 +285,8 @@ export class MainView extends UI.Panel.PanelWithSidebar implements SDK.TargetMan
     this.detailPanels.get(playerID)?.onEvent(event);
   }
 
-  private playersCreated(event: Common.EventTarget.EventTargetEvent): void {
-    const playerlist = event.data as Iterable<string>;
-    for (const playerID of playerlist) {
+  private playersCreated(event: Common.EventTarget.EventTargetEvent<Protocol.Media.PlayerId[]>): void {
+    for (const playerID of event.data) {
       this.onPlayerCreated(playerID);
     }
   }

package/front_end/panels/media/MediaModel.ts

@@ -12,7 +12,7 @@ export interface PlayerEvent extends Protocol.Media.PlayerEvent {
   event: string;
 }
 
-export const enum ProtocolTriggers {
+export const enum Events {
   PlayerPropertiesChanged = 'PlayerPropertiesChanged',
   PlayerEventsAdded = 'PlayerEventsAdded',
   PlayerMessagesLogged = 'PlayerMessagesLogged',
@@ -20,7 +20,15 @@ export const enum ProtocolTriggers {
   PlayersCreated = 'PlayersCreated',
 }
 
-export class MediaModel extends SDK.SDKModel.SDKModel implements ProtocolProxyApi.MediaDispatcher {
+export type EventTypes = {
+  [Events.PlayerPropertiesChanged]: Protocol.Media.PlayerPropertiesChangedEvent,
+  [Events.PlayerEventsAdded]: Protocol.Media.PlayerEventsAddedEvent,
+  [Events.PlayerMessagesLogged]: Protocol.Media.PlayerMessagesLoggedEvent,
+  [Events.PlayerErrorsRaised]: Protocol.Media.PlayerErrorsRaisedEvent,
+  [Events.PlayersCreated]: Protocol.Media.PlayerId[],
+};
+
+export class MediaModel extends SDK.SDKModel.SDKModel<EventTypes> implements ProtocolProxyApi.MediaDispatcher {
   private enabled: boolean;
   private readonly agent: ProtocolProxyApi.MediaApi;
 
@@ -46,23 +54,23 @@ export class MediaModel extends SDK.SDKModel.SDKModel implements ProtocolProxyAp
   }
 
   playerPropertiesChanged(event: Protocol.Media.PlayerPropertiesChangedEvent): void {
-    this.dispatchEventToListeners(ProtocolTriggers.PlayerPropertiesChanged, event);
+    this.dispatchEventToListeners(Events.PlayerPropertiesChanged, event);
   }
 
   playerEventsAdded(event: Protocol.Media.PlayerEventsAddedEvent): void {
-    this.dispatchEventToListeners(ProtocolTriggers.PlayerEventsAdded, event);
+    this.dispatchEventToListeners(Events.PlayerEventsAdded, event);
   }
 
   playerMessagesLogged(event: Protocol.Media.PlayerMessagesLoggedEvent): void {
-    this.dispatchEventToListeners(ProtocolTriggers.PlayerMessagesLogged, event);
+    this.dispatchEventToListeners(Events.PlayerMessagesLogged, event);
   }
 
   playerErrorsRaised(event: Protocol.Media.PlayerErrorsRaisedEvent): void {
-    this.dispatchEventToListeners(ProtocolTriggers.PlayerErrorsRaised, event);
+    this.dispatchEventToListeners(Events.PlayerErrorsRaised, event);
   }
 
   playersCreated({players}: Protocol.Media.PlayersCreatedEvent): void {
-    this.dispatchEventToListeners(ProtocolTriggers.PlayersCreated, players);
+    this.dispatchEventToListeners(Events.PlayersCreated, players);
   }
 }
 SDK.SDKModel.SDKModel.register(MediaModel, {capabilities: SDK.Target.Capability.Media, autostart: false});

package/front_end/panels/media/PlayerMessagesView.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 * as Common from '../../core/common/common.js';
+import type * as Common from '../../core/common/common.js';
 import * as i18n from '../../core/i18n/i18n.js';
 import * as UI from '../../ui/legacy/legacy.js';
 
@@ -70,8 +70,7 @@ interface SelectableLevel {
   overwrite?: boolean;
 }
 
-class MessageLevelSelector extends Common.ObjectWrapper.ObjectWrapper implements
-    UI.SoftDropDown.Delegate<SelectableLevel> {
+class MessageLevelSelector implements UI.SoftDropDown.Delegate<SelectableLevel> {
   private readonly items: UI.ListModel.ListModel<SelectableLevel>;
   private readonly view: PlayerMessagesView;
   private readonly itemMap: Map<number, SelectableLevel>;
@@ -84,7 +83,6 @@ class MessageLevelSelector extends Common.ObjectWrapper.ObjectWrapper implements
   elementsForItems: WeakMap<SelectableLevel, HTMLElement>;
 
   constructor(items: UI.ListModel.ListModel<SelectableLevel>, view: PlayerMessagesView) {
-    super();
     this.items = items;
     this.view = view;
     this.itemMap = new Map();

package/front_end/panels/network/NetworkPanel.ts

@@ -377,7 +377,7 @@ export class NetworkPanel extends UI.Panel.Panel implements UI.ContextMenu.Provi
     this.networkLogView.setWindow(startTime, endTime);
   }
 
-  private async searchToggleClick(_event: Common.EventTarget.EventTargetEvent): Promise<void> {
+  private async searchToggleClick(): Promise<void> {
     const action = UI.ActionRegistry.ActionRegistry.instance().action('network.search');
     if (action) {
       await action.execute();
@@ -403,8 +403,8 @@ export class NetworkPanel extends UI.Panel.Panel implements UI.ContextMenu.Provi
     this.panelToolbar.appendToolbarItem(this.filterBar.filterButton());
     updateSidebarToggle();
     splitWidget.addEventListener(UI.SplitWidget.Events.ShowModeChanged, updateSidebarToggle);
-    searchToggle.addEventListener(UI.Toolbar.ToolbarButton.Events.Click, event => {
-      this.searchToggleClick(event);
+    searchToggle.addEventListener(UI.Toolbar.ToolbarButton.Events.Click, () => {
+      this.searchToggleClick();
     });
     this.panelToolbar.appendToolbarItem(searchToggle);
     this.panelToolbar.appendSeparator();
@@ -640,12 +640,12 @@ export class NetworkPanel extends UI.Panel.Panel implements UI.ContextMenu.Provi
     this.hideRequestPanel();
   }
 
-  private onRowSizeChanged(_event: Common.EventTarget.EventTargetEvent): void {
+  private onRowSizeChanged(): void {
     this.updateUI();
   }
 
-  private onRequestSelected(event: Common.EventTarget.EventTargetEvent): void {
-    const request = (event.data as SDK.NetworkRequest.NetworkRequest | null);
+  private onRequestSelected(event: Common.EventTarget.EventTargetEvent<SDK.NetworkRequest.NetworkRequest|null>): void {
+    const request = event.data;
     this.currentRequest = request;
     this.networkOverview.setHighlightedRequest(request);
     this.updateNetworkItemView();

package/front_end/panels/network/RequestHeadersView.ts

@@ -120,6 +120,10 @@ const UIStrings = {
   */
   fromDiskCache: '(from disk cache)',
   /**
+  *@description Text in Request Headers View of the Network panel
+  */
+  fromWebBundle: '(from Web Bundle)',
+  /**
   *@description Message to explain lack of raw headers for a particular network request
   */
   provisionalHeadersAreShownS: 'Provisional headers are shown. Disable cache to see full headers.',
@@ -513,6 +517,9 @@ export class RequestHeadersView extends UI.Widget.VBox {
       } else if (this.request.redirectSourceSignedExchangeInfoHasNoErrors()) {
         statusText += ' ' + i18nString(UIStrings.fromSignedexchange);
         statusTextElement.classList.add('status-from-cache');
+      } else if (this.request.webBundleInnerRequestInfo()) {
+        statusText += ' ' + i18nString(UIStrings.fromWebBundle);
+        statusTextElement.classList.add('status-from-cache');
       } else if (this.request.fromPrefetchCache()) {
         statusText += ' ' + i18nString(UIStrings.fromPrefetchCache);
         statusTextElement.classList.add('status-from-cache');

package/front_end/panels/network/networkLogView.css

@@ -243,6 +243,11 @@
   filter: brightness(0) invert(1);
 }
 
+.network-log-grid.data-grid:focus .data-grid-data-grid-node.selected [is=ui-icon].icon-mask {
+  --network-grid-selected-color: #dadce0;
+  --override-icon-mask-background-color: var(--network-grid-selected-color);
+}
+
 .network-log-grid.data-grid .network-error-row.data-grid-data-grid-node img.icon,
 .network-log-grid.data-grid .network-error-row.data-grid-data-grid-node.selected img.icon {
   /* This is generated with https://codepen.io/sosuke/pen/Pjoqqp to target var(--color-red) */

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[];
@@ -186,7 +186,7 @@ export class HeapProfileView extends ProfileView implements UI.SearchableView.Se
     this.setProfile(profile);
   }
 
-  onStatsUpdate(event: Common.EventTarget.EventTargetEvent): void {
+  onStatsUpdate(event: Common.EventTarget.EventTargetEvent<Protocol.HeapProfiler.SamplingHeapProfile|null>): void {
     const profile = event.data;
 
     if (!this.totalTime) {
@@ -202,7 +202,7 @@ export class HeapProfileView extends ProfileView implements UI.SearchableView.Se
     this.sizes.push(0);
     this.timestamps.push(Date.now());
     this.ordinals.push(this.lastOrdinal + 1);
-    for (const sample of profile.samples) {
+    for (const sample of profile?.samples ?? []) {
       this.lastOrdinal = Math.max(this.lastOrdinal, sample.ordinal);
       const bucket = Platform.ArrayUtilities.upperBound(
                          this.ordinals, sample.ordinal, Platform.ArrayUtilities.DEFAULT_COMPARATOR) -
@@ -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/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;
@@ -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);
     }
   }
 
@@ -958,20 +959,20 @@ export class HeapSnapshotView extends UI.View.SimpleView implements DataDisplayD
     this.updateFilterOptions();
   }
 
-  onReceiveSnapshot(event: Common.EventTarget.EventTargetEvent): void {
+  onReceiveSnapshot(event: Common.EventTarget.EventTargetEvent<ProfileHeader>): void {
     this.updateControls();
     const profile = event.data;
     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();
@@ -1165,8 +1166,9 @@ export class StatisticsPerspective extends Perspective {
   }
 }
 
-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;
@@ -1316,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;
@@ -1383,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);
@@ -1448,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;
   }
 
@@ -1458,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) {
@@ -1491,7 +1506,7 @@ export class TrackingHeapSnapshotProfileType extends HeapSnapshotProfileType {
     return i18nString(UIStrings.AllocationTimelinesShowInstrumented);
   }
 
-  resetProfiles(event: Common.EventTarget.EventTargetEvent): void {
+  resetProfiles(event: Common.EventTarget.EventTargetEvent<SDK.HeapProfilerModel.HeapProfilerModel>): void {
     const wasRecording = this.recording;
     // Clear current profile to avoid stopping backend.
     this.setProfileBeingRecorded(null);
@@ -1509,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
@@ -1517,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;
@@ -1739,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/LiveHeapProfileView.ts

@@ -183,8 +183,8 @@ export class LiveHeapProfileView extends UI.Widget.VBox {
     this.setting.removeChangeListener(this.settingChanged, this);
   }
 
-  settingChanged(value: Common.EventTarget.EventTargetEvent): void {
-    this.toggleRecordButton.setToggled((value.data as boolean));
+  settingChanged(value: Common.EventTarget.EventTargetEvent<boolean>): void {
+    this.toggleRecordButton.setToggled(value.data);
   }
 
   async poll(): Promise<void> {

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/ProfileView.ts

@@ -480,7 +480,7 @@ export class ProfileView extends UI.View.SimpleView implements UI.SearchableView
     this.excludeButton.setEnabled(selected);
   }
 
-  focusClicked(_event: Common.EventTarget.EventTargetEvent): void {
+  focusClicked(): void {
     if (!this.dataGrid.selectedNode) {
       return;
     }
@@ -495,7 +495,7 @@ export class ProfileView extends UI.View.SimpleView implements UI.SearchableView
     Host.userMetrics.actionTaken(Host.UserMetrics.Action.CpuProfileNodeFocused);
   }
 
-  excludeClicked(_event: Common.EventTarget.EventTargetEvent): void {
+  excludeClicked(): void {
     const selectedNode = this.dataGrid.selectedNode;
 
     if (!selectedNode) {
@@ -515,7 +515,7 @@ export class ProfileView extends UI.View.SimpleView implements UI.SearchableView
     Host.userMetrics.actionTaken(Host.UserMetrics.Action.CpuProfileNodeExcluded);
   }
 
-  resetClicked(_event: Common.EventTarget.EventTargetEvent): void {
+  resetClicked(): void {
     this.viewSelectComboBox.selectElement().focus();
     this.resetButton.setEnabled(false);
     if (this.profileDataGridTree) {

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/screencast/InputModel.ts

@@ -6,7 +6,7 @@ import * as SDK from '../../core/sdk/sdk.js';
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import * as Protocol from '../../generated/protocol.js';
 
-export class InputModel extends SDK.SDKModel.SDKModel {
+export class InputModel extends SDK.SDKModel.SDKModel<void> {
   private readonly inputAgent: ProtocolProxyApi.InputApi;
   private activeTouchOffsetTop: number|null;
   private activeTouchParams: Protocol.Input.EmulateTouchFromMouseEventRequest|null;

package/front_end/panels/screencast/ScreencastView.ts

@@ -277,7 +277,7 @@ export class ScreencastView extends UI.Widget.VBox implements SDK.OverlayModel.H
     this.updateGlasspane();
   }
 
-  private onSuspendStateChange(_event: Common.EventTarget.EventTargetEvent): void {
+  private onSuspendStateChange(): void {
     if (SDK.TargetManager.TargetManager.instance().allTargetsSuspended()) {
       this.stopCasting();
     } else {