devtools-tracing 1.1.1 → 1.2.1

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

@@ -1,183 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Platform from '../../../core/platform/platform.js';
-import * as Types from '../types/types.js';
-
-import {data as metaHandlerData} from './MetaHandler.js';
-import type {FinalizeOptions} from './types.js';
-
-/**
- * This handler is responsible for the relationships between:
- * DecodeImage/ResizeImage, PaintImage and DrawLazyPixelRef events.
- *
- * When we get a DecodeImage event, we want to associate it to a PaintImage
- * event, primarily so we can determine the NodeID of the image that was
- * decoded.
- * We can do this in two ways:
- *
- * 1. If there is a PaintImage event on the same thread, use that
- *    (if there are multiple, use the latest one).
- *
- * 2. If not, we can find the DecodeLazyPixelRef event on the same thread, and
- *    use the PaintImage event associated with it via the `LazyPixelRef` key.
- */
-
-// Track paintImageEvents across threads.
-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.
-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.
-let eventToPaintImage = new Map<Types.Events.Event, Types.Events.PaintImage>();
-
-let urlToPaintImage = new Map<string, Types.Events.PaintImage[]>();
-
-let paintEventToCorrectedDisplaySize = new Map<Types.Events.PaintImage, {width: number, height: number}>();
-
-let didCorrectForHostDpr = false;
-
-export function reset(): void {
-  paintImageEvents = new Map();
-  decodeLazyPixelRefEvents = new Map();
-  paintImageByLazyPixelRef = new Map();
-  eventToPaintImage = new Map();
-  urlToPaintImage = new Map();
-  paintEventToCorrectedDisplaySize = new Map();
-  didCorrectForHostDpr = false;
-}
-
-export function handleEvent(event: Types.Events.Event): void {
-  if (Types.Events.isPaintImage(event)) {
-    const forProcess = paintImageEvents.get(event.pid) || new Map<Types.Events.ThreadID, Types.Events.PaintImage[]>();
-    const forThread = forProcess.get(event.tid) || [];
-    forThread.push(event);
-    forProcess.set(event.tid, forThread);
-    paintImageEvents.set(event.pid, forProcess);
-
-    if (event.args.data.url) {
-      const paintsForUrl = Platform.MapUtilities.getWithDefault(urlToPaintImage, event.args.data.url, () => []);
-      paintsForUrl.push(event);
-    }
-
-    return;
-  }
-
-  if (Types.Events.isDecodeLazyPixelRef(event) && typeof event.args?.LazyPixelRef !== 'undefined') {
-    // Store these because we use them to tie DecodeImage to a PaintEvent.
-    const forProcess =
-        decodeLazyPixelRefEvents.get(event.pid) || new Map<Types.Events.ThreadID, Types.Events.DecodeLazyPixelRef[]>();
-    const forThread = forProcess.get(event.tid) || [];
-    forThread.push(event);
-    forProcess.set(event.tid, forThread);
-    decodeLazyPixelRefEvents.set(event.pid, forProcess);
-  }
-
-  // If we see a DrawLazyPixelRef event, we need to find the last PaintImage
-  // event on the thread and associate it to the LazyPixelRef that is supplied
-  // in the DrawLazyPixelRef event.
-  // This means that later on if we see a DecodeLazyPixelRef event with the
-  // same LazyPixelRef key, we can find its associated PaintImage event by
-  // looking it up.
-  if (Types.Events.isDrawLazyPixelRef(event) && typeof event.args?.LazyPixelRef !== 'undefined') {
-    const lastPaintEvent = paintImageEvents.get(event.pid)?.get(event.tid)?.at(-1);
-    if (!lastPaintEvent) {
-      return;
-    }
-    paintImageByLazyPixelRef.set(event.args.LazyPixelRef, lastPaintEvent);
-    return;
-  }
-
-  if (Types.Events.isDecodeImage(event)) {
-    // When we see a DecodeImage, we want to associate it to a PaintImage
-    // event. We try two approaches:
-    //
-    // 1. If the thread of the DecodeImage event has a previous PaintImage
-    // event, that is the associated event.
-    //
-    // 2. If that is false, we then look on the thread for a DecodeLazyPixelRef
-    // event. If we find that, we then look for its associated PaintImage
-    // event, which we associate via DrawLazyPixelRef events (the code block
-    // above this one)
-    //
-    // 1. Find a PaintImage event on the same thread. If we find it, that's our association done.
-    const lastPaintImageEventOnThread = paintImageEvents.get(event.pid)?.get(event.tid)?.at(-1);
-    if (lastPaintImageEventOnThread) {
-      eventToPaintImage.set(event, lastPaintImageEventOnThread);
-      return;
-    }
-
-    // 2. Find the last DecodeLazyPixelRef event and, if we find it, find its associated PaintImage event.
-    const lastDecodeLazyPixelRef = decodeLazyPixelRefEvents.get(event.pid)?.get(event.tid)?.at(-1);
-    if (typeof lastDecodeLazyPixelRef?.args?.LazyPixelRef === 'undefined') {
-      return;
-    }
-
-    const paintEvent = paintImageByLazyPixelRef.get(lastDecodeLazyPixelRef.args.LazyPixelRef);
-    if (!paintEvent) {
-      return;
-    }
-    eventToPaintImage.set(event, paintEvent);
-  }
-}
-
-export async function finalize(options: FinalizeOptions): Promise<void> {
-  // Painting in Chrome never uses the emulated DPR, but instead used the host's DPR.
-  // We need to correct for that for our responsive image checks in the ImageDelivery
-  // insight.
-  // See: crbug.com/427552461 crbug.com/416580500#comment5
-
-  if (!options.metadata?.hostDPR) {
-    return;
-  }
-
-  // Note: this isn't necessarily emulated (for desktop+no DPR emulation, it's equal
-  // to host DPR).
-  const {devicePixelRatio: emulatedDpr} = metaHandlerData();
-  if (!emulatedDpr) {
-    return;
-  }
-
-  for (const byThread of paintImageEvents.values()) {
-    for (const paintEvents of byThread.values()) {
-      for (const paintEvent of paintEvents) {
-        const cssPixelsWidth = paintEvent.args.data.width / options.metadata.hostDPR;
-        const cssPixelsHeight = paintEvent.args.data.height / options.metadata.hostDPR;
-        const width = cssPixelsWidth * emulatedDpr;
-        const height = cssPixelsHeight * emulatedDpr;
-        paintEventToCorrectedDisplaySize.set(paintEvent, {width, height});
-      }
-    }
-  }
-
-  didCorrectForHostDpr = true;
-}
-
-export interface ImagePaintData {
-  paintImageByDrawLazyPixelRef: Map<number, Types.Events.PaintImage>;
-  paintImageForEvent: Map<Types.Events.Event, Types.Events.PaintImage>;
-  paintImageEventForUrl: Map<string, Types.Events.PaintImage[]>;
-  paintEventToCorrectedDisplaySize: Map<Types.Events.PaintImage, {width: number, height: number}>;
-  /** Go read the comment in finalize(). */
-  didCorrectForHostDpr: boolean;
-}
-
-export function data(): ImagePaintData {
-  return {
-    paintImageByDrawLazyPixelRef: paintImageByLazyPixelRef,
-    paintImageForEvent: eventToPaintImage,
-    paintImageEventForUrl: urlToPaintImage,
-    paintEventToCorrectedDisplaySize,
-    didCorrectForHostDpr,
-  };
-}

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

@@ -1,193 +0,0 @@
-// Copyright 2023 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Helpers from '../helpers/helpers.js';
-import * as Types from '../types/types.js';
-
-import {data as AsyncJSCallsHandlerData} from './AsyncJSCallsHandler.js';
-import {data as flowsHandlerData} from './FlowsHandler.js';
-
-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.
-let lastInvalidationEventForFrame = new Map<string, Types.Events.Event>();
-
-let lastRecalcByFrame = new Map<string, Types.Events.RecalcStyle>();
-
-// 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.
-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.
-let initiatorToEventsMap = new Map<Types.Events.Event, Types.Events.Event[]>();
-
-let timerInstallEventsById = new Map<number, Types.Events.TimerInstall>();
-let requestIdleCallbackEventsById = new Map<number, Types.Events.RequestIdleCallback>();
-
-let webSocketCreateEventsById = new Map<number, Types.Events.WebSocketCreate>();
-let schedulePostTaskCallbackEventsById = new Map<number, Types.Events.SchedulePostTaskCallback>();
-
-export function reset(): void {
-  lastScheduleStyleRecalcByFrame = new Map();
-  lastInvalidationEventForFrame = new Map();
-  lastRecalcByFrame = 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 {
-  eventToInitiatorMap.set(data.event, data.initiator);
-  const eventsForInitiator = initiatorToEventsMap.get(data.initiator) || [];
-  eventsForInitiator.push(data.event);
-  initiatorToEventsMap.set(data.initiator, eventsForInitiator);
-}
-
-/**
- * IMPORTANT: Before adding support for new initiator relationships in
- * trace events consider using Perfetto's flow API on the events in
- * question, so that they get automatically computed.
- * @see {@link flowsHandlerData}
- *
- * The events manually computed here were added before we had support
- * for flow events. As such they should be migrated to use the flow
- * API so that no manual parsing is needed.
- */
-export function handleEvent(event: Types.Events.Event): void {
-  if (Types.Events.isScheduleStyleRecalculation(event)) {
-    lastScheduleStyleRecalcByFrame.set(event.args.data.frame, event);
-  } else if (Types.Events.isRecalcStyle(event)) {
-    if (event.args.beginData) {
-      // Store the last RecalcStyle event: we use this when we see an
-      // InvalidateLayout and try to figure out its initiator.
-      lastRecalcByFrame.set(event.args.beginData.frame, event);
-
-      // If this frame has seen a ScheduleStyleRecalc event, then that event is
-      // considered to be the initiator of this StylesRecalc.
-      const scheduledStyleForFrame = lastScheduleStyleRecalcByFrame.get(event.args.beginData.frame);
-      if (scheduledStyleForFrame) {
-        storeInitiator({
-          event,
-          initiator: scheduledStyleForFrame,
-        });
-      }
-    }
-  } else if (Types.Events.isInvalidateLayout(event)) {
-    // By default, the InvalidateLayout event is what triggered the layout invalidation for this frame.
-    let invalidationInitiator: Types.Events.Event = event;
-
-    // However, if we have not had any prior invalidations for this frame, we
-    // want to consider StyleRecalculation events as they might be the actual
-    // cause of this layout invalidation.
-    if (!lastInvalidationEventForFrame.has(event.args.data.frame)) {
-      // 1. If we have not had an invalidation event for this frame
-      // 2. AND we have had an RecalcStyle for this frame
-      // 3. AND the RecalcStyle event ended AFTER the InvalidateLayout startTime
-      // 4. AND we have an initiator for the RecalcStyle event
-      // 5. Then we set the last invalidation event for this frame to be the RecalcStyle's initiator.
-      const lastRecalcStyleForFrame = lastRecalcByFrame.get(event.args.data.frame);
-      if (lastRecalcStyleForFrame) {
-        const {endTime} = Helpers.Timing.eventTimingsMicroSeconds(lastRecalcStyleForFrame);
-        const initiatorOfRecalcStyle = eventToInitiatorMap.get(lastRecalcStyleForFrame);
-
-        if (initiatorOfRecalcStyle && endTime && endTime > event.ts) {
-          invalidationInitiator = initiatorOfRecalcStyle;
-        }
-      }
-    }
-    lastInvalidationEventForFrame.set(event.args.data.frame, invalidationInitiator);
-  } else if (Types.Events.isLayout(event)) {
-    // The initiator of a Layout event is the last Invalidation event.
-    const lastInvalidation = lastInvalidationEventForFrame.get(event.args.beginData.frame);
-    if (lastInvalidation) {
-      storeInitiator({
-        event,
-        initiator: lastInvalidation,
-      });
-    }
-    // Now clear the last invalidation for the frame: the last invalidation has been linked to a Layout event, so it cannot be the initiator for any future layouts.
-    lastInvalidationEventForFrame.delete(event.args.beginData.frame);
-  } else if (Types.Events.isTimerInstall(event)) {
-    timerInstallEventsById.set(event.args.data.timerId, event);
-  } else if (Types.Events.isTimerFire(event)) {
-    const matchingInstall = timerInstallEventsById.get(event.args.data.timerId);
-    if (matchingInstall) {
-      storeInitiator({event, initiator: matchingInstall});
-    }
-  } else if (Types.Events.isRequestIdleCallback(event)) {
-    requestIdleCallbackEventsById.set(event.args.data.id, event);
-  } else if (Types.Events.isFireIdleCallback(event)) {
-    const matchingRequestEvent = requestIdleCallbackEventsById.get(event.args.data.id);
-    if (matchingRequestEvent) {
-      storeInitiator({
-        event,
-        initiator: matchingRequestEvent,
-      });
-    }
-  } else if (Types.Events.isWebSocketCreate(event)) {
-    webSocketCreateEventsById.set(event.args.data.identifier, event);
-  } else if (Types.Events.isWebSocketInfo(event) || Types.Events.isWebSocketTransfer(event)) {
-    const matchingCreateEvent = webSocketCreateEventsById.get(event.args.data.identifier);
-    if (matchingCreateEvent) {
-      storeInitiator({
-        event,
-        initiator: matchingCreateEvent,
-      });
-    }
-  } else if (Types.Events.isSchedulePostTaskCallback(event)) {
-    schedulePostTaskCallbackEventsById.set(event.args.data.taskId, event);
-  } else if (Types.Events.isRunPostTaskCallback(event) || Types.Events.isAbortPostTaskCallback(event)) {
-    const matchingSchedule = schedulePostTaskCallbackEventsById.get(event.args.data.taskId);
-    if (matchingSchedule) {
-      storeInitiator({event, initiator: matchingSchedule});
-    }
-  }
-}
-
-function createRelationshipsFromFlows(): void {
-  const flows = flowsHandlerData().flows;
-  for (let i = 0; i < flows.length; i++) {
-    const flow = flows[i];
-    for (let j = 0; j < flow.length - 1; j++) {
-      storeInitiator({event: flow[j + 1], initiator: flow[j]});
-    }
-  }
-}
-
-function createRelationshipsFromAsyncJSCalls(): void {
-  const asyncCallEntries = AsyncJSCallsHandlerData().schedulerToRunEntryPoints.entries();
-  for (const [asyncCaller, asyncCallees] of asyncCallEntries) {
-    for (const asyncCallee of asyncCallees) {
-      storeInitiator({event: asyncCallee, initiator: asyncCaller});
-    }
-  }
-}
-
-export async function finalize(): Promise<void> {
-  createRelationshipsFromFlows();
-  createRelationshipsFromAsyncJSCalls();
-}
-
-export interface InitiatorsData {
-  eventToInitiator: Map<Types.Events.Event, Types.Events.Event>;
-  initiatorToEvents: Map<Types.Events.Event, Types.Events.Event[]>;
-}
-
-export function data(): InitiatorsData {
-  return {
-    eventToInitiator: eventToInitiatorMap,
-    initiatorToEvents: initiatorToEventsMap,
-  };
-}
-
-export function deps(): ['Flows', 'AsyncJSCalls'] {
-  return ['Flows', 'AsyncJSCalls'];
-}

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

@@ -1,168 +0,0 @@
-// Copyright 2023 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Types from '../types/types.js';
-
-/**
- * @file Associates invalidation to recalc/layout events; mostly used in "invalidation tracking" experiment.
- * "Invalidations" == "mutations" == "damage".
- * A DOM change that means we need to recompute style or layout is an invalidation that's tracked here.
- * If the experiment `timeline-invalidation-tracking` is enabled, the `disabledByDefault('devtools.timeline.invalidationTracking')` trace category is enabled, which contains most of these events.
- */
-
-interface InvalidationsStatePerFrame {
-  invalidationsForEvent: Map<Types.Events.Event, Types.Events.InvalidationTrackingEvent[]>;
-  invalidationCountForEvent: Map<Types.Events.Event, number>;
-  lastRecalcStyleEvent: Types.Events.RecalcStyle|null;
-  hasPainted: boolean;
-  pendingInvalidations: Types.Events.InvalidationTrackingEvent[];
-}
-
-const frameStateByFrame = new Map<string, InvalidationsStatePerFrame>();
-let maxInvalidationsPerEvent: number|null = null;
-
-export function reset(): void {
-  frameStateByFrame.clear();
-  maxInvalidationsPerEvent = null;
-}
-
-export function handleUserConfig(userConfig: Types.Configuration.Configuration): void {
-  maxInvalidationsPerEvent = userConfig.maxInvalidationEventsPerEvent;
-}
-
-function getState(frameId: string): InvalidationsStatePerFrame {
-  let frameState = frameStateByFrame.get(frameId);
-  if (!frameState) {
-    frameState = {
-      invalidationsForEvent: new Map(),
-      invalidationCountForEvent: new Map(),
-      lastRecalcStyleEvent: null,
-      pendingInvalidations: [],
-      hasPainted: false,
-    };
-    frameStateByFrame.set(frameId, frameState);
-  }
-  return frameState;
-}
-
-function getFrameId(event: Types.Events.Event): string|null {
-  if (Types.Events.isRecalcStyle(event) || Types.Events.isLayout(event)) {
-    return event.args.beginData?.frame ?? null;
-  }
-  return event.args?.data?.frame ?? null;
-}
-
-function addInvalidationToEvent(
-    frameState: InvalidationsStatePerFrame, event: Types.Events.Event,
-    invalidation: Types.Events.InvalidationTrackingEvent): void {
-  const existingInvalidations = frameState.invalidationsForEvent.get(event) || [];
-  existingInvalidations.push(invalidation);
-
-  if (maxInvalidationsPerEvent !== null && existingInvalidations.length > maxInvalidationsPerEvent) {
-    existingInvalidations.shift();
-  }
-  frameState.invalidationsForEvent.set(event, existingInvalidations);
-
-  const count = frameState.invalidationCountForEvent.get(event) ?? 0;
-  frameState.invalidationCountForEvent.set(event, count + 1);
-}
-
-export function handleEvent(event: Types.Events.Event): void {
-  // Special case: if we have been configured to not store any invalidations,
-  // we take that as a sign that we don't even want to gather any invalidations
-  // data at all and early exit.
-  if (maxInvalidationsPerEvent === 0) {
-    return;
-  }
-
-  const frameId = getFrameId(event);
-  if (!frameId) {
-    return;
-  }
-  const thisFrame = getState(frameId);
-
-  if (Types.Events.isRecalcStyle(event)) {
-    thisFrame.lastRecalcStyleEvent = event;
-
-    // Associate any prior invalidations with this recalc event.
-    for (const invalidation of thisFrame.pendingInvalidations) {
-      if (Types.Events.isLayoutInvalidationTracking(invalidation)) {
-        // LayoutInvalidation events cannot be associated with a LayoutTree
-        // event.
-        continue;
-      }
-      addInvalidationToEvent(thisFrame, event, invalidation);
-    }
-    return;
-  }
-
-  if (Types.Events.isInvalidationTracking(event)) {
-    if (thisFrame.hasPainted) {
-      // If we have painted, then we can clear out the list of all existing
-      // invalidations, as we cannot associate them across frames.
-      thisFrame.pendingInvalidations.length = 0;
-      thisFrame.lastRecalcStyleEvent = null;
-      thisFrame.hasPainted = false;
-    }
-
-    // Style invalidation events can occur before and during recalc styles. When we get a recalc style event, we check and associate any prior invalidations with it.
-    // But any invalidations that occur during a RecalcStyle
-    // event would be reported in trace events after. So each time we get an
-    // invalidation that might be due to a style recalc, we check if the
-    // timings overlap and if so associate them.
-    if (thisFrame.lastRecalcStyleEvent &&
-        (Types.Events.isScheduleStyleInvalidationTracking(event) ||
-         Types.Events.isStyleRecalcInvalidationTracking(event) ||
-         Types.Events.isStyleInvalidatorInvalidationTracking(event))) {
-      const recalcLastRecalc = thisFrame.lastRecalcStyleEvent;
-      const recalcEndTime = recalcLastRecalc.ts + (recalcLastRecalc.dur || 0);
-      if (event.ts >= recalcLastRecalc.ts && event.ts <= recalcEndTime) {
-        addInvalidationToEvent(thisFrame, recalcLastRecalc, event);
-      }
-    }
-
-    thisFrame.pendingInvalidations.push(event);
-    return;
-  }
-
-  if (Types.Events.isPaint(event)) {
-    thisFrame.hasPainted = true;
-    return;
-  }
-
-  if (Types.Events.isLayout(event)) {
-    for (const invalidation of thisFrame.pendingInvalidations) {
-      // The only invalidations that cause a Layout are LayoutInvalidations :)
-      if (!Types.Events.isLayoutInvalidationTracking(invalidation)) {
-        continue;
-      }
-      addInvalidationToEvent(thisFrame, event, invalidation);
-    }
-  }
-}
-
-export async function finalize(): Promise<void> {
-}
-
-interface InvalidationsData {
-  invalidationsForEvent: Map<Types.Events.Event, Types.Events.InvalidationTrackingEvent[]>;
-  invalidationCountForEvent: Map<Types.Events.Event, number>;
-}
-
-export function data(): InvalidationsData {
-  const invalidationsForEvent = new Map<Types.Events.Event, Types.Events.InvalidationTrackingEvent[]>();
-  const invalidationCountForEvent = new Map<Types.Events.Event, number>();
-  for (const frame of frameStateByFrame.values()) {
-    for (const [event, invalidations] of frame.invalidationsForEvent.entries()) {
-      invalidationsForEvent.set(event, invalidations);
-    }
-    for (const [event, count] of frame.invalidationCountForEvent.entries()) {
-      invalidationCountForEvent.set(event, count);
-    }
-  }
-  return {
-    invalidationsForEvent,
-    invalidationCountForEvent,
-  };
-}

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

@@ -1,109 +0,0 @@
-// Copyright 2022 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import * as Platform from '../../../core/platform/platform.js';
-import type * as Protocol from '../../../generated/protocol.js';
-import * as Types from '../types/types.js';
-
-import {data as metaData} from './MetaHandler.js';
-import {data as networkRequestsData} from './NetworkRequestsHandler.js';
-import {data as pageLoadMetricsData, MetricName} from './PageLoadMetricsHandler.js';
-import type {HandlerName} from './types.js';
-
-/**
- * If the LCP resource was an image, and that image was fetched over the
- * network, we want to be able to find the network request in order to construct
- * the critical path for an LCP image.
- * Within the trace file there are `LargestImagePaint::Candidate` events.
- * Within their data object, they contain a `DOMNodeId` property, which maps to
- * the DOM Node ID for that image.
- *
- * This id maps exactly to the `data.nodeId` property that a
- * `LargestContentfulPaint::Candidate` will have. So, when we find an image
- * paint candidate, we can store it, keying it on the node ID.
- * Then, when it comes to finding the network request for an LCP image, we can
- * use the nodeId from the LCP candidate to find the image candidate. That image
- * candidate also contains a `imageUrl` property, which will have the full URL
- * to the image.
- *
- * `BackendNodeId`s are only unique within a given renderer process, so this is
- * also keyed on `ProcessId`.
- **/
-let imagePaintsByNodeIdAndProcess =
-    new Map<Types.Events.ProcessID, Map<Protocol.DOM.BackendNodeId, Types.Events.LargestImagePaintCandidate>>();
-let lcpRequestByNavigationId = new Map<string, Types.Events.SyntheticNetworkRequest>();
-
-export function reset(): void {
-  imagePaintsByNodeIdAndProcess = new Map();
-  lcpRequestByNavigationId = new Map();
-}
-
-export function handleEvent(event: Types.Events.Event): void {
-  if (!Types.Events.isLargestImagePaintCandidate(event) || !event.args.data) {
-    return;
-  }
-
-  const imagePaintsByNodeId =
-      Platform.MapUtilities.getWithDefault(imagePaintsByNodeIdAndProcess, event.pid, () => new Map());
-  imagePaintsByNodeId.set(event.args.data.DOMNodeId, event);
-}
-
-export async function finalize(): Promise<void> {
-  const requests = networkRequestsData().byTime;
-  const {traceBounds, navigationsByNavigationId} = metaData();
-  const metricScoresByFrameId = pageLoadMetricsData().metricScoresByFrameId;
-
-  for (const [navigationId, navigation] of navigationsByNavigationId) {
-    const lcpMetric = metricScoresByFrameId.get(navigation.args.frame)?.get(navigationId)?.get(MetricName.LCP);
-    const lcpEvent = lcpMetric?.event;
-    if (!lcpEvent || !Types.Events.isLargestContentfulPaintCandidate(lcpEvent)) {
-      continue;
-    }
-
-    const nodeId = lcpEvent.args.data?.nodeId;
-    if (!nodeId) {
-      continue;
-    }
-
-    const lcpImagePaintEvent = imagePaintsByNodeIdAndProcess.get(lcpEvent.pid)?.get(nodeId);
-    const lcpUrl = lcpImagePaintEvent?.args.data?.imageUrl;
-    if (!lcpUrl) {
-      continue;
-    }
-
-    const startTime = navigation?.ts ?? traceBounds.min;
-    const endTime = lcpImagePaintEvent.ts;
-
-    let lcpRequest;
-    for (const request of requests) {
-      if (request.ts < startTime) {
-        continue;
-      }
-      if (request.ts >= endTime) {
-        break;
-      }
-
-      if (request.args.data.url === lcpUrl || request.args.data.redirects.some(r => r.url === lcpUrl)) {
-        lcpRequest = request;
-        break;
-      }
-    }
-
-    if (lcpRequest) {
-      lcpRequestByNavigationId.set(navigationId, lcpRequest);
-    }
-  }
-}
-
-export interface LargestImagePaintData {
-  lcpRequestByNavigationId: Map<string, Types.Events.SyntheticNetworkRequest>;
-}
-
-export function data(): LargestImagePaintData {
-  return {lcpRequestByNavigationId};
-}
-
-export function deps(): HandlerName[] {
-  return ['Meta', 'NetworkRequests', 'PageLoadMetrics'];
-}

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

@@ -1,35 +0,0 @@
-// Copyright 2022 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-import type * as Protocol from '../../../generated/protocol.js';
-import * as Types from '../types/types.js';
-/**
- * A trace file will contain all the text paints that were candidates for the
- * LargestTextPaint. If an LCP event is text, it will point to one of these
- * candidates, so we store them by their DOM Node ID.
- **/
-let textPaintByDOMNodeId = new Map<Protocol.DOM.BackendNodeId, Types.Events.LargestTextPaintCandidate>();
-
-export function reset(): void {
-  textPaintByDOMNodeId = new Map();
-}
-
-export function handleEvent(event: Types.Events.Event): void {
-  if (!Types.Events.isLargestTextPaintCandidate(event)) {
-    return;
-  }
-
-  if (!event.args.data) {
-    return;
-  }
-
-  textPaintByDOMNodeId.set(event.args.data.DOMNodeId, event);
-}
-
-export async function finalize(): Promise<void> {
-}
-
-export function data(): Map<Protocol.DOM.BackendNodeId, Types.Events.LargestTextPaintCandidate> {
-  return textPaintByDOMNodeId;
-}