lighthouse 10.0.1-dev.20230227 → 10.0.2

package/cli/test/smokehouse/config/exclusions.js

@@ -25,6 +25,8 @@ const exclusions = {
     'metrics-tricky-tti', 'metrics-tricky-tti-late-fcp', 'screenshot',
     // Disabled because of differences that need further investigation
     'byte-efficiency', 'byte-gzip', 'perf-preload',
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=1420418
+    'issues-mixed-content',
   ],
 };
 

package/core/audits/redirects.d.ts

@@ -4,19 +4,19 @@ declare class Redirects extends Audit {
      * This method generates the document request chain including client-side and server-side redirects.
      *
      * Example:
-     *    GET /initialUrl => 302 /firstRedirect
+     *    GET /requestedUrl => 302 /firstRedirect
      *    GET /firstRedirect => 200 /firstRedirect, window.location = '/secondRedirect'
      *    GET /secondRedirect => 302 /thirdRedirect
-     *    GET /thirdRedirect => 200 /mainDocumentUrl
+     *    GET /thirdRedirect => 302 /mainDocumentUrl
+     *    GET /mainDocumentUrl => 200 /mainDocumentUrl
      *
-     * Returns network records [/initialUrl, /firstRedirect, /secondRedirect, /thirdRedirect, /mainDocumentUrl]
+     * Returns network records [/requestedUrl, /firstRedirect, /secondRedirect, /thirdRedirect, /mainDocumentUrl]
      *
-     * @param {LH.Artifacts.NetworkRequest} mainResource
      * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
      * @param {LH.Artifacts.ProcessedTrace} processedTrace
      * @return {Array<LH.Artifacts.NetworkRequest>}
      */
-    static getDocumentRequestChain(mainResource: LH.Artifacts.NetworkRequest, networkRecords: Array<LH.Artifacts.NetworkRequest>, processedTrace: LH.Artifacts.ProcessedTrace): Array<LH.Artifacts.NetworkRequest>;
+    static getDocumentRequestChain(networkRecords: Array<LH.Artifacts.NetworkRequest>, processedTrace: LH.Artifacts.ProcessedTrace): Array<LH.Artifacts.NetworkRequest>;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {LH.Audit.Context} context

package/core/audits/redirects.js

@@ -9,7 +9,6 @@ import {ByteEfficiencyAudit} from './byte-efficiency/byte-efficiency-audit.js';
 import * as i18n from '../lib/i18n/i18n.js';
 import {ProcessedTrace} from '../computed/processed-trace.js';
 import {NetworkRecords} from '../computed/network-records.js';
-import {MainResource} from '../computed/main-resource.js';
 import {LanternInteractive} from '../computed/metrics/lantern-interactive.js';
 
 const UIStrings = {
@@ -40,19 +39,19 @@ class Redirects extends Audit {
    * This method generates the document request chain including client-side and server-side redirects.
    *
    * Example:
-   *    GET /initialUrl => 302 /firstRedirect
+   *    GET /requestedUrl => 302 /firstRedirect
    *    GET /firstRedirect => 200 /firstRedirect, window.location = '/secondRedirect'
    *    GET /secondRedirect => 302 /thirdRedirect
-   *    GET /thirdRedirect => 200 /mainDocumentUrl
+   *    GET /thirdRedirect => 302 /mainDocumentUrl
+   *    GET /mainDocumentUrl => 200 /mainDocumentUrl
    *
-   * Returns network records [/initialUrl, /firstRedirect, /secondRedirect, /thirdRedirect, /mainDocumentUrl]
+   * Returns network records [/requestedUrl, /firstRedirect, /secondRedirect, /thirdRedirect, /mainDocumentUrl]
    *
-   * @param {LH.Artifacts.NetworkRequest} mainResource
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
    * @param {LH.Artifacts.ProcessedTrace} processedTrace
    * @return {Array<LH.Artifacts.NetworkRequest>}
    */
-  static getDocumentRequestChain(mainResource, networkRecords, processedTrace) {
+  static getDocumentRequestChain(networkRecords, processedTrace) {
     /** @type {Array<LH.Artifacts.NetworkRequest>} */
     const documentRequests = [];
 
@@ -63,18 +62,19 @@ class Redirects extends Audit {
       const data = event.args.data || {};
       if (!data.documentLoaderURL || !data.isLoadingMainFrame) continue;
 
-      let networkRecord = networkRecords.find(record => record.url === data.documentLoaderURL);
+      let networkRecord = networkRecords.find(record => record.requestId === data.navigationId);
       while (networkRecord) {
         documentRequests.push(networkRecord);
+        // HTTP redirects won't have separate navStarts, so find through the redirect chain.
         networkRecord = networkRecord.redirectDestination;
       }
     }
 
-    // If we found documents in the trace, just use this directly.
-    if (documentRequests.length) return documentRequests;
+    if (!documentRequests.length) {
+      throw new Error('No navigation requests found');
+    }
 
-    // Use the main resource as a backup if we didn't find any modern navigationStart events
-    return (mainResource.redirects || []).concat(mainResource);
+    return documentRequests;
   }
 
   /**
@@ -90,21 +90,19 @@ class Redirects extends Audit {
 
     const processedTrace = await ProcessedTrace.request(trace, context);
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    const mainResource = await MainResource.request({URL: artifacts.URL, devtoolsLog}, context);
 
     const metricComputationData = {trace, devtoolsLog, gatherContext, settings, URL: artifacts.URL};
     const metricResult = await LanternInteractive.request(metricComputationData, context);
 
     /** @type {Map<string, LH.Gatherer.Simulation.NodeTiming>} */
-    const nodeTimingsByUrl = new Map();
+    const nodeTimingsById = new Map();
     for (const [node, timing] of metricResult.pessimisticEstimate.nodeTimings.entries()) {
       if (node.type === 'network') {
-        nodeTimingsByUrl.set(node.record.url, timing);
+        nodeTimingsById.set(node.record.requestId, timing);
       }
     }
 
-    const documentRequests = Redirects.getDocumentRequestChain(
-      mainResource, networkRecords, processedTrace);
+    const documentRequests = Redirects.getDocumentRequestChain(networkRecords, processedTrace);
 
     let totalWastedMs = 0;
     const tableRows = [];
@@ -118,8 +116,8 @@ class Redirects extends Audit {
       const initialRequest = documentRequests[i];
       const redirectedRequest = documentRequests[i + 1] || initialRequest;
 
-      const initialTiming = nodeTimingsByUrl.get(initialRequest.url);
-      const redirectedTiming = nodeTimingsByUrl.get(redirectedRequest.url);
+      const initialTiming = nodeTimingsById.get(initialRequest.requestId);
+      const redirectedTiming = nodeTimingsById.get(redirectedRequest.requestId);
       if (!initialTiming || !redirectedTiming) {
         throw new Error('Could not find redirects in graph');
       }

package/core/lib/tracehouse/trace-processor.js

@@ -488,21 +488,24 @@ class TraceProcessor {
    * @return {Map<number, number>} Map where keys are process IDs and their values are thread IDs
    */
   static findMainFramePidTids(mainFrameInfo, keyEvents) {
-    const frameCommittedEvts = keyEvents.filter(evt =>
-      evt.name === 'FrameCommittedInBrowser' &&
-      evt.args?.data?.frame === mainFrameInfo.frameId
+    const frameProcessEvts = keyEvents.filter(evt =>
+      // ProcessReadyInBrowser is used when a processID isn't available when the FrameCommittedInBrowser trace event is emitted.
+      // In that case. FrameCommittedInBrowser has no processId, but a processPseudoId. and the ProcessReadyInBrowser event declares the proper processId.
+      (evt.name === 'FrameCommittedInBrowser' || evt.name === 'ProcessReadyInBrowser') &&
+      evt.args?.data?.frame === mainFrameInfo.frameId &&
+      evt?.args?.data?.processId
     );
 
     // "Modern" traces with a navigation have a FrameCommittedInBrowser event
-    const mainFramePids = frameCommittedEvts.length
-      ? frameCommittedEvts.map(e => e?.args?.data?.processId)
+    const mainFramePids = frameProcessEvts.length
+      ? frameProcessEvts.map(e => e?.args?.data?.processId)
       // …But old traces and some timespan traces may not. In these situations, we'll assume the
       // primary process ID remains constant (as there were no navigations).
       : [mainFrameInfo.startingPid];
 
     const pidToTid = new Map();
 
-    mainFramePids.forEach(pid => {
+    for (const pid of new Set(mainFramePids)) {
       // While renderer tids are generally predictable, we'll doublecheck it
       const threadNameEvt = keyEvents.find(e =>
         e.cat === '__metadata' &&
@@ -518,7 +521,7 @@ class TraceProcessor {
       }
 
       pidToTid.set(pid, tid);
-    });
+    }
     return pidToTid;
   }
 
@@ -712,7 +715,8 @@ class TraceProcessor {
     }
     const frameEvents = keyEvents.filter(e => associatedToMainFrame(e));
 
-    // Filter to just events matching the main frame ID or any child frame IDs.
+    // Filter to just events matching the main frame ID or any child frame IDs. The subframes
+    // are either in-process (same origin) or, potentially, out-of-process. (OOPIFs)
     let frameTreeEvents = [];
     if (frameIdToRootFrameId.has(mainFrameInfo.frameId)) {
       frameTreeEvents = keyEvents.filter(e => associatedToAllFrames(e));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "10.0.1-dev.20230227",
+  "version": "10.0.2",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {

package/types/artifacts.d.ts

@@ -709,7 +709,7 @@ declare module Artifacts {
     timestamps: TraceTimes;
     /** The relative times from timeOrigin to key events, in milliseconds. */
     timings: TraceTimes;
-    /** The subset of trace events from the page's process, sorted by timestamp. */
+    /** The subset of trace events from the main frame's process, sorted by timestamp. Due to cross-origin navigations, the main frame may have multiple processes, so events may be from more than one process.  */
     processEvents: Array<TraceEvent>;
     /** The subset of trace events from the page's main thread, sorted by timestamp. */
     mainThreadEvents: Array<TraceEvent>;
@@ -977,6 +977,7 @@ export interface TraceEvent {
       processId?: number;
       isLoadingMainFrame?: boolean;
       documentLoaderURL?: string;
+      navigationId?: string;
       frames?: {
         frame: string;
         url: string;