lighthouse 12.0.0 → 12.1.0-dev.20240619

package/core/lib/lantern/metrics/MetricTestUtils.js

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as TraceEngine from '@paulirish/trace_engine';
+
+import * as Lantern from '../lantern.js';
+import {polyfillDOMRect} from '../../polyfill-dom-rect.js';
+
+polyfillDOMRect();
+
+/**
+ * @param {TraceEngine.Types.TraceEvents.TraceEventData[]} traceEvents
+ */
+async function runTraceEngine(traceEvents) {
+  const processor = TraceEngine.Processor.TraceProcessor.createWithAllHandlers();
+  await processor.parse(traceEvents);
+  if (!processor.traceParsedData) throw new Error('No data');
+  return processor.traceParsedData;
+}
+
+/**
+ * @param {{trace: Lantern.Trace, settings?: Lantern.Simulation.Settings, URL?: Lantern.Simulation.URL}} opts
+ */
+async function getComputationDataFromFixture({trace, settings, URL}) {
+  settings = settings ?? /** @type {Lantern.Simulation.Settings} */({});
+  if (!settings.throttlingMethod) settings.throttlingMethod = 'simulate';
+  const traceEngineData = await runTraceEngine(
+    /** @type {TraceEngine.Types.TraceEvents.TraceEventData[]} */ (trace.traceEvents)
+  );
+  const requests =
+    Lantern.TraceEngineComputationData.createNetworkRequests(trace, traceEngineData);
+  const networkAnalysis = Lantern.Simulation.NetworkAnalyzer.analyze(requests);
+
+  return {
+    simulator: Lantern.Simulation.Simulator.createSimulator({...settings, networkAnalysis}),
+    graph: Lantern.TraceEngineComputationData.createGraph(requests, trace, traceEngineData, URL),
+    processedNavigation:
+      Lantern.TraceEngineComputationData.createProcessedNavigation(traceEngineData),
+  };
+}
+
+export {
+  runTraceEngine,
+  getComputationDataFromFixture,
+};

package/core/lib/lantern/metrics/{speed-index.d.ts → SpeedIndex.d.ts}

@@ -1,6 +1,6 @@
-export type Node = import('../base-node.js').Node;
-/** @typedef {import('../base-node.js').Node} Node */
-export class SpeedIndex extends Metric {
+export type Node = import('../BaseNode.js').Node;
+/** @typedef {import('../BaseNode.js').Node} Node */
+export class SpeedIndex extends Lantern.Metric {
     /**
      * @param {Node} dependencyGraph
      * @return {Node}
@@ -11,12 +11,6 @@ export class SpeedIndex extends Metric {
      * @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
@@ -28,11 +22,11 @@ export class SpeedIndex extends Metric {
      * 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 {Lantern.Simulation.Result['nodeTimings']} nodeTimings
      * @param {number} fcpTimeInMs
      * @return {number}
      */
-    static computeLayoutBasedSpeedIndex(nodeTimings: LH.Gatherer.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
+    static computeLayoutBasedSpeedIndex(nodeTimings: Lantern.Simulation.Result['nodeTimings'], fcpTimeInMs: number): number;
 }
-import { Metric } from '../metric.js';
-//# sourceMappingURL=speed-index.d.ts.map
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=SpeedIndex.d.ts.map

package/core/lib/lantern/metrics/{speed-index.js → SpeedIndex.js}

@@ -4,17 +4,15 @@
  * 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 * as Lantern from '../lantern.js';
 
 const mobileSlow4GRtt = 150;
 
-/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../BaseNode.js').Node} Node */
 
-class SpeedIndex extends Metric {
+class SpeedIndex extends Lantern.Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -28,7 +26,7 @@ class SpeedIndex extends Metric {
 
   /**
    * @param {number} rttMs
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.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.
@@ -70,17 +68,17 @@ class SpeedIndex extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result} simulationResult
-   * @param {import('../metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @param {Lantern.Simulation.Result} simulationResult
+   * @param {import('../Metric.js').Extras} extras
+   * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulationResult, extras) {
     if (!extras.fcpResult) throw new Error('missing fcpResult');
-    if (!extras.speedline) throw new Error('missing speedline');
+    if (extras.observedSpeedIndex === undefined) throw new Error('missing observedSpeedIndex');
 
     const fcpTimeInMs = extras.fcpResult.pessimisticEstimate.timeInMs;
     const estimate = extras.optimistic
-      ? extras.speedline.speedIndex
+      ? extras.observedSpeedIndex
       : SpeedIndex.computeLayoutBasedSpeedIndex(simulationResult.nodeTimings, fcpTimeInMs);
     return {
       timeInMs: estimate,
@@ -90,8 +88,8 @@ class SpeedIndex extends Metric {
 
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<Lantern.Metrics.Result>}
    */
   static async compute(data, extras) {
     const fcpResult = extras?.fcpResult;
@@ -115,7 +113,7 @@ class SpeedIndex extends Metric {
    * 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 {Lantern.Simulation.Result['nodeTimings']} nodeTimings
    * @param {number} fcpTimeInMs
    * @return {number}
    */
@@ -123,7 +121,7 @@ class SpeedIndex extends Metric {
     /** @type {Array<{time: number, weight: number}>} */
     const layoutWeights = [];
     for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== BaseNode.TYPES.CPU) continue;
+      if (node.type !== Lantern.BaseNode.TYPES.CPU) continue;
 
       if (node.childEvents.some(x => x.name === 'Layout')) {
         const timingWeight = Math.max(Math.log2(timing.endTime - timing.startTime), 0);

package/core/lib/lantern/metrics/SpeedIndex.test.js

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../lantern.js';
+import {readJson} from '../../../test/test-utils.js';
+import {getComputationDataFromFixture} from './MetricTestUtils.js';
+
+const {SpeedIndex, FirstContentfulPaint} = Lantern.Metrics;
+
+const trace = readJson('../../../test/fixtures/artifacts/progressive-app/trace.json', import.meta);
+
+const defaultThrottling = Lantern.Simulation.Constants.throttling.mobileSlow4G;
+
+describe('Metrics: Lantern Speed Index', () => {
+  it('should compute predicted value', async () => {
+    const data = await getComputationDataFromFixture({trace});
+    // TODO: observedSpeedIndex is from the Speedline library, and is used for optimistic
+    // mode. At the moment callers must pass the result into Lantern.
+    const observedSpeedIndex = 379.04474997520487;
+    const result = await SpeedIndex.compute(data, {
+      fcpResult: await FirstContentfulPaint.compute(data),
+      observedSpeedIndex,
+    });
+
+    expect({
+      timing: Math.round(result.timing),
+      optimistic: Math.round(result.optimisticEstimate.timeInMs),
+      pessimistic: Math.round(result.pessimisticEstimate.timeInMs)}).
+toMatchInlineSnapshot(`
+Object {
+  "optimistic": 379,
+  "pessimistic": 1122,
+  "timing": 1107,
+}
+`);
+  });
+
+  it('should compute predicted value for different settings', async () => {
+    const settings = {throttlingMethod: 'simulate', throttling: {...defaultThrottling, rttMs: 300}};
+    const data = await getComputationDataFromFixture({trace, settings});
+    const observedSpeedIndex = 379.04474997520487;
+    const result = await SpeedIndex.compute(data, {
+      fcpResult: await FirstContentfulPaint.compute(data),
+      observedSpeedIndex,
+    });
+
+    expect({
+      timing: Math.round(result.timing),
+      optimistic: Math.round(result.optimisticEstimate.timeInMs),
+      pessimistic: Math.round(result.pessimisticEstimate.timeInMs)}).
+toMatchInlineSnapshot(`
+Object {
+  "optimistic": 379,
+  "pessimistic": 2022,
+  "timing": 2007,
+}
+`);
+  });
+
+  it('should not scale coefficients at default', async () => {
+    const result = SpeedIndex.getScaledCoefficients(defaultThrottling.rttMs);
+    expect(result).toEqual(SpeedIndex.COEFFICIENTS);
+  });
+
+  it('should scale coefficients back', async () => {
+    const result = SpeedIndex.getScaledCoefficients(5);
+    expect(result).toEqual({intercept: 0, pessimistic: 0.5, optimistic: 0.5});
+  });
+
+  it('should scale coefficients forward', async () => {
+    const result = SpeedIndex.getScaledCoefficients(300);
+    expect(result).toMatchInlineSnapshot(`
+      Object {
+        "intercept": 0,
+        "optimistic": 2.525,
+        "pessimistic": 0.275,
+      }
+    `);
+  });
+});

package/core/lib/lantern/metrics/TotalBlockingTime.d.ts

@@ -0,0 +1,25 @@
+export type Node = import('../BaseNode.js').Node;
+/** @typedef {import('../BaseNode.js').Node} Node */
+export class TotalBlockingTime extends Lantern.Metric {
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getOptimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Node} dependencyGraph
+     * @return {Node}
+     */
+    static getPessimisticGraph(dependencyGraph: Node): Node;
+    /**
+     * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
+     * @param {number} minDurationMs
+     */
+    static getTopLevelEvents(nodeTimings: Lantern.Simulation.Result['nodeTimings'], minDurationMs: number): {
+        start: number;
+        end: number;
+        duration: number;
+    }[];
+}
+import * as Lantern from '../lantern.js';
+//# sourceMappingURL=TotalBlockingTime.d.ts.map

package/core/lib/lantern/metrics/{total-blocking-time.js → TotalBlockingTime.js}

@@ -4,16 +4,13 @@
  * 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';
+import * as Lantern from '../lantern.js';
 
-/** @typedef {import('../base-node.js').Node} Node */
+/** @typedef {import('../BaseNode.js').Node} Node */
 
-class TotalBlockingTime extends Metric {
+class TotalBlockingTime extends Lantern.Metric {
   /**
-   * @return {LH.Gatherer.Simulation.MetricCoefficients}
+   * @return {Lantern.Simulation.MetricCoefficients}
    */
   static get COEFFICIENTS() {
     return {
@@ -40,9 +37,9 @@ class TotalBlockingTime extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result} simulation
-   * @param {import('../metric.js').Extras} extras
-   * @return {LH.Gatherer.Simulation.Result}
+   * @param {Lantern.Simulation.Result} simulation
+   * @param {import('../Metric.js').Extras} extras
+   * @return {Lantern.Simulation.Result}
    */
   static getEstimateFromSimulation(simulation, extras) {
     if (!extras.fcpResult) throw new Error('missing fcpResult');
@@ -64,7 +61,7 @@ class TotalBlockingTime extends Metric {
       ? extras.interactiveResult.optimisticEstimate.timeInMs
       : extras.interactiveResult.pessimisticEstimate.timeInMs;
 
-    const minDurationMs = BLOCKING_TIME_THRESHOLD;
+    const minDurationMs = Lantern.TBTUtils.BLOCKING_TIME_THRESHOLD;
 
     const events = TotalBlockingTime.getTopLevelEvents(
       simulation.nodeTimings,
@@ -72,7 +69,7 @@ class TotalBlockingTime extends Metric {
     );
 
     return {
-      timeInMs: calculateSumOfBlockingTime(
+      timeInMs: Lantern.TBTUtils.calculateSumOfBlockingTime(
         events,
         fcpTimeInMs,
         interactiveTimeMs
@@ -83,8 +80,8 @@ class TotalBlockingTime extends Metric {
 
   /**
    * @param {Lantern.Simulation.MetricComputationDataInput} data
-   * @param {Omit<import('../metric.js').Extras, 'optimistic'>=} extras
-   * @return {Promise<LH.Artifacts.LanternMetric>}
+   * @param {Omit<import('../Metric.js').Extras, 'optimistic'>=} extras
+   * @return {Promise<Lantern.Metrics.Result>}
    */
   static async compute(data, extras) {
     const fcpResult = extras?.fcpResult;
@@ -101,7 +98,7 @@ class TotalBlockingTime extends Metric {
   }
 
   /**
-   * @param {LH.Gatherer.Simulation.Result['nodeTimings']} nodeTimings
+   * @param {Lantern.Simulation.Result['nodeTimings']} nodeTimings
    * @param {number} minDurationMs
    */
   static getTopLevelEvents(nodeTimings, minDurationMs) {
@@ -110,7 +107,7 @@ class TotalBlockingTime extends Metric {
     const events = [];
 
     for (const [node, timing] of nodeTimings.entries()) {
-      if (node.type !== BaseNode.TYPES.CPU) continue;
+      if (node.type !== Lantern.BaseNode.TYPES.CPU) continue;
       // Filtering out events below minimum duration.
       if (timing.duration < minDurationMs) continue;
 

package/core/lib/lantern/metrics/__snapshots__/FirstContentfulPaint.test.js.snap

@@ -0,0 +1,11 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Metrics: Lantern FCP should compute predicted value 1`] = `
+Object {
+  "optimistic": 1107,
+  "optimisticNodeTimings": 4,
+  "pessimistic": 1107,
+  "pessimisticNodeTimings": 4,
+  "timing": 1107,
+}
+`;

package/core/lib/lantern/metrics/__snapshots__/Interactive.test.js.snap

@@ -0,0 +1,17 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Metrics: Lantern TTI should compute predicted value 1`] = `
+Object {
+  "optimistic": 1107,
+  "pessimistic": 1134,
+  "timing": 1122,
+}
+`;
+
+exports[`Metrics: Lantern TTI should compute predicted value on iframes with substantial layout 1`] = `
+Object {
+  "optimistic": 2372,
+  "pessimistic": 2386,
+  "timing": 2379,
+}
+`;

package/core/lib/lantern/metrics/metrics.d.ts

@@ -0,0 +1,9 @@
+export { FirstContentfulPaint } from "./FirstContentfulPaint.js";
+export { Interactive } from "./Interactive.js";
+export { LargestContentfulPaint } from "./LargestContentfulPaint.js";
+export { MaxPotentialFID } from "./MaxPotentialFID.js";
+export { SpeedIndex } from "./SpeedIndex.js";
+export { TotalBlockingTime } from "./TotalBlockingTime.js";
+export type Result<T = any> = Lantern.MetricResult<T>;
+import * as Lantern from '../types/lantern.js';
+//# sourceMappingURL=metrics.d.ts.map

package/core/lib/lantern/metrics/metrics.js

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as Lantern from '../types/lantern.js';
+
+export {FirstContentfulPaint} from './FirstContentfulPaint.js';
+export {Interactive} from './Interactive.js';
+export {LargestContentfulPaint} from './LargestContentfulPaint.js';
+export {MaxPotentialFID} from './MaxPotentialFID.js';
+export {SpeedIndex} from './SpeedIndex.js';
+export {TotalBlockingTime} from './TotalBlockingTime.js';
+
+/** @template [T=any] @typedef {Lantern.MetricResult<T>} Result */

package/core/lib/lantern/{simulator/connection-pool.d.ts → simulation/ConnectionPool.d.ts}

@@ -4,12 +4,12 @@ export class ConnectionPool {
      * @param {Required<Lantern.Simulation.Options>} options
      */
     constructor(records: Lantern.NetworkRequest[], options: Required<Lantern.Simulation.Options>);
-    _options: Required<Lantern.Simulation.Options>;
+    _options: Required<import("../types/lantern.js").Simulation.Options>;
     _records: Lantern.NetworkRequest<any>[];
     /** @type {Map<string, TcpConnection[]>} */
     _connectionsByOrigin: Map<string, TcpConnection[]>;
     /** @type {Map<Lantern.NetworkRequest, TcpConnection>} */
-    _connectionsByRecord: Map<Lantern.NetworkRequest, TcpConnection>;
+    _connectionsByRequest: Map<Lantern.NetworkRequest, TcpConnection>;
     _connectionsInUse: Set<any>;
     _connectionReusedByRequestId: Map<string, boolean>;
     /**
@@ -20,29 +20,29 @@ export class ConnectionPool {
     /**
      * @param {Array<TcpConnection>} connections
      */
-    _findAvailableConnectionWithLargestCongestionWindow(connections: Array<TcpConnection>): TcpConnection | null;
+    _findAvailableConnectionWithLargestCongestionWindow(connections: Array<TcpConnection>): Lantern.Simulation.TcpConnection | null;
     /**
-     * This method finds an available connection to the origin specified by the network record or null
+     * This method finds an available connection to the origin specified by the network request or null
      * if no connection was available. If returned, connection will not be available for other network
      * records until release is called.
      *
-     * @param {Lantern.NetworkRequest} record
+     * @param {Lantern.NetworkRequest} request
      * @return {?TcpConnection}
      */
-    acquire(record: Lantern.NetworkRequest): TcpConnection | null;
+    acquire(request: 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.
+     * Return the connection currently being used to fetch a request. If no connection
+     * currently being used for this request, an error will be thrown.
      *
-     * @param {Lantern.NetworkRequest} record
+     * @param {Lantern.NetworkRequest} request
      * @return {TcpConnection}
      */
-    acquireActiveConnectionFromRecord(record: Lantern.NetworkRequest): TcpConnection;
+    acquireActiveConnectionFromRequest(request: Lantern.NetworkRequest): TcpConnection;
     /**
-     * @param {Lantern.NetworkRequest} record
+     * @param {Lantern.NetworkRequest} request
      */
-    release(record: Lantern.NetworkRequest): void;
+    release(request: Lantern.NetworkRequest): void;
 }
-import * as Lantern from '../types/lantern.js';
-import { TcpConnection } from './tcp-connection.js';
-//# sourceMappingURL=connection-pool.d.ts.map
+import * as Lantern from '../lantern.js';
+import { TcpConnection } from './TcpConnection.js';
+//# sourceMappingURL=ConnectionPool.d.ts.map

package/core/lib/lantern/{simulator/connection-pool.js → simulation/ConnectionPool.js}

@@ -4,9 +4,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../types/lantern.js';
-import {NetworkAnalyzer} from './network-analyzer.js';
-import {TcpConnection} from './tcp-connection.js';
+import * as Lantern from '../lantern.js';
+import {NetworkAnalyzer} from './NetworkAnalyzer.js';
+import {TcpConnection} from './TcpConnection.js';
 
 const DEFAULT_SERVER_RESPONSE_TIME = 30;
 const TLS_SCHEMES = ['https', 'wss'];
@@ -27,7 +27,7 @@ export class ConnectionPool {
     /** @type {Map<string, TcpConnection[]>} */
     this._connectionsByOrigin = new Map();
     /** @type {Map<Lantern.NetworkRequest, TcpConnection>} */
-    this._connectionsByRecord = new Map();
+    this._connectionsByRequest = new Map();
     this._connectionsInUse = new Set();
     this._connectionReusedByRequestId = NetworkAnalyzer.estimateIfConnectionWasReused(records, {
       forceCoarseEstimates: true,
@@ -49,16 +49,16 @@ export class ConnectionPool {
     const serverResponseTimeByOrigin = this._options.serverResponseTimeByOrigin;
 
     const recordsByOrigin = NetworkAnalyzer.groupByOrigin(this._records);
-    for (const [origin, records] of recordsByOrigin.entries()) {
+    for (const [origin, requests] of recordsByOrigin.entries()) {
       const connections = [];
       const additionalRtt = additionalRttByOrigin.get(origin) || 0;
       const responseTime = serverResponseTimeByOrigin.get(origin) || DEFAULT_SERVER_RESPONSE_TIME;
 
-      for (const record of records) {
-        if (connectionReused.get(record.requestId)) continue;
+      for (const request of requests) {
+        if (connectionReused.get(request.requestId)) continue;
 
-        const isTLS = TLS_SCHEMES.includes(record.parsedURL.scheme);
-        const isH2 = record.protocol === 'h2';
+        const isTLS = TLS_SCHEMES.includes(request.parsedURL.scheme);
+        const isH2 = request.protocol === 'h2';
         const connection = new TcpConnection(
           this._options.rtt + additionalRtt,
           this._options.throughput,
@@ -106,47 +106,47 @@ export class ConnectionPool {
   }
 
   /**
-   * This method finds an available connection to the origin specified by the network record or null
+   * This method finds an available connection to the origin specified by the network request or null
    * if no connection was available. If returned, connection will not be available for other network
    * records until release is called.
    *
-   * @param {Lantern.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} request
    * @return {?TcpConnection}
    */
-  acquire(record) {
-    if (this._connectionsByRecord.has(record)) throw new Error('Record already has a connection');
+  acquire(request) {
+    if (this._connectionsByRequest.has(request)) throw new Error('Record already has a connection');
 
-    const origin = record.parsedURL.securityOrigin;
+    const origin = request.parsedURL.securityOrigin;
     const connections = this._connectionsByOrigin.get(origin) || [];
     const connectionToUse = this._findAvailableConnectionWithLargestCongestionWindow(connections);
 
     if (!connectionToUse) return null;
 
     this._connectionsInUse.add(connectionToUse);
-    this._connectionsByRecord.set(record, connectionToUse);
+    this._connectionsByRequest.set(request, connectionToUse);
     return connectionToUse;
   }
 
   /**
-   * Return the connection currently being used to fetch a record. If no connection
-   * currently being used for this record, an error will be thrown.
+   * Return the connection currently being used to fetch a request. If no connection
+   * currently being used for this request, an error will be thrown.
    *
-   * @param {Lantern.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} request
    * @return {TcpConnection}
    */
-  acquireActiveConnectionFromRecord(record) {
-    const activeConnection = this._connectionsByRecord.get(record);
-    if (!activeConnection) throw new Error('Could not find an active connection for record');
+  acquireActiveConnectionFromRequest(request) {
+    const activeConnection = this._connectionsByRequest.get(request);
+    if (!activeConnection) throw new Error('Could not find an active connection for request');
 
     return activeConnection;
   }
 
   /**
-   * @param {Lantern.NetworkRequest} record
+   * @param {Lantern.NetworkRequest} request
    */
-  release(record) {
-    const connection = this._connectionsByRecord.get(record);
-    this._connectionsByRecord.delete(record);
+  release(request) {
+    const connection = this._connectionsByRequest.get(request);
+    this._connectionsByRequest.delete(request);
     this._connectionsInUse.delete(connection);
   }
 }