lighthouse 11.7.1 → 12.0.0

package/core/lib/lantern/metrics/max-potential-fid.js

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../types/lantern.js';
+import {Metric} from '../metric.js';
+import {BaseNode} from '../base-node.js';
+
+/** @typedef {import('../base-node.js').Node} Node */
+
+class MaxPotentialFID extends Metric {
+  /**
+   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   */
+  static get COEFFICIENTS() {
+    return {
+      intercept: 0,
+      optimistic: 0.5,
+      pessimistic: 0.5,
+    };
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @return {Node}
+   */
+  static getOptimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @return {Node}
+   */
+  static getPessimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result} simulation
+   * @param {import('../metric.js').Extras} extras
+   * @return {LH.Gatherer.Simulation.Result}
+   */
+  static getEstimateFromSimulation(simulation, extras) {
+    if (!extras.fcpResult) throw new Error('missing fcpResult');
+
+    // Intentionally use the opposite FCP estimate, a more pessimistic FCP means that more tasks
+    // are excluded from the FID computation, so a higher FCP means lower FID for same work.
+    const fcpTimeInMs = extras.optimistic
+      ? extras.fcpResult.pessimisticEstimate.timeInMs
+      : extras.fcpResult.optimisticEstimate.timeInMs;
+
+    const timings = MaxPotentialFID.getTimingsAfterFCP(
+      simulation.nodeTimings,
+      fcpTimeInMs
+    );
+
+    return {
+      timeInMs: Math.max(...timings.map(timing => timing.duration), 16),
+      nodeTimings: simulation.nodeTimings,
+    };
+  }
+
+  /**
+   * @param {Lantern.Simulation.MetricComputationDataInput} data
+   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static compute(data, extras) {
+    const fcpResult = extras?.fcpResult;
+    if (!fcpResult) {
+      throw new Error('FCP is required to calculate the Max Potential FID metric');
+    }
+
+    return super.compute(data, extras);
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {number} fcpTimeInMs
+   * @return {Array<{duration: number}>}
+   */
+  static getTimingsAfterFCP(nodeTimings, fcpTimeInMs) {
+    return Array.from(nodeTimings.entries())
+      .filter(([node, timing]) => node.type === BaseNode.TYPES.CPU && timing.endTime > fcpTimeInMs)
+      .map(([_, timing]) => timing);
+  }
+}
+
+export {MaxPotentialFID};

package/core/lib/lantern/metrics/speed-index.d.ts

@@ -0,0 +1,38 @@
+export type Node = import('../base-node.js').Node;
+/** @typedef {import('../base-node.js').Node} Node */
+export class SpeedIndex extends Metric {
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getOptimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {LH.Gatherer.Simulation.Result} simulationResult
+     * @param {import('../metric.js').Extras} extras
+     * @return {LH.Gatherer.Simulation.Result}
+     */
+    static getEstimateFromSimulation(simulationResult: LH.Gatherer.Simulation.Result, extras: import('../metric.js').Extras): LH.Gatherer.Simulation.Result;
+    /**
+     * Approximate speed index using layout events from the simulated node timings.
+     * The layout-based speed index is the weighted average of the endTime of CPU nodes that contained
+     * a 'Layout' task. log(duration) is used as the weight to stand for "significance" to the page.
+     *
+     * If no layout events can be found or the endTime of a CPU task is too early, FCP is used instead.
+     *
+     * This approach was determined after evaluating the accuracy/complexity tradeoff of many
+     * different methods. Read more in the evaluation doc.
+     *
+     * @see https://docs.google.com/document/d/1qJWXwxoyVLVadezIp_Tgdk867G3tDNkkVRvUJSH3K1E/edit#
+     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+     * @param {number} fcpTimeInMs
+     * @return {number}
+     */
+    static computeLayoutBasedSpeedIndex(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
+}
+import { Metric } from '../metric.js';
+//# sourceMappingURL=speed-index.d.ts.map

package/core/lib/lantern/metrics/speed-index.js

@@ -0,0 +1,144 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../types/lantern.js';
+import {Metric} from '../metric.js';
+import {BaseNode} from '../base-node.js';
+
+const mobileSlow4GRtt = 150;
+
+/** @typedef {import('../base-node.js').Node} Node */
+
+class SpeedIndex extends Metric {
+  /**
+   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   */
+  static get COEFFICIENTS() {
+    return {
+      // Note that the optimistic estimate is based on the real observed speed index rather than a
+      // real lantern graph (and the final estimate will be Math.max(FCP, Speed Index)).
+      intercept: 0,
+      optimistic: 1.4,
+      pessimistic: 0.4,
+    };
+  }
+
+  /**
+   * @param {number} rttMs
+   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   */
+  static getScaledCoefficients(rttMs) { // eslint-disable-line no-unused-vars
+    // We want to scale our default coefficients based on the speed of the connection.
+    // We will linearly interpolate coefficients for the passed-in rttMs based on two pre-determined points:
+    //   1. Baseline point of 30 ms RTT where Speed Index should be a ~50/50 blend of optimistic/pessimistic.
+    //      30 ms was based on a typical home WiFi connection's actual RTT.
+    //      Coefficients here follow from the fact that the optimistic estimate should be very close
+    //      to reality at this connection speed and the pessimistic estimate compensates for minor
+    //      connection speed differences.
+    //   2. Default throttled point of 150 ms RTT where the default coefficients have been determined to be most accurate.
+    //      Coefficients here were determined through thorough analysis and linear regression on the
+    //      lantern test data set. See core/scripts/test-lantern.sh for more detail.
+    // While the coefficients haven't been analyzed at the interpolated points, it's our current best effort.
+    const defaultCoefficients = this.COEFFICIENTS;
+    const defaultRttExcess = mobileSlow4GRtt - 30;
+    const multiplier = Math.max((rttMs - 30) / defaultRttExcess, 0);
+
+    return {
+      intercept: defaultCoefficients.intercept * multiplier,
+      optimistic: 0.5 + (defaultCoefficients.optimistic - 0.5) * multiplier,
+      pessimistic: 0.5 + (defaultCoefficients.pessimistic - 0.5) * multiplier,
+    };
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @return {Node}
+   */
+  static getOptimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @return {Node}
+   */
+  static getPessimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result} simulationResult
+   * @param {import('../metric.js').Extras} extras
+   * @return {LH.Gatherer.Simulation.Result}
+   */
+  static getEstimateFromSimulation(simulationResult, extras) {
+    if (!extras.fcpResult) throw new Error('missing fcpResult');
+    if (!extras.speedline) throw new Error('missing speedline');
+
+    const fcpTimeInMs = extras.fcpResult.pessimisticEstimate.timeInMs;
+    const estimate = extras.optimistic
+      ? extras.speedline.speedIndex
+      : SpeedIndex.computeLayoutBasedSpeedIndex(simulationResult.nodeTimings, fcpTimeInMs);
+    return {
+      timeInMs: estimate,
+      nodeTimings: simulationResult.nodeTimings,
+    };
+  }
+
+  /**
+   * @param {Lantern.Simulation.MetricComputationDataInput} data
+   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static async compute(data, extras) {
+    const fcpResult = extras?.fcpResult;
+    if (!fcpResult) {
+      throw new Error('FCP is required to calculate the SpeedIndex metric');
+    }
+
+    const metricResult = await super.compute(data, extras);
+    metricResult.timing = Math.max(metricResult.timing, fcpResult.timing);
+    return metricResult;
+  }
+
+  /**
+   * Approximate speed index using layout events from the simulated node timings.
+   * The layout-based speed index is the weighted average of the endTime of CPU nodes that contained
+   * a 'Layout' task. log(duration) is used as the weight to stand for "significance" to the page.
+   *
+   * If no layout events can be found or the endTime of a CPU task is too early, FCP is used instead.
+   *
+   * This approach was determined after evaluating the accuracy/complexity tradeoff of many
+   * different methods. Read more in the evaluation doc.
+   *
+   * @see https://docs.google.com/document/d/1qJWXwxoyVLVadezIp_Tgdk867G3tDNkkVRvUJSH3K1E/edit#
+   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {number} fcpTimeInMs
+   * @return {number}
+   */
+  static computeLayoutBasedSpeedIndex(nodeTimings, fcpTimeInMs) {
+    /** @type {Array<{time: number, weight: number}>} */
+    const layoutWeights = [];
+    for (const [node, timing] of nodeTimings.entries()) {
+      if (node.type !== BaseNode.TYPES.CPU) continue;
+
+      if (node.childEvents.some(x => x.name === 'Layout')) {
+        const timingWeight = Math.max(Math.log2(timing.endTime - timing.startTime), 0);
+        layoutWeights.push({time: timing.endTime, weight: timingWeight});
+      }
+    }
+
+    const totalWeightedTime = layoutWeights
+      .map(evt => evt.weight * Math.max(evt.time, fcpTimeInMs))
+      .reduce((a, b) => a + b, 0);
+    const totalWeight = layoutWeights.map(evt => evt.weight).reduce((a, b) => a + b, 0);
+
+    if (!totalWeight) return fcpTimeInMs;
+    return totalWeightedTime / totalWeight;
+  }
+}
+
+export {SpeedIndex};

package/core/lib/lantern/metrics/total-blocking-time.d.ts

@@ -0,0 +1,31 @@
+export type Node = import('../base-node.js').Node;
+/** @typedef {import('../base-node.js').Node} Node */
+export class TotalBlockingTime extends Metric {
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getOptimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {LH.Gatherer.Simulation.Result} simulation
+     * @param {import('../metric.js').Extras} extras
+     * @return {LH.Gatherer.Simulation.Result}
+     */
+    static getEstimateFromSimulation(simulation: LH.Gatherer.Simulation.Result, extras: import('../metric.js').Extras): LH.Gatherer.Simulation.Result;
+    /**
+     * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+     * @param {number} minDurationMs
+     */
+    static getTopLevelEvents(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], minDurationMs: number): {
+        start: number;
+        end: number;
+        duration: number;
+    }[];
+}
+import { Metric } from '../metric.js';
+//# sourceMappingURL=total-blocking-time.d.ts.map

package/core/lib/lantern/metrics/total-blocking-time.js

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../types/lantern.js';
+import {Metric} from '../metric.js';
+import {BaseNode} from '../base-node.js';
+import {BLOCKING_TIME_THRESHOLD, calculateSumOfBlockingTime} from '../../../computed/metrics/tbt-utils.js';
+
+/** @typedef {import('../base-node.js').Node} Node */
+
+class TotalBlockingTime extends Metric {
+  /**
+   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   */
+  static get COEFFICIENTS() {
+    return {
+      intercept: 0,
+      optimistic: 0.5,
+      pessimistic: 0.5,
+    };
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @return {Node}
+   */
+  static getOptimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {Node} dependencyGraph
+   * @return {Node}
+   */
+  static getPessimisticGraph(dependencyGraph) {
+    return dependencyGraph;
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result} simulation
+   * @param {import('../metric.js').Extras} extras
+   * @return {LH.Gatherer.Simulation.Result}
+   */
+  static getEstimateFromSimulation(simulation, extras) {
+    if (!extras.fcpResult) throw new Error('missing fcpResult');
+    if (!extras.interactiveResult) throw new Error('missing interactiveResult');
+
+    // Intentionally use the opposite FCP estimate. A pessimistic FCP is higher than equal to an
+    // optimistic FCP, which means potentially more tasks are excluded from the Total Blocking Time
+    // computation. So a more pessimistic FCP gives a more optimistic Total Blocking Time for the
+    // same work.
+    const fcpTimeInMs = extras.optimistic
+      ? extras.fcpResult.pessimisticEstimate.timeInMs
+      : extras.fcpResult.optimisticEstimate.timeInMs;
+
+    // Similarly, we always have pessimistic TTI >= optimistic TTI. Therefore, picking optimistic
+    // TTI means our window of interest is smaller and thus potentially more tasks are excluded from
+    // Total Blocking Time computation, yielding a lower (more optimistic) Total Blocking Time value
+    // for the same work.
+    const interactiveTimeMs = extras.optimistic
+      ? extras.interactiveResult.optimisticEstimate.timeInMs
+      : extras.interactiveResult.pessimisticEstimate.timeInMs;
+
+    const minDurationMs = BLOCKING_TIME_THRESHOLD;
+
+    const events = TotalBlockingTime.getTopLevelEvents(
+      simulation.nodeTimings,
+      minDurationMs
+    );
+
+    return {
+      timeInMs: calculateSumOfBlockingTime(
+        events,
+        fcpTimeInMs,
+        interactiveTimeMs
+      ),
+      nodeTimings: simulation.nodeTimings,
+    };
+  }
+
+  /**
+   * @param {Lantern.Simulation.MetricComputationDataInput} data
+   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<LH.Artifacts.LanternMetric>}
+   */
+  static async compute(data, extras) {
+    const fcpResult = extras?.fcpResult;
+    if (!fcpResult) {
+      throw new Error('FCP is required to calculate the TBT metric');
+    }
+
+    const interactiveResult = extras?.fcpResult;
+    if (!interactiveResult) {
+      throw new Error('Interactive is required to calculate the TBT metric');
+    }
+
+    return super.compute(data, extras);
+  }
+
+  /**
+   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {number} minDurationMs
+   */
+  static getTopLevelEvents(nodeTimings, minDurationMs) {
+    /** @type {Array<{start: number, end: number, duration: number}>}
+     */
+    const events = [];
+
+    for (const [node, timing] of nodeTimings.entries()) {
+      if (node.type !== BaseNode.TYPES.CPU) continue;
+      // Filtering out events below minimum duration.
+      if (timing.duration < minDurationMs) continue;
+
+      events.push({
+        start: timing.startTime,
+        end: timing.endTime,
+        duration: timing.duration,
+      });
+    }
+
+    return events;
+  }
+}
+
+export {TotalBlockingTime};

package/core/lib/lantern/network-node.js

@@ -7,8 +7,32 @@
 import * as Lantern from './types/lantern.js';
 import {NetworkRequestTypes} from './lantern.js';
 import {BaseNode} from './base-node.js';
-// TODO(15841): bring impl of isNonNetworkRequest inside lantern and remove this.
-import UrlUtils from '../url-utils.js';
+
+const NON_NETWORK_SCHEMES = [
+  'blob', // @see https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
+  'data', // @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
+  'intent', // @see https://developer.chrome.com/docs/multidevice/android/intents/
+  'file', // @see https://en.wikipedia.org/wiki/File_URI_scheme
+  'filesystem', // @see https://developer.mozilla.org/en-US/docs/Web/API/FileSystem
+  'chrome-extension',
+];
+
+/**
+ * Use `NetworkRequest.isNonNetworkRequest(req)` if working with a request.
+ * Note: the `protocol` field from CDP can be 'h2', 'http', (not 'https'!) or it'll be url's scheme.
+ *   https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/protocol/network_handler.cc;l=598-611;drc=56d4a9a9deb30be73adcee8737c73bcb2a5ab64f
+ * However, a `new URL(href).protocol` has a colon suffix.
+ *   https://url.spec.whatwg.org/#dom-url-protocol
+ * A URL's `scheme` is specced as the `protocol` sans-colon, but isn't exposed on a URL object.
+ * This method can take all 3 of these string types as a parameter.
+ * @param {string} protocol Either a networkRequest's `protocol` per CDP or a `new URL(href).protocol`
+ * @return {boolean}
+ */
+function isNonNetworkProtocol(protocol) {
+  // Strip off any colon
+  const urlScheme = protocol.includes(':') ? protocol.slice(0, protocol.indexOf(':')) : protocol;
+  return NON_NETWORK_SCHEMES.includes(urlScheme);
+}
 
 /**
  * @template [T=any]
@@ -75,9 +99,9 @@ class NetworkNode extends BaseNode {
    */
   get isNonNetworkProtocol() {
     // The 'protocol' field in devtools a string more like a `scheme`
-    return UrlUtils.isNonNetworkProtocol(this.request.protocol) ||
+    return isNonNetworkProtocol(this.request.protocol) ||
       // But `protocol` can fail to be populated if the request fails, so fallback to scheme.
-      UrlUtils.isNonNetworkProtocol(this.request.parsedURL.scheme);
+      isNonNetworkProtocol(this.request.parsedURL.scheme);
   }
 
   /**

package/core/lib/lantern/page-dependency-graph.d.ts

@@ -18,10 +18,10 @@ export class PageDependencyGraph {
      */
     static getNetworkNodeOutput(networkRecords: Array<Lantern.NetworkRequest>): NetworkNodeOutput;
     /**
-     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @param {LH.TraceEvent[]} mainThreadEvents
      * @return {Array<CPUNode>}
      */
-    static getCPUNodes({ mainThreadEvents }: LH.Artifacts.ProcessedTrace): Array<CPUNode>;
+    static getCPUNodes(mainThreadEvents: LH.TraceEvent[]): Array<CPUNode>;
     /**
      * @param {NetworkNode} rootNode
      * @param {NetworkNodeOutput} networkNodeOutput
@@ -40,12 +40,12 @@ export class PageDependencyGraph {
      */
     static _pruneNode(node: Node): void;
     /**
-     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @param {LH.TraceEvent[]} mainThreadEvents
      * @param {Array<Lantern.NetworkRequest>} networkRecords
      * @param {URLArtifact} URL
      * @return {Node}
      */
-    static createGraph(processedTrace: LH.Artifacts.ProcessedTrace, networkRecords: Array<Lantern.NetworkRequest>, URL: URLArtifact): Node;
+    static createGraph(mainThreadEvents: LH.TraceEvent[], networkRecords: Array<Lantern.NetworkRequest>, URL: URLArtifact): Node;
     /**
      *
      * @param {Node} rootNode

package/core/lib/lantern/page-dependency-graph.js

@@ -109,10 +109,10 @@ class PageDependencyGraph {
   }
 
   /**
-   * @param {LH.Artifacts.ProcessedTrace} processedTrace
+   * @param {LH.TraceEvent[]} mainThreadEvents
    * @return {Array<CPUNode>}
    */
-  static getCPUNodes({mainThreadEvents}) {
+  static getCPUNodes(mainThreadEvents) {
     /** @type {Array<CPUNode>} */
     const nodes = [];
     let i = 0;
@@ -128,6 +128,9 @@ class PageDependencyGraph {
         continue;
       }
 
+      /** @type {number|undefined} */
+      let correctedEndTs = undefined;
+
       // Capture all events that occurred within the task
       /** @type {Array<LH.TraceEvent>} */
       const children = [];
@@ -136,10 +139,19 @@ class PageDependencyGraph {
         i < mainThreadEvents.length && mainThreadEvents[i].ts < endTime;
         i++
       ) {
+        // Temporary fix for a Chrome bug where some RunTask events can be overlapping.
+        // We correct that here be ensuring each RunTask ends at least 1 microsecond before the next
+        // https://github.com/GoogleChrome/lighthouse/issues/15896
+        // https://issues.chromium.org/issues/329678173
+        if (TraceProcessor.isScheduleableTask(mainThreadEvents[i]) && mainThreadEvents[i].dur) {
+          correctedEndTs = mainThreadEvents[i].ts - 1;
+          break;
+        }
+
         children.push(mainThreadEvents[i]);
       }
 
-      nodes.push(new CPUNode(evt, children));
+      nodes.push(new CPUNode(evt, children, correctedEndTs));
     }
 
     return nodes;
@@ -359,7 +371,7 @@ class PageDependencyGraph {
         isFirst = foundFirstParse = true;
       }
 
-      if (isFirst || node.event.dur >= minimumEvtDur) {
+      if (isFirst || node.duration >= minimumEvtDur) {
         // Don't prune this node. The task is long / important so it will impact simulation.
         continue;
       }
@@ -393,14 +405,14 @@ class PageDependencyGraph {
   }
 
   /**
-   * @param {LH.Artifacts.ProcessedTrace} processedTrace
+   * @param {LH.TraceEvent[]} mainThreadEvents
    * @param {Array<Lantern.NetworkRequest>} networkRecords
    * @param {URLArtifact} URL
    * @return {Node}
    */
-  static createGraph(processedTrace, networkRecords, URL) {
+  static createGraph(mainThreadEvents, networkRecords, URL) {
     const networkNodeOutput = PageDependencyGraph.getNetworkNodeOutput(networkRecords);
-    const cpuNodes = PageDependencyGraph.getCPUNodes(processedTrace);
+    const cpuNodes = PageDependencyGraph.getCPUNodes(mainThreadEvents);
     const {requestedUrl, mainDocumentUrl} = URL;
     if (!requestedUrl) throw new Error('requestedUrl is required to get the root request');
     if (!mainDocumentUrl) throw new Error('mainDocumentUrl is required to get the main resource');

package/core/lib/lantern/simulator/connection-pool.d.ts

@@ -19,27 +19,17 @@ export class ConnectionPool {
     _initializeConnections(): void;
     /**
      * @param {Array<TcpConnection>} connections
-     * @param {{ignoreConnectionReused?: boolean, observedConnectionWasReused: boolean}} options
      */
-    _findAvailableConnectionWithLargestCongestionWindow(connections: Array<TcpConnection>, options: {
-        ignoreConnectionReused?: boolean | undefined;
-        observedConnectionWasReused: boolean;
-    }): TcpConnection | null;
+    _findAvailableConnectionWithLargestCongestionWindow(connections: Array<TcpConnection>): TcpConnection | null;
     /**
      * This method finds an available connection to the origin specified by the network record or null
      * if no connection was available. If returned, connection will not be available for other network
      * records until release is called.
      *
-     * If ignoreConnectionReused is true, acquire will consider all connections not in use as available.
-     * Otherwise, only connections that have matching "warmth" are considered available.
-     *
      * @param {Lantern.NetworkRequest} record
-     * @param {{ignoreConnectionReused?: boolean}} options
      * @return {?TcpConnection}
      */
-    acquire(record: Lantern.NetworkRequest, options?: {
-        ignoreConnectionReused?: boolean;
-    }): TcpConnection | null;
+    acquire(record: Lantern.NetworkRequest): TcpConnection | null;
     /**
      * Return the connection currently being used to fetch a record. If no connection
      * currently being used for this record, an error will be thrown.

package/core/lib/lantern/simulator/connection-pool.js

@@ -85,24 +85,13 @@ export class ConnectionPool {
 
   /**
    * @param {Array<TcpConnection>} connections
-   * @param {{ignoreConnectionReused?: boolean, observedConnectionWasReused: boolean}} options
    */
-  _findAvailableConnectionWithLargestCongestionWindow(connections, options) {
-    const {ignoreConnectionReused, observedConnectionWasReused} = options;
-
+  _findAvailableConnectionWithLargestCongestionWindow(connections) {
     /** @type {TcpConnection|null} */
     let maxConnection = null;
     for (let i = 0; i < connections.length; i++) {
       const connection = connections[i];
 
-      // Normally, we want to make sure the connection warmth matches the state of the record
-      // we're acquiring for. Do this check first since it's the common case and cheaper than our
-      // "in use" check below.
-      // Use the _warmed property instead of the getter because this is a surprisingly hot code path.
-      if (!ignoreConnectionReused && connection._warmed !== observedConnectionWasReused) {
-        continue;
-      }
-
       // Connections that are in use are never available.
       if (this._connectionsInUse.has(connection)) {
         continue;
@@ -121,23 +110,15 @@ export class ConnectionPool {
    * if no connection was available. If returned, connection will not be available for other network
    * records until release is called.
    *
-   * If ignoreConnectionReused is true, acquire will consider all connections not in use as available.
-   * Otherwise, only connections that have matching "warmth" are considered available.
-   *
    * @param {Lantern.NetworkRequest} record
-   * @param {{ignoreConnectionReused?: boolean}} options
    * @return {?TcpConnection}
    */
-  acquire(record, options = {}) {
+  acquire(record) {
     if (this._connectionsByRecord.has(record)) throw new Error('Record already has a connection');
 
     const origin = record.parsedURL.securityOrigin;
-    const observedConnectionWasReused = !!this._connectionReusedByRequestId.get(record.requestId);
     const connections = this._connectionsByOrigin.get(origin) || [];
-    const connectionToUse = this._findAvailableConnectionWithLargestCongestionWindow(connections, {
-      ignoreConnectionReused: options.ignoreConnectionReused,
-      observedConnectionWasReused,
-    });
+    const connectionToUse = this._findAvailableConnectionWithLargestCongestionWindow(connections);
 
     if (!connectionToUse) return null;