chrome-devtools-frontend 1.0.1506453 → 1.0.1510180

package/front_end/models/trace/handlers/FlowsHandler.ts

@@ -24,7 +24,7 @@ import * as Types from '../types/types.js';
 // flows with the timestamps of each phase. Then, we place trace events
 // in the flows where their corresponding phase events were placed (if
 // there are any corresponding flow phase events at all).
-const flowDataByGroupToken = new Map<string, number>();
+let flowDataByGroupToken = new Map<string, number>();
 
 interface EventFlowData {
   flows: Set<number>;
@@ -43,20 +43,20 @@ type FlowBindingTuple =
 // every event in a trace, resulting in a lot of memory overhead and
 // major GC triggering. So we are trading off readability for
 // performance.
-const boundFlowData: FlowBindingTuple = new Map();
+let boundFlowData: FlowBindingTuple = new Map();
 
-const flowsById = new Map<number, Map<Types.Timing.Micro, Types.Events.Event>>();
-const flowEvents: Types.Events.FlowEvent[] = [];
-const nonFlowEvents: Types.Events.Event[] = [];
+let flowsById = new Map<number, Map<Types.Timing.Micro, Types.Events.Event>>();
+let flowEvents: Types.Events.FlowEvent[] = [];
+let nonFlowEvents: Types.Events.Event[] = [];
 let flows: Types.Events.Event[][] = [];
 const ID_COMPONENT_SEPARATOR = '-$-';
 export function reset(): void {
   flows = [];
-  flowEvents.length = 0;
-  nonFlowEvents.length = 0;
-  flowDataByGroupToken.clear();
-  boundFlowData.clear();
-  flowsById.clear();
+  flowEvents = [];
+  nonFlowEvents = [];
+  flowDataByGroupToken = new Map();
+  boundFlowData = new Map();
+  flowsById = new Map();
 }
 
 export function handleEvent(event: Types.Events.Event): void {

package/front_end/models/trace/handlers/FramesHandler.ts

@@ -25,7 +25,7 @@ import type {HandlerName} from './types.js';
  */
 
 let model: TimelineFrameModel|null = null;
-const relevantFrameEvents: Types.Events.Event[] = [];
+let relevantFrameEvents: Types.Events.Event[] = [];
 
 type FrameEvent = Types.Events.BeginFrame|Types.Events.DroppedFrame|Types.Events.RequestMainThreadFrame|
                   Types.Events.BeginMainThreadFrame|Types.Events.Commit|Types.Events.CompositeLayers|
@@ -58,7 +58,7 @@ const MAIN_FRAME_MARKERS = new Set<Types.Events.Name>([
 
 export function reset(): void {
   model = null;
-  relevantFrameEvents.length = 0;
+  relevantFrameEvents = [];
 }
 export function handleEvent(event: Types.Events.Event): void {
   // This might seem like a wide set of events to filter for, but these are all

package/front_end/models/trace/handlers/GPUHandler.ts

@@ -10,12 +10,12 @@ import type {HandlerName} from './types.js';
 
 // Each thread contains events. Events indicate the thread and process IDs, which are
 // used to store the event in the correct process thread entry below.
-const eventsInProcessThread = new Map<Types.Events.ProcessID, Map<Types.Events.ThreadID, Types.Events.GPUTask[]>>();
+let eventsInProcessThread = new Map<Types.Events.ProcessID, Map<Types.Events.ThreadID, Types.Events.GPUTask[]>>();
 
 let mainGPUThreadTasks: Types.Events.GPUTask[] = [];
 
 export function reset(): void {
-  eventsInProcessThread.clear();
+  eventsInProcessThread = new Map();
   mainGPUThreadTasks = [];
 }
 

package/front_end/models/trace/handlers/ImagePaintingHandler.ts

@@ -25,35 +25,35 @@ import type {FinalizeOptions} from './types.js';
  */
 
 // Track paintImageEvents across threads.
-const paintImageEvents = new Map<Types.Events.ProcessID, Map<Types.Events.ThreadID, Types.Events.PaintImage[]>>();
-const decodeLazyPixelRefEvents =
+let paintImageEvents = new Map<Types.Events.ProcessID, Map<Types.Events.ThreadID, Types.Events.PaintImage[]>>();
+let decodeLazyPixelRefEvents =
     new Map<Types.Events.ProcessID, Map<Types.Events.ThreadID, Types.Events.DecodeLazyPixelRef[]>>();
 
 // A DrawLazyPixelRef event will contain a numerical reference in
 // args.LazyPixelRef. As we parse each DrawLazyPixelRef, we can assign it to a
 // paint event. Later we want to look up paint events by this reference, so we
 // store them in this map.
-const paintImageByLazyPixelRef = new Map<number, Types.Events.PaintImage>();
+let paintImageByLazyPixelRef = new Map<number, Types.Events.PaintImage>();
 
 // When we find events that we want to tie to a particular PaintImage event, we add them to this map.
 // These are currently only DecodeImage and ResizeImage events, but the type is
 // deliberately generic as in the future we might want to add more events that
 // have a relationship to a individual PaintImage event.
-const eventToPaintImage = new Map<Types.Events.Event, Types.Events.PaintImage>();
+let eventToPaintImage = new Map<Types.Events.Event, Types.Events.PaintImage>();
 
-const urlToPaintImage = new Map<string, Types.Events.PaintImage[]>();
+let urlToPaintImage = new Map<string, Types.Events.PaintImage[]>();
 
-const paintEventToCorrectedDisplaySize = new Map<Types.Events.PaintImage, {width: number, height: number}>();
+let paintEventToCorrectedDisplaySize = new Map<Types.Events.PaintImage, {width: number, height: number}>();
 
 let didCorrectForHostDpr = false;
 
 export function reset(): void {
-  paintImageEvents.clear();
-  decodeLazyPixelRefEvents.clear();
-  paintImageByLazyPixelRef.clear();
-  eventToPaintImage.clear();
-  urlToPaintImage.clear();
-  paintEventToCorrectedDisplaySize.clear();
+  paintImageEvents = new Map();
+  decodeLazyPixelRefEvents = new Map();
+  paintImageByLazyPixelRef = new Map();
+  eventToPaintImage = new Map();
+  urlToPaintImage = new Map();
+  paintEventToCorrectedDisplaySize = new Map();
   didCorrectForHostDpr = false;
 }
 

package/front_end/models/trace/handlers/InitiatorsHandler.ts

@@ -8,46 +8,44 @@ import * as Types from '../types/types.js';
 import {data as AsyncJSCallsHandlerData} from './AsyncJSCallsHandler.js';
 import {data as flowsHandlerData} from './FlowsHandler.js';
 
-const lastScheduleStyleRecalcByFrame = new Map<string, Types.Events.ScheduleStyleRecalculation>();
+let lastScheduleStyleRecalcByFrame = new Map<string, Types.Events.ScheduleStyleRecalculation>();
 
 // This tracks the last event that is considered to have invalidated the layout
 // for a given frame.
 // Note that although there is an InvalidateLayout event, there are also other
 // events (ScheduleStyleRecalculation) that could be the reason a layout was
 // invalidated.
-const lastInvalidationEventForFrame = new Map<string, Types.Events.Event>();
+let lastInvalidationEventForFrame = new Map<string, Types.Events.Event>();
 
 // Important: although the event is called UpdateLayoutTree, in the UI we
 // present these to the user as "Recalculate Style". So don't get confused!
 // These are the same - just UpdateLayoutTree is what the event from Chromium
 // is called.
-const lastUpdateLayoutTreeByFrame = new Map<string, Types.Events.UpdateLayoutTree>();
+let lastUpdateLayoutTreeByFrame = new Map<string, Types.Events.UpdateLayoutTree>();
 
 // These two maps store the same data but in different directions.
 // For a given event, tell me what its initiator was. An event can only have one initiator.
-const eventToInitiatorMap = new Map<Types.Events.Event, Types.Events.Event>();
+let eventToInitiatorMap = new Map<Types.Events.Event, Types.Events.Event>();
 // For a given event, tell me what events it initiated. An event can initiate
 // multiple events, hence why the value for this map is an array.
-const initiatorToEventsMap = new Map<Types.Events.Event, Types.Events.Event[]>();
+let initiatorToEventsMap = new Map<Types.Events.Event, Types.Events.Event[]>();
 
-const requestAnimationFrameEventsById = new Map<number, Types.Events.RequestAnimationFrame>();
-const timerInstallEventsById = new Map<number, Types.Events.TimerInstall>();
-const requestIdleCallbackEventsById = new Map<number, Types.Events.RequestIdleCallback>();
+let timerInstallEventsById = new Map<number, Types.Events.TimerInstall>();
+let requestIdleCallbackEventsById = new Map<number, Types.Events.RequestIdleCallback>();
 
-const webSocketCreateEventsById = new Map<number, Types.Events.WebSocketCreate>();
-const schedulePostTaskCallbackEventsById = new Map<number, Types.Events.SchedulePostTaskCallback>();
+let webSocketCreateEventsById = new Map<number, Types.Events.WebSocketCreate>();
+let schedulePostTaskCallbackEventsById = new Map<number, Types.Events.SchedulePostTaskCallback>();
 
 export function reset(): void {
-  lastScheduleStyleRecalcByFrame.clear();
-  lastInvalidationEventForFrame.clear();
-  lastUpdateLayoutTreeByFrame.clear();
-  timerInstallEventsById.clear();
-  eventToInitiatorMap.clear();
-  initiatorToEventsMap.clear();
-  requestAnimationFrameEventsById.clear();
-  requestIdleCallbackEventsById.clear();
-  webSocketCreateEventsById.clear();
-  schedulePostTaskCallbackEventsById.clear();
+  lastScheduleStyleRecalcByFrame = new Map();
+  lastInvalidationEventForFrame = new Map();
+  lastUpdateLayoutTreeByFrame = new Map();
+  timerInstallEventsById = new Map();
+  eventToInitiatorMap = new Map();
+  initiatorToEventsMap = new Map();
+  requestIdleCallbackEventsById = new Map();
+  webSocketCreateEventsById = new Map();
+  schedulePostTaskCallbackEventsById = new Map();
 }
 
 function storeInitiator(data: {initiator: Types.Events.Event, event: Types.Events.Event}): void {

package/front_end/models/trace/handlers/InvalidationsHandler.ts

@@ -4,21 +4,21 @@
 
 import * as Types from '../types/types.js';
 
-const invalidationsForEvent = new Map<Types.Events.Event, Types.Events.InvalidationTrackingEvent[]>();
-const invalidationCountForEvent = new Map<Types.Events.Event, number>();
+let invalidationsForEvent = new Map<Types.Events.Event, Types.Events.InvalidationTrackingEvent[]>();
+let invalidationCountForEvent = new Map<Types.Events.Event, number>();
 
 let lastRecalcStyleEvent: Types.Events.UpdateLayoutTree|null = null;
 
 // Used to track paints so we track invalidations correctly per paint.
 let hasPainted = false;
 
-const allInvalidationTrackingEvents: Types.Events.InvalidationTrackingEvent[] = [];
+let allInvalidationTrackingEvents: Types.Events.InvalidationTrackingEvent[] = [];
 
 export function reset(): void {
-  invalidationsForEvent.clear();
-  invalidationCountForEvent.clear();
+  invalidationsForEvent = new Map();
+  invalidationCountForEvent = new Map();
   lastRecalcStyleEvent = null;
-  allInvalidationTrackingEvents.length = 0;
+  allInvalidationTrackingEvents = [];
   hasPainted = false;
   maxInvalidationsPerEvent = null;
 }

package/front_end/models/trace/handlers/LargestImagePaintHandler.ts

@@ -30,12 +30,13 @@ import type {HandlerName} from './types.js';
  * `BackendNodeId`s are only unique within a given renderer process, so this is
  * also keyed on `ProcessId`.
  **/
-const imagePaintsByNodeIdAndProcess =
+let imagePaintsByNodeIdAndProcess =
     new Map<Types.Events.ProcessID, Map<Protocol.DOM.BackendNodeId, Types.Events.LargestImagePaintCandidate>>();
-const lcpRequestByNavigationId = new Map<string, Types.Events.SyntheticNetworkRequest>();
+let lcpRequestByNavigationId = new Map<string, Types.Events.SyntheticNetworkRequest>();
 
 export function reset(): void {
-  imagePaintsByNodeIdAndProcess.clear();
+  imagePaintsByNodeIdAndProcess = new Map();
+  lcpRequestByNavigationId = new Map();
 }
 
 export function handleEvent(event: Types.Events.Event): void {

package/front_end/models/trace/handlers/LargestTextPaintHandler.ts

@@ -9,10 +9,10 @@ import * as Types from '../types/types.js';
  * LargestTextPaint. If an LCP event is text, it will point to one of these
  * candidates, so we store them by their DOM Node ID.
  **/
-const textPaintByDOMNodeId = new Map<Protocol.DOM.BackendNodeId, Types.Events.LargestTextPaintCandidate>();
+let textPaintByDOMNodeId = new Map<Protocol.DOM.BackendNodeId, Types.Events.LargestTextPaintCandidate>();
 
 export function reset(): void {
-  textPaintByDOMNodeId.clear();
+  textPaintByDOMNodeId = new Map();
 }
 
 export function handleEvent(event: Types.Events.Event): void {

package/front_end/models/trace/handlers/LayerTreeHandler.ts

@@ -8,28 +8,28 @@ import * as Types from '../types/types.js';
 import {data as metaHandlerData} from './MetaHandler.js';
 import type {HandlerName} from './types.js';
 
-const paintEvents: Types.Events.Paint[] = [];
-const snapshotEvents: Types.Events.DisplayItemListSnapshot[] = [];
-const paintToSnapshotMap = new Map<Types.Events.Paint, Types.Events.DisplayItemListSnapshot>();
+let paintEvents: Types.Events.Paint[] = [];
+let snapshotEvents: Types.Events.DisplayItemListSnapshot[] = [];
+let paintToSnapshotMap = new Map<Types.Events.Paint, Types.Events.DisplayItemListSnapshot>();
 
 let lastPaintForLayerId: Record<number, Types.Events.Paint> = {};
 
 let currentMainFrameLayerTreeId: number|null = null;
-const updateLayerEvents: Types.Events.UpdateLayer[] = [];
+let updateLayerEvents: Types.Events.UpdateLayer[] = [];
 
 type RelevantLayerTreeEvent =
     Types.Events.Paint|Types.Events.DisplayItemListSnapshot|Types.Events.UpdateLayer|Types.Events.SetLayerTreeId;
 
-const relevantEvents: RelevantLayerTreeEvent[] = [];
+let relevantEvents: RelevantLayerTreeEvent[] = [];
 export function reset(): void {
-  paintEvents.length = 0;
-  snapshotEvents.length = 0;
-  paintToSnapshotMap.clear();
+  paintEvents = [];
+  snapshotEvents = [];
+  paintToSnapshotMap = new Map();
 
   lastPaintForLayerId = {};
   currentMainFrameLayerTreeId = null;
-  updateLayerEvents.length = 0;
-  relevantEvents.length = 0;
+  updateLayerEvents = [];
+  relevantEvents = [];
 }
 
 export function handleEvent(event: Types.Events.Event): void {

package/front_end/models/trace/handlers/LayoutShiftsHandler.ts

@@ -81,34 +81,34 @@ export const MAX_SHIFT_TIME_DELTA = Helpers.Timing.milliToMicro(Types.Timing.Mil
 // will be reported together. In the case of multiple renderers (frames across
 // different origins), we offer the developer the ability to switch renderer in
 // the UI.
-const layoutShiftEvents: Types.Events.LayoutShift[] = [];
+let layoutShiftEvents: Types.Events.LayoutShift[] = [];
 
 // These events denote potential node resizings. We store them to link captured
 // layout shifts to the resizing of unsized elements.
-const layoutInvalidationEvents: Types.Events.LayoutInvalidationTracking[] = [];
-const scheduleStyleInvalidationEvents: Types.Events.ScheduleStyleInvalidationTracking[] = [];
-const styleRecalcInvalidationEvents: Types.Events.StyleRecalcInvalidationTracking[] = [];
-const renderFrameImplCreateChildFrameEvents: Types.Events.RenderFrameImplCreateChildFrame[] = [];
-const domLoadingEvents: Types.Events.DomLoading[] = [];
-const layoutImageUnsizedEvents: Types.Events.LayoutImageUnsized[] = [];
-const remoteFonts: RemoteFont[] = [];
+let layoutInvalidationEvents: Types.Events.LayoutInvalidationTracking[] = [];
+let scheduleStyleInvalidationEvents: Types.Events.ScheduleStyleInvalidationTracking[] = [];
+let styleRecalcInvalidationEvents: Types.Events.StyleRecalcInvalidationTracking[] = [];
+let renderFrameImplCreateChildFrameEvents: Types.Events.RenderFrameImplCreateChildFrame[] = [];
+let domLoadingEvents: Types.Events.DomLoading[] = [];
+let layoutImageUnsizedEvents: Types.Events.LayoutImageUnsized[] = [];
+let remoteFonts: RemoteFont[] = [];
 
-const backendNodeIds = new Set<Protocol.DOM.BackendNodeId>();
+let backendNodeIds = new Set<Protocol.DOM.BackendNodeId>();
 
 // Layout shifts happen during PrePaint as part of the rendering lifecycle.
 // We determine if a LayoutInvalidation event is a potential root cause of a layout
 // shift if the next PrePaint after the LayoutInvalidation is the parent
 // node of such shift.
-const prePaintEvents: Types.Events.PrePaint[] = [];
+let prePaintEvents: Types.Events.PrePaint[] = [];
 
-const paintImageEvents: Types.Events.PaintImage[] = [];
+let paintImageEvents: Types.Events.PaintImage[] = [];
 
 let sessionMaxScore = 0;
 
 let clsWindowID = -1;
 
-const clusters: Types.Events.SyntheticLayoutShiftCluster[] = [];
-const clustersByNavigationId = new Map<Types.Events.NavigationId, Types.Events.SyntheticLayoutShiftCluster[]>();
+let clusters: Types.Events.SyntheticLayoutShiftCluster[] = [];
+let clustersByNavigationId = new Map<Types.Events.NavigationId, Types.Events.SyntheticLayoutShiftCluster[]>();
 
 // Represents a point in time in which a  LS score change
 // was recorded.
@@ -119,25 +119,25 @@ interface ScoreRecord {
 
 // The complete timeline of LS score changes in a trace.
 // Includes drops to 0 when session windows end.
-const scoreRecords: ScoreRecord[] = [];
+let scoreRecords: ScoreRecord[] = [];
 
 export function reset(): void {
-  layoutShiftEvents.length = 0;
-  layoutInvalidationEvents.length = 0;
-  scheduleStyleInvalidationEvents.length = 0;
-  styleRecalcInvalidationEvents.length = 0;
-  prePaintEvents.length = 0;
-  paintImageEvents.length = 0;
-  renderFrameImplCreateChildFrameEvents.length = 0;
-  layoutImageUnsizedEvents.length = 0;
-  domLoadingEvents.length = 0;
-  remoteFonts.length = 0;
-  backendNodeIds.clear();
-  clusters.length = 0;
+  layoutShiftEvents = [];
+  layoutInvalidationEvents = [];
+  scheduleStyleInvalidationEvents = [];
+  styleRecalcInvalidationEvents = [];
+  prePaintEvents = [];
+  paintImageEvents = [];
+  renderFrameImplCreateChildFrameEvents = [];
+  layoutImageUnsizedEvents = [];
+  domLoadingEvents = [];
+  remoteFonts = [];
+  backendNodeIds = new Set();
+  clusters = [];
   sessionMaxScore = 0;
-  scoreRecords.length = 0;
+  scoreRecords = [];
   clsWindowID = -1;
-  clustersByNavigationId.clear();
+  clustersByNavigationId = new Map();
 }
 
 export function handleEvent(event: Types.Events.Event): void {

package/front_end/models/trace/handlers/MemoryHandler.ts

@@ -9,10 +9,10 @@ export interface MemoryData {
   updateCountersByProcess: Map<Types.Events.ProcessID, Types.Events.UpdateCounters[]>;
 }
 
-const updateCountersByProcess: MemoryData['updateCountersByProcess'] = new Map();
+let updateCountersByProcess: MemoryData['updateCountersByProcess'] = new Map();
 
 export function reset(): void {
-  updateCountersByProcess.clear();
+  updateCountersByProcess = new Map();
 }
 
 export function handleEvent(event: Types.Events.Event): void {

package/front_end/models/trace/handlers/MetaHandler.ts

@@ -7,14 +7,14 @@ import * as Helpers from '../helpers/helpers.js';
 import * as Types from '../types/types.js';
 
 // We track the renderer processes we see in each frame on the way through the trace.
-const rendererProcessesByFrameId: FrameProcessData = new Map();
+let rendererProcessesByFrameId: FrameProcessData = new Map();
 
 // We will often want to key data by Frame IDs, and commonly we'll care most
 // about the main frame's ID, so we store and expose that.
 let mainFrameId = '';
 let mainFrameURL = '';
 
-const framesByProcessId = new Map<Types.Events.ProcessID, Map<string, Types.Events.TraceFrame>>();
+let framesByProcessId = new Map<Types.Events.ProcessID, Map<string, Types.Events.TraceFrame>>();
 
 // We will often want to key data by the browser process, GPU process and top
 // level renderer IDs, so keep a track on those.
@@ -25,9 +25,9 @@ let gpuThreadId: Types.Events.ThreadID = Types.Events.ThreadID(-1);
 let viewportRect: {x: number, y: number, width: number, height: number}|null = null;
 let devicePixelRatio: number|null = null;
 
-const processNames = new Map<Types.Events.ProcessID, Types.Events.ProcessName>();
+let processNames = new Map<Types.Events.ProcessID, Types.Events.ProcessName>();
 
-const topLevelRendererIds = new Set<Types.Events.ProcessID>();
+let topLevelRendererIds = new Set<Types.Events.ProcessID>();
 const traceBounds: Types.Timing.TraceWindowMicro = {
   min: Types.Timing.Micro(Number.POSITIVE_INFINITY),
   max: Types.Timing.Micro(Number.NEGATIVE_INFINITY),
@@ -49,14 +49,14 @@ const traceBounds: Types.Timing.TraceWindowMicro = {
  * main frame navigations, so calculating this list here is better than
  * filtering either of the below maps over and over again at the UI layer.
  */
-const navigationsByFrameId = new Map<string, Types.Events.NavigationStart[]>();
-const navigationsByNavigationId = new Map<string, Types.Events.NavigationStart>();
-const finalDisplayUrlByNavigationId = new Map<string, string>();
-const mainFrameNavigations: Types.Events.NavigationStart[] = [];
+let navigationsByFrameId = new Map<string, Types.Events.NavigationStart[]>();
+let navigationsByNavigationId = new Map<string, Types.Events.NavigationStart>();
+let finalDisplayUrlByNavigationId = new Map<string, string>();
+let mainFrameNavigations: Types.Events.NavigationStart[] = [];
 
 // Represents all the threads in the trace, organized by process. This is mostly for internal
 // bookkeeping so that during the finalize pass we can obtain the main and browser thread IDs.
-const threadsInProcess = new Map<Types.Events.ProcessID, Map<Types.Events.ThreadID, Types.Events.ThreadName>>();
+let threadsInProcess = new Map<Types.Events.ProcessID, Map<Types.Events.ThreadID, Types.Events.ThreadName>>();
 
 let traceStartedTimeFromTracingStartedEvent = Types.Timing.Micro(-1);
 const eventPhasesOfInterestForTraceBounds = new Set([
@@ -82,21 +82,21 @@ const CHROME_WEB_TRACE_EVENTS = new Set([
 ]);
 
 export function reset(): void {
-  navigationsByFrameId.clear();
-  navigationsByNavigationId.clear();
-  finalDisplayUrlByNavigationId.clear();
-  processNames.clear();
-  mainFrameNavigations.length = 0;
+  navigationsByFrameId = new Map();
+  navigationsByNavigationId = new Map();
+  finalDisplayUrlByNavigationId = new Map();
+  processNames = new Map();
+  mainFrameNavigations = [];
 
   browserProcessId = Types.Events.ProcessID(-1);
   browserThreadId = Types.Events.ThreadID(-1);
   gpuProcessId = Types.Events.ProcessID(-1);
   gpuThreadId = Types.Events.ThreadID(-1);
   viewportRect = null;
-  topLevelRendererIds.clear();
-  threadsInProcess.clear();
-  rendererProcessesByFrameId.clear();
-  framesByProcessId.clear();
+  topLevelRendererIds = new Set();
+  threadsInProcess = new Map();
+  rendererProcessesByFrameId = new Map();
+  framesByProcessId = new Map();
 
   traceBounds.min = Types.Timing.Micro(Number.POSITIVE_INFINITY);
   traceBounds.max = Types.Timing.Micro(Number.NEGATIVE_INFINITY);

package/front_end/models/trace/handlers/NetworkRequestsHandler.ts

@@ -46,8 +46,8 @@ export interface WebSocketTraceDataForWorker {
 }
 export type WebSocketTraceData = WebSocketTraceDataForFrame|WebSocketTraceDataForWorker;
 
-const webSocketData = new Map<number, WebSocketTraceData>();
-const linkPreconnectEvents: Types.Events.LinkPreconnect[] = [];
+let webSocketData = new Map<number, WebSocketTraceData>();
+let linkPreconnectEvents: Types.Events.LinkPreconnect[] = [];
 
 interface NetworkRequestData {
   byId: Map<string, Types.Events.SyntheticNetworkRequest>;
@@ -58,19 +58,19 @@ interface NetworkRequestData {
   linkPreconnectEvents: Types.Events.LinkPreconnect[];
 }
 
-const requestMap = new Map<string, TraceEventsForNetworkRequest>();
-const requestsById = new Map<string, Types.Events.SyntheticNetworkRequest>();
-const requestsByTime: Types.Events.SyntheticNetworkRequest[] = [];
+let requestMap = new Map<string, TraceEventsForNetworkRequest>();
+let requestsById = new Map<string, Types.Events.SyntheticNetworkRequest>();
+let requestsByTime: Types.Events.SyntheticNetworkRequest[] = [];
 
-const networkRequestEventByInitiatorUrl = new Map<string, Types.Events.SyntheticNetworkRequest[]>();
-const eventToInitiatorMap = new Map<Types.Events.SyntheticNetworkRequest, Types.Events.SyntheticNetworkRequest>();
+let networkRequestEventByInitiatorUrl = new Map<string, Types.Events.SyntheticNetworkRequest[]>();
+let eventToInitiatorMap = new Map<Types.Events.SyntheticNetworkRequest, Types.Events.SyntheticNetworkRequest>();
 
 /**
  * These are to store ThirdParty data relationships between entities and events. To reduce iterating through data
  * more than we have to, here we start building the caches. After this, the RendererHandler will update
  * the relationships. When handling ThirdParty references, use the one in the RendererHandler instead.
  */
-const entityMappings: HandlerHelpers.EntityMappings = {
+let entityMappings: HandlerHelpers.EntityMappings = {
   eventsByEntity: new Map<HandlerHelpers.Entity, Types.Events.Event[]>(),
   entityByEvent: new Map<Types.Events.Event, HandlerHelpers.Entity>(),
   createdEntityCache: new Map<string, HandlerHelpers.Entity>(),
@@ -111,17 +111,19 @@ function firstPositiveValueInList(entries: Array<number|null>): number {
 }
 
 export function reset(): void {
-  requestsById.clear();
-  requestMap.clear();
-  requestsByTime.length = 0;
-  networkRequestEventByInitiatorUrl.clear();
-  eventToInitiatorMap.clear();
-  webSocketData.clear();
-  entityMappings.eventsByEntity.clear();
-  entityMappings.entityByEvent.clear();
-  entityMappings.createdEntityCache.clear();
-  entityMappings.entityByUrlCache.clear();
-  linkPreconnectEvents.length = 0;
+  requestsById = new Map();
+  requestMap = new Map();
+  requestsByTime = [];
+  networkRequestEventByInitiatorUrl = new Map();
+  eventToInitiatorMap = new Map();
+  webSocketData = new Map();
+  entityMappings = {
+    eventsByEntity: new Map<HandlerHelpers.Entity, Types.Events.Event[]>(),
+    entityByEvent: new Map<Types.Events.Event, HandlerHelpers.Entity>(),
+    createdEntityCache: new Map<string, HandlerHelpers.Entity>(),
+    entityByUrlCache: new Map<string, HandlerHelpers.Entity>(),
+  };
+  linkPreconnectEvents = [];
 }
 
 export function handleEvent(event: Types.Events.Event): void {
@@ -581,10 +583,10 @@ export function data(): NetworkRequestData {
     eventToInitiator: eventToInitiatorMap,
     webSocket: [...webSocketData.values()],
     entityMappings: {
-      entityByEvent: new Map(entityMappings.entityByEvent),
-      eventsByEntity: new Map(entityMappings.eventsByEntity),
-      createdEntityCache: new Map(entityMappings.createdEntityCache),
-      entityByUrlCache: new Map(entityMappings.entityByUrlCache),
+      entityByEvent: entityMappings.entityByEvent,
+      eventsByEntity: entityMappings.eventsByEntity,
+      createdEntityCache: entityMappings.createdEntityCache,
+      entityByUrlCache: entityMappings.entityByUrlCache,
     },
     linkPreconnectEvents,
   };

package/front_end/models/trace/handlers/PageFramesHandler.ts

@@ -4,10 +4,10 @@
 
 import * as Types from '../types/types.js';
 
-const frames = new Map<string, Types.Events.TraceFrame>();
+let frames = new Map<string, Types.Events.TraceFrame>();
 
 export function reset(): void {
-  frames.clear();
+  frames = new Map();
 }
 
 export function handleEvent(event: Types.Events.Event): void {

package/front_end/models/trace/handlers/PageLoadMetricsHandler.ts

@@ -29,7 +29,7 @@ type NavigationId = string;
  * The metric scores include the event related to the metric as well as the data regarding
  * the score itself.
  */
-const metricScoresByFrameId = new Map<FrameId, Map<NavigationId, Map<MetricName, MetricScore>>>();
+let metricScoresByFrameId = new Map<FrameId, Map<NavigationId, Map<MetricName, MetricScore>>>();
 
 /**
  * Page load events with no associated duration that happened in the
@@ -38,10 +38,10 @@ const metricScoresByFrameId = new Map<FrameId, Map<NavigationId, Map<MetricName,
 let allMarkerEvents: Types.Events.PageLoadEvent[] = [];
 
 export function reset(): void {
-  metricScoresByFrameId.clear();
+  metricScoresByFrameId = new Map();
   pageLoadEventsArray = [];
   allMarkerEvents = [];
-  selectedLCPCandidateEvents.clear();
+  selectedLCPCandidateEvents = new Set();
 }
 
 let pageLoadEventsArray: Types.Events.PageLoadEvent[] = [];
@@ -54,7 +54,7 @@ let pageLoadEventsArray: Types.Events.PageLoadEvent[] = [];
 // trace, we store that and delete the prior event. When we've parsed the
 // entire trace this set will contain all the LCP events that were used - e.g.
 // the candidates that were the actual LCP events.
-const selectedLCPCandidateEvents = new Set<Types.Events.LargestContentfulPaintCandidate>();
+let selectedLCPCandidateEvents = new Set<Types.Events.LargestContentfulPaintCandidate>();
 
 export function handleEvent(event: Types.Events.Event): void {
   if (!Types.Events.eventIsPageLoadEvent(event)) {
@@ -159,7 +159,7 @@ function storePageLoadMetricAgainstNavigationId(
   if (Types.Events.isLargestContentfulPaintCandidate(event)) {
     const candidateIndex = event.args.data?.candidateIndex;
     if (!candidateIndex) {
-      throw new Error('Largest Contenful Paint unexpectedly had no candidateIndex.');
+      throw new Error('Largest Contentful Paint unexpectedly had no candidateIndex.');
     }
     const lcpTime = Types.Timing.Micro(event.ts - navigation.ts);
     const lcp = {