devtools-tracing 1.1.1 → 1.2.1

package/lib/front_end/models/trace/insights/LCPDiscovery.ts

@@ -1,237 +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 i18n from '../../../core/i18n/i18n.js';
-import * as Handlers from '../handlers/handlers.js';
-import * as Helpers from '../helpers/helpers.js';
-import * as Types from '../types/types.js';
-
-import {calculateDocFirstByteTs} from './Common.js';
-import {
-  type Checklist,
-  InsightCategory,
-  InsightKeys,
-  type InsightModel,
-  type InsightSetContext,
-  InsightWarning,
-  type PartialInsightModel,
-} from './types.js';
-
-export const UIStrings = {
-  /**
-   * @description Title of an insight that provides details about the LCP metric, and the network requests necessary to load it. Details how the LCP request was discoverable - in other words, the path necessary to load it (ex: network requests, JavaScript)
-   */
-  title: 'LCP request discovery',
-  /**
-   * @description Description of an insight that provides details about the LCP metric, and the network requests necessary to load it.
-   */
-  description:
-      '[Optimize LCP](https://developer.chrome.com/docs/performance/insights/lcp-discovery) by making the LCP image discoverable from the HTML immediately, and avoiding lazy-loading',
-  /**
-   * @description Text to tell the user how long after the earliest discovery time their LCP element loaded.
-   * @example {401ms} PH1
-   */
-  lcpLoadDelay: 'LCP image loaded {PH1} after earliest start point.',
-  /**
-   * @description Text to tell the user that a fetchpriority property value of "high" is applied to the LCP request.
-   */
-  fetchPriorityApplied: 'fetchpriority=high applied',
-  /**
-   * @description Text to tell the user that a fetchpriority property value of "high" should be applied to the LCP request.
-   */
-  fetchPriorityShouldBeApplied: 'fetchpriority=high should be applied',
-  /**
-   * @description Text to tell the user that the LCP request is discoverable in the initial document.
-   */
-  requestDiscoverable: 'Request is discoverable in initial document',
-  /**
-   * @description Text to tell the user that the LCP request does not have the lazy load property applied.
-   */
-  lazyLoadNotApplied: 'lazy load not applied',
-  /**
-   * @description Text status indicating that the the Largest Contentful Paint (LCP) metric timing was not found. "LCP" is an acronym and should not be translated.
-   */
-  noLcp: 'No LCP detected',
-  /**
-   * @description Text status indicating that the Largest Contentful Paint (LCP) metric was text rather than an image. "LCP" is an acronym and should not be translated.
-   */
-  noLcpResource: 'No LCP resource detected because the LCP is not an image',
-} as const;
-
-const str_ = i18n.i18n.registerUIStrings('models/trace/insights/LCPDiscovery.ts', UIStrings);
-export const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-
-export function isLCPDiscoveryInsight(model: InsightModel): model is LCPDiscoveryInsightModel {
-  return model.insightKey === 'LCPDiscovery';
-}
-export type LCPDiscoveryInsightModel = InsightModel<typeof UIStrings, {
-  lcpEvent?: Types.Events.LargestContentfulPaintCandidate,
-  /** The network request for the LCP image, if there was one. */
-  lcpRequest?: Types.Events.SyntheticNetworkRequest,
-  earliestDiscoveryTimeTs?: Types.Timing.Micro,
-  checklist?: Checklist<'priorityHinted'|'requestDiscoverable'|'eagerlyLoaded'>,
-}>;
-
-function finalize(partialModel: PartialInsightModel<LCPDiscoveryInsightModel>): LCPDiscoveryInsightModel {
-  const relatedEvents = partialModel.lcpEvent && partialModel.lcpRequest ?
-      // TODO: add entire request initiator chain?
-      [partialModel.lcpEvent, partialModel.lcpRequest] :
-      [];
-  return {
-    insightKey: InsightKeys.LCP_DISCOVERY,
-    strings: UIStrings,
-    title: i18nString(UIStrings.title),
-    description: i18nString(UIStrings.description),
-    docs: 'https://developer.chrome.com/docs/performance/insights/lcp-discovery',
-    category: InsightCategory.LCP,
-    state: partialModel.lcpRequest && partialModel.checklist &&
-            (!partialModel.checklist.eagerlyLoaded.value || !partialModel.checklist.requestDiscoverable.value ||
-             !partialModel.checklist.priorityHinted.value) ?
-        'fail' :
-        'pass',
-    ...partialModel,
-    relatedEvents,
-  };
-}
-
-export function generateInsight(
-    data: Handlers.Types.HandlerData, context: InsightSetContext): LCPDiscoveryInsightModel {
-  if (!context.navigation) {
-    return finalize({});
-  }
-
-  const networkRequests = data.NetworkRequests;
-
-  const frameMetrics = data.PageLoadMetrics.metricScoresByFrameId.get(context.frameId);
-  if (!frameMetrics) {
-    throw new Error('no frame metrics');
-  }
-
-  const navMetrics = frameMetrics.get(context.navigationId);
-  if (!navMetrics) {
-    throw new Error('no navigation metrics');
-  }
-  const metricScore = navMetrics.get(Handlers.ModelHandlers.PageLoadMetrics.MetricName.LCP);
-  const lcpEvent = metricScore?.event;
-  if (!lcpEvent || !Types.Events.isLargestContentfulPaintCandidate(lcpEvent)) {
-    return finalize({warnings: [InsightWarning.NO_LCP]});
-  }
-
-  const docRequest = networkRequests.byId.get(context.navigationId);
-  if (!docRequest) {
-    return finalize({warnings: [InsightWarning.NO_DOCUMENT_REQUEST]});
-  }
-
-  const lcpRequest = data.LargestImagePaint.lcpRequestByNavigationId.get(context.navigationId);
-  if (!lcpRequest) {
-    return finalize({lcpEvent});
-  }
-
-  const initiatorUrl = lcpRequest.args.data.initiator?.url;
-  // TODO(b/372319476): Explore using trace event HTMLDocumentParser::FetchQueuedPreloads to determine if the request
-  // is discovered by the preload scanner.
-  const initiatedByMainDoc =
-      lcpRequest?.args.data.initiator?.type === 'parser' && docRequest.args.data.url === initiatorUrl;
-  const imgPreloadedOrFoundInHTML = lcpRequest?.args.data.isLinkPreload || initiatedByMainDoc;
-
-  const imageLoadingAttr = lcpEvent.args.data?.loadingAttr;
-  const imageFetchPriorityHint = lcpRequest?.args.data.fetchPriorityHint;
-  // This is the earliest discovery time an LCP request could have - it's TTFB (as an absolute timestamp).
-  const earliestDiscoveryTime = calculateDocFirstByteTs(docRequest);
-
-  const priorityHintFound = imageFetchPriorityHint === 'high';
-
-  return finalize({
-    lcpEvent,
-    lcpRequest,
-    earliestDiscoveryTimeTs: earliestDiscoveryTime ? Types.Timing.Micro(earliestDiscoveryTime) : undefined,
-    checklist: {
-      priorityHinted: {
-        label: priorityHintFound ? i18nString(UIStrings.fetchPriorityApplied) :
-                                   i18nString(UIStrings.fetchPriorityShouldBeApplied),
-        value: priorityHintFound
-      },
-      requestDiscoverable: {label: i18nString(UIStrings.requestDiscoverable), value: imgPreloadedOrFoundInHTML},
-      eagerlyLoaded: {label: i18nString(UIStrings.lazyLoadNotApplied), value: imageLoadingAttr !== 'lazy'},
-    },
-  });
-}
-
-interface LCPImageDiscoveryData {
-  checklist: Exclude<LCPDiscoveryInsightModel['checklist'], undefined>;
-  request: Types.Events.SyntheticNetworkRequest;
-  discoveryDelay: Types.Timing.Micro|null;
-  estimatedSavings: Types.Timing.Milli|null;
-}
-
-/**
- * TODO: this extra transformation (getImageData) should not be necessary.
- */
-export function getImageData(model: LCPDiscoveryInsightModel): LCPImageDiscoveryData|null {
-  if (!model.lcpRequest || !model.checklist) {
-    return null;
-  }
-
-  const shouldIncreasePriorityHint = !model.checklist.priorityHinted.value;
-  const shouldPreloadImage = !model.checklist.requestDiscoverable.value;
-  const shouldRemoveLazyLoading = !model.checklist.eagerlyLoaded.value;
-
-  const imageLCP = shouldIncreasePriorityHint !== undefined && shouldPreloadImage !== undefined &&
-      shouldRemoveLazyLoading !== undefined;
-
-  // Shouldn't render anything if lcp insight is null or lcp is text.
-  if (!imageLCP) {
-    return null;
-  }
-
-  const data: LCPImageDiscoveryData = {
-    checklist: model.checklist,
-    request: model.lcpRequest,
-    discoveryDelay: null,
-    estimatedSavings: model.metricSavings?.LCP ?? null,
-  };
-
-  if (model.earliestDiscoveryTimeTs && model.lcpRequest) {
-    const discoveryDelay = model.lcpRequest.ts - model.earliestDiscoveryTimeTs;
-    data.discoveryDelay = Types.Timing.Micro(discoveryDelay);
-  }
-
-  return data;
-}
-
-export function createOverlays(model: LCPDiscoveryInsightModel): Types.Overlays.Overlay[] {
-  const imageResults = getImageData(model);
-  if (!imageResults?.discoveryDelay) {
-    return [];
-  }
-
-  const delay = Helpers.Timing.traceWindowFromMicroSeconds(
-      Types.Timing.Micro(imageResults.request.ts - imageResults.discoveryDelay),
-      imageResults.request.ts,
-  );
-
-  return [
-    {
-      type: 'ENTRY_OUTLINE',
-      entry: imageResults.request,
-      outlineReason: 'ERROR',
-    },
-    {
-      type: 'CANDY_STRIPED_TIME_RANGE',
-      bounds: delay,
-      entry: imageResults.request,
-    },
-    {
-      type: 'TIMESPAN_BREAKDOWN',
-      sections: [{
-        bounds: delay,
-        // This is overridden in the component.
-        label: `${imageResults.discoveryDelay} microseconds`,
-        showDuration: false,
-      }],
-      entry: imageResults.request,
-      renderLocation: 'ABOVE_EVENT',
-    },
-  ];
-}

package/lib/front_end/models/trace/insights/LegacyJavaScript.ts

@@ -1,138 +0,0 @@
-// Copyright 2025 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 i18n from '../../../core/i18n/i18n.js';
-import * as LegacyJavaScriptLib from '../../../third_party/legacy-javascript/legacy-javascript.js';
-import type * as Handlers from '../handlers/handlers.js';
-import * as Helpers from '../helpers/helpers.js';
-import type * as Types from '../types/types.js';
-
-import {estimateCompressionRatioForScript, metricSavingsForWastedBytes} from './Common.js';
-import {
-  InsightCategory,
-  InsightKeys,
-  type InsightModel,
-  type InsightSetContext,
-  type PartialInsightModel,
-} from './types.js';
-
-const {detectLegacyJavaScript} = LegacyJavaScriptLib.LegacyJavaScript;
-
-export const UIStrings = {
-  /**
-   * @description Title of an insight that identifies polyfills for modern JavaScript features, and recommends their removal.
-   */
-  title: 'Legacy JavaScript',
-  /**
-   * @description Description of an insight that identifies polyfills for modern JavaScript features, and recommends their removal.
-   */
-  description:
-      'Polyfills and transforms enable older browsers to use new JavaScript features. However, many aren\'t necessary for modern browsers. Consider modifying your JavaScript build process to not transpile [Baseline](https://web.dev/articles/baseline-and-polyfills) features, unless you know you must support older browsers. [Learn why most sites can deploy ES6+ code without transpiling](https://developer.chrome.com/docs/performance/insights/legacy-javascript)',
-  /** Label for a column in a data table; entries will be the individual JavaScript scripts. */
-  columnScript: 'Script',
-  /** Label for a column in a data table; entries will be the number of wasted bytes (aka the estimated savings in terms of bytes). */
-  columnWastedBytes: 'Wasted bytes',
-} as const;
-
-const str_ = i18n.i18n.registerUIStrings('models/trace/insights/LegacyJavaScript.ts', UIStrings);
-export const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-
-export interface PatternMatchResult {
-  name: string;
-  line: number;
-  column: number;
-}
-
-interface LegacyJavaScriptResult {
-  matches: PatternMatchResult[];
-  estimatedByteSavings: number;
-}
-
-type LegacyJavaScriptResults = Map<Handlers.ModelHandlers.Scripts.Script, LegacyJavaScriptResult>;
-
-export type LegacyJavaScriptInsightModel = InsightModel<typeof UIStrings, {
-  legacyJavaScriptResults: LegacyJavaScriptResults,
-}>;
-
-const BYTE_THRESHOLD = 5000;
-
-function finalize(partialModel: PartialInsightModel<LegacyJavaScriptInsightModel>): LegacyJavaScriptInsightModel {
-  const requests = [...partialModel.legacyJavaScriptResults.keys()].map(script => script.request).filter(e => !!e);
-
-  return {
-    insightKey: InsightKeys.LEGACY_JAVASCRIPT,
-    strings: UIStrings,
-    title: i18nString(UIStrings.title),
-    description: i18nString(UIStrings.description),
-    docs: 'https://developer.chrome.com/docs/performance/insights/legacy-javascript',
-    category: InsightCategory.ALL,
-    state: requests.length ? 'fail' : 'pass',
-    relatedEvents: [...new Set(requests)],
-    ...partialModel,
-  };
-}
-
-export function isLegacyJavaScript(model: InsightModel): model is LegacyJavaScriptInsightModel {
-  return model.insightKey === InsightKeys.LEGACY_JAVASCRIPT;
-}
-
-export function generateInsight(
-    data: Handlers.Types.HandlerData, context: InsightSetContext): LegacyJavaScriptInsightModel {
-  const scripts = data.Scripts.scripts.filter(script => {
-    if (script.frame !== context.frameId) {
-      return false;
-    }
-
-    if (script.url?.startsWith('chrome-extension://')) {
-      return false;
-    }
-
-    return Helpers.Timing.timestampIsInBounds(context.bounds, script.ts) ||
-        (script.request && Helpers.Timing.eventIsInBounds(script.request, context.bounds));
-  });
-
-  const legacyJavaScriptResults: LegacyJavaScriptResults = new Map();
-  const wastedBytesByRequestId = new Map<string, number>();
-
-  for (const script of scripts) {
-    if (!script.content || script.content.length < BYTE_THRESHOLD) {
-      continue;
-    }
-
-    const result = detectLegacyJavaScript(script.content, script.sourceMap);
-    if (result.estimatedByteSavings < BYTE_THRESHOLD) {
-      continue;
-    }
-
-    // Translate from resource size to transfer size.
-    const compressionRatio = estimateCompressionRatioForScript(script);
-    const transferSize = Math.round(result.estimatedByteSavings * compressionRatio);
-    result.estimatedByteSavings = transferSize;
-
-    legacyJavaScriptResults.set(script, result);
-
-    if (script.request) {
-      const requestId = script.request.args.data.requestId;
-      wastedBytesByRequestId.set(requestId, transferSize);
-    }
-  }
-
-  const sorted =
-      new Map([...legacyJavaScriptResults].sort((a, b) => b[1].estimatedByteSavings - a[1].estimatedByteSavings));
-
-  return finalize({
-    legacyJavaScriptResults: sorted,
-    metricSavings: metricSavingsForWastedBytes(wastedBytesByRequestId, context),
-    wastedBytes: wastedBytesByRequestId.values().reduce((acc, cur) => acc + cur, 0),
-  });
-}
-export function createOverlays(model: LegacyJavaScriptInsightModel): Types.Overlays.Overlay[] {
-  return [...model.legacyJavaScriptResults.keys()].map(script => script.request).filter(e => !!e).map(request => {
-    return {
-      type: 'ENTRY_OUTLINE',
-      entry: request,
-      outlineReason: 'ERROR',
-    };
-  });
-}

package/lib/front_end/models/trace/insights/Models.ts

@@ -1,22 +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.
-
-export * as Cache from './Cache.js';
-export * as CLSCulprits from './CLSCulprits.js';
-export * as DocumentLatency from './DocumentLatency.js';
-export * as DOMSize from './DOMSize.js';
-export * as DuplicatedJavaScript from './DuplicatedJavaScript.js';
-export * as FontDisplay from './FontDisplay.js';
-export * as ForcedReflow from './ForcedReflow.js';
-export * as ImageDelivery from './ImageDelivery.js';
-export * as INPBreakdown from './INPBreakdown.js';
-export * as LCPBreakdown from './LCPBreakdown.js';
-export * as LCPDiscovery from './LCPDiscovery.js';
-export * as LegacyJavaScript from './LegacyJavaScript.js';
-export * as ModernHTTP from './ModernHTTP.js';
-export * as NetworkDependencyTree from './NetworkDependencyTree.js';
-export * as RenderBlocking from './RenderBlocking.js';
-export * as SlowCSSSelector from './SlowCSSSelector.js';
-export * as ThirdParties from './ThirdParties.js';
-export * as Viewport from './Viewport.js';

package/lib/front_end/models/trace/insights/ModernHTTP.ts

@@ -1,257 +0,0 @@
-// Copyright 2025 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 i18n from '../../../core/i18n/i18n.js';
-import * as Platform from '../../../core/platform/platform.js';
-import * as Handlers from '../handlers/handlers.js';
-import * as Helpers from '../helpers/helpers.js';
-import type * as Lantern from '../lantern/lantern.js';
-import type * as Types from '../types/types.js';
-
-import {
-  InsightCategory,
-  InsightKeys,
-  type InsightModel,
-  type InsightSetContext,
-  type MetricSavings,
-  type PartialInsightModel,
-} from './types.js';
-
-export const UIStrings = {
-  /**
-   * @description Title of an insight that recommends using HTTP/2 over HTTP/1.1 because of the performance benefits. "HTTP" should not be translated.
-   */
-  title: 'Modern HTTP',
-  /**
-   * @description Description of an insight that recommends recommends using HTTP/2 over HTTP/1.1 because of the performance benefits. "HTTP" should not be translated.
-   */
-  description:
-      'HTTP/2 and HTTP/3 offer many benefits over HTTP/1.1, such as multiplexing. [Learn more about using modern HTTP](https://developer.chrome.com/docs/performance/insights/modern-http).',
-  /**
-   * @description Column header for a table where each cell represents a network request.
-   */
-  request: 'Request',
-  /**
-   * @description Column header for a table where each cell represents the protocol of a network request.
-   */
-  protocol: 'Protocol',
-  /**
-   * @description Text explaining that there were not requests that were slowed down by using HTTP/1.1. "HTTP/1.1" should not be translated.
-   */
-  noOldProtocolRequests:
-      'No requests used HTTP/1.1, or its current use of HTTP/1.1 does not present a significant optimization opportunity. HTTP/1.1 requests are only flagged if six or more static assets originate from the same origin, and they are not served from a local development environment or a third-party source.'
-} as const;
-
-const str_ = i18n.i18n.registerUIStrings('models/trace/insights/ModernHTTP.ts', UIStrings);
-export const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-
-export type ModernHTTPInsightModel = InsightModel<typeof UIStrings, {
-  http1Requests: Types.Events.SyntheticNetworkRequest[],
-}>;
-
-export function isModernHTTPInsight(model: InsightModel): model is ModernHTTPInsightModel {
-  return model.insightKey === InsightKeys.MODERN_HTTP;
-}
-
-/**
- * Determines whether a network request is a "static resource" that would benefit from H2 multiplexing.
- * XHRs, tracking pixels, etc generally don't benefit as much because they aren't requested en-masse
- * for the same origin at the exact same time.
- */
-function isMultiplexableStaticAsset(
-    request: Types.Events.SyntheticNetworkRequest, entityMappings: Handlers.Helpers.EntityMappings,
-    firstPartyEntity: Handlers.Helpers.Entity|null): boolean {
-  if (!Helpers.Network.STATIC_RESOURCE_TYPES.has(request.args.data.resourceType)) {
-    return false;
-  }
-
-  // Resources from third-parties that are less than 100 bytes are usually tracking pixels, not actual resources.
-  // They can masquerade as static types though (gifs, documents, etc)
-  if (request.args.data.decodedBodyLength < 100) {
-    const entity = entityMappings.entityByEvent.get(request);
-    if (entity) {
-      // Third-party assets are multiplexable in their first-party context.
-      if (firstPartyEntity?.name === entity.name) {
-        return true;
-      }
-      // Skip recognizable third-parties' requests.
-      if (!entity.isUnrecognized) {
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
-/**
- * Determine the set of resources that aren't HTTP/2 but should be.
- * We're a little conservative about what we surface for a few reasons:
- *
- *    - The simulator approximation of HTTP/2 is a little more generous than reality.
- *    - There's a bit of debate surrounding HTTP/2 due to its worse performance in environments with high packet loss. [1][2][3]
- *    - It's something that you'd have absolutely zero control over with a third-party (can't defer to fix it for example).
- *
- * Therefore, we only surface requests that were...
- *
- *    - Served over HTTP/1.1 or earlier
- *    - Served over an origin that serves at least 6 static asset requests
- *      (if there aren't more requests than browser's max/host, multiplexing isn't as big a deal)
- *    - Not served on localhost (h2 is a pain to deal with locally & and CI)
- *
- * [1] https://news.ycombinator.com/item?id=19086639
- * [2] https://www.twilio.com/blog/2017/10/http2-issues.html
- * [3] https://www.cachefly.com/http-2-is-not-a-magic-bullet/
- */
-export function determineHttp1Requests(
-    requests: Types.Events.SyntheticNetworkRequest[], entityMappings: Handlers.Helpers.EntityMappings,
-    firstPartyEntity: Handlers.Helpers.Entity|null): Types.Events.SyntheticNetworkRequest[] {
-  const http1Requests: Types.Events.SyntheticNetworkRequest[] = [];
-
-  const groupedByOrigin = new Map<string, Types.Events.SyntheticNetworkRequest[]>();
-  for (const record of requests) {
-    const url = new URL(record.args.data.url);
-    if (!isMultiplexableStaticAsset(record, entityMappings, firstPartyEntity)) {
-      continue;
-    }
-    if (Helpers.Network.isSyntheticNetworkRequestLocalhost(record)) {
-      continue;
-    }
-    const originRequests = Platform.MapUtilities.getWithDefault(groupedByOrigin, url.origin, () => []);
-    originRequests.push(record);
-  }
-
-  const seenURLs = new Set<string>();
-
-  for (const request of requests) {
-    // Skip duplicates.
-    if (seenURLs.has(request.args.data.url)) {
-      continue;
-    }
-
-    // Check if record is not served through the service worker, servicer worker uses http/1.1 as a protocol.
-    // These can generate false positives (bug: https://github.com/GoogleChrome/lighthouse/issues/7158).
-    if (request.args.data.fromServiceWorker) {
-      continue;
-    }
-
-    // Test the protocol to see if it was http/1.1.
-    const isOldHttp = /HTTP\/[01][.\d]?/i.test(request.args.data.protocol);
-    if (!isOldHttp) {
-      continue;
-    }
-
-    const url = new URL(request.args.data.url);
-
-    // Check if the origin has enough requests to bother flagging.
-    const group = groupedByOrigin.get(url.origin) || [];
-    if (group.length < 6) {
-      continue;
-    }
-
-    seenURLs.add(request.args.data.url);
-    http1Requests.push(request);
-  }
-
-  return http1Requests;
-}
-
-/**
- * Computes the estimated effect of all results being converted to http/2 on the provided graph.
- */
-function computeWasteWithGraph(
-    urlsToChange: Set<string>, graph: Lantern.Graph.Node, simulator: Lantern.Simulation.Simulator): Types.Timing.Milli {
-  const simulationBefore = simulator.simulate(graph);
-
-  // Update all the protocols to reflect implementing our recommendations
-  const originalProtocols = new Map();
-  graph.traverse(node => {
-    if (node.type !== 'network') {
-      return;
-    }
-    if (!urlsToChange.has(node.request.url)) {
-      return;
-    }
-
-    originalProtocols.set(node.request.requestId, node.request.protocol);
-    node.request.protocol = 'h2';
-  });
-
-  const simulationAfter = simulator.simulate(graph);
-
-  // Restore the original protocol after we've done our simulation
-  graph.traverse(node => {
-    if (node.type !== 'network') {
-      return;
-    }
-    const originalProtocol = originalProtocols.get(node.request.requestId);
-    if (originalProtocol === undefined) {
-      return;
-    }
-    node.request.protocol = originalProtocol;
-  });
-
-  const savings = simulationBefore.timeInMs - simulationAfter.timeInMs;
-
-  return Platform.NumberUtilities.floor(savings, 1 / 10) as Types.Timing.Milli;
-}
-
-function computeMetricSavings(
-    http1Requests: Types.Events.SyntheticNetworkRequest[], context: InsightSetContext): MetricSavings|undefined {
-  if (!context.navigation || !context.lantern) {
-    return;
-  }
-
-  const urlsToChange = new Set(http1Requests.map(r => r.args.data.url));
-
-  const fcpGraph = context.lantern.metrics.firstContentfulPaint.optimisticGraph;
-  const lcpGraph = context.lantern.metrics.largestContentfulPaint.optimisticGraph;
-
-  return {
-    FCP: computeWasteWithGraph(urlsToChange, fcpGraph, context.lantern.simulator),
-    LCP: computeWasteWithGraph(urlsToChange, lcpGraph, context.lantern.simulator),
-  };
-}
-
-function finalize(partialModel: PartialInsightModel<ModernHTTPInsightModel>): ModernHTTPInsightModel {
-  return {
-    insightKey: InsightKeys.MODERN_HTTP,
-    strings: UIStrings,
-    title: i18nString(UIStrings.title),
-    description: i18nString(UIStrings.description),
-    docs: 'https://developer.chrome.com/docs/performance/insights/modern-http',
-    category: InsightCategory.LCP,
-    state: partialModel.http1Requests.length > 0 ? 'fail' : 'pass',
-    ...partialModel,
-    relatedEvents: partialModel.http1Requests,
-  };
-}
-
-export function generateInsight(data: Handlers.Types.HandlerData, context: InsightSetContext): ModernHTTPInsightModel {
-  const isWithinContext = (event: Types.Events.Event): boolean => Helpers.Timing.eventIsInBounds(event, context.bounds);
-
-  const contextRequests = data.NetworkRequests.byTime.filter(isWithinContext);
-
-  const entityMappings = data.NetworkRequests.entityMappings;
-  const firstPartyUrl = context.navigation?.args.data?.documentLoaderURL ?? data.Meta.mainFrameURL;
-  const firstPartyEntity = Handlers.Helpers.getEntityForUrl(firstPartyUrl, entityMappings);
-  const http1Requests = determineHttp1Requests(contextRequests, entityMappings, firstPartyEntity ?? null);
-
-  return finalize({
-    http1Requests,
-    metricSavings: computeMetricSavings(http1Requests, context),
-  });
-}
-
-export function createOverlayForRequest(request: Types.Events.SyntheticNetworkRequest): Types.Overlays.EntryOutline {
-  return {
-    type: 'ENTRY_OUTLINE',
-    entry: request,
-    outlineReason: 'ERROR',
-  };
-}
-
-export function createOverlays(model: ModernHTTPInsightModel): Types.Overlays.Overlay[] {
-  return model.http1Requests.map(req => createOverlayForRequest(req)) ?? [];
-}