lighthouse 9.5.0-dev.20220329 → 9.5.0-dev.20220330

package/lighthouse-core/audits/metrics/largest-contentful-paint.js

@@ -29,7 +29,7 @@ class LargestContentfulPaint extends Audit {
       description: str_(UIStrings.description),
       scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
       supportedModes: ['navigation'],
-      requiredArtifacts: ['HostUserAgent', 'traces', 'devtoolsLogs', 'GatherContext'],
+      requiredArtifacts: ['HostUserAgent', 'traces', 'devtoolsLogs', 'GatherContext', 'URL'],
     };
   }
 
@@ -74,7 +74,8 @@ class LargestContentfulPaint extends Audit {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const gatherContext = artifacts.GatherContext;
-    const metricComputationData = {trace, devtoolsLog, gatherContext, settings: context.settings};
+    const metricComputationData = {trace, devtoolsLog, gatherContext,
+      settings: context.settings, URL: artifacts.URL};
 
     let metricResult;
     try {

package/lighthouse-core/audits/metrics/max-potential-fid.js

@@ -33,7 +33,7 @@ class MaxPotentialFID extends Audit {
       description: str_(UIStrings.description),
       scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
       supportedModes: ['navigation'],
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
     };
   }
 
@@ -57,7 +57,8 @@ class MaxPotentialFID extends Audit {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const gatherContext = artifacts.GatherContext;
-    const metricComputationData = {trace, devtoolsLog, gatherContext, settings: context.settings};
+    const metricComputationData = {trace, devtoolsLog, gatherContext,
+      settings: context.settings, URL: artifacts.URL};
     const metricResult = await ComputedFid.request(metricComputationData, context);
 
     return {

package/lighthouse-core/audits/metrics/speed-index.js

@@ -28,7 +28,7 @@ class SpeedIndex extends Audit {
       description: str_(UIStrings.description),
       scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
       supportedModes: ['navigation'],
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
     };
   }
 
@@ -67,7 +67,8 @@ class SpeedIndex extends Audit {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const gatherContext = artifacts.GatherContext;
-    const metricComputationData = {trace, devtoolsLog, gatherContext, settings: context.settings};
+    const metricComputationData = {trace, devtoolsLog, gatherContext,
+      settings: context.settings, URL: artifacts.URL};
     const metricResult = await ComputedSi.request(metricComputationData, context);
     const options = context.options[context.settings.formFactor];
 

package/lighthouse-core/audits/metrics/total-blocking-time.js

@@ -27,7 +27,7 @@ class TotalBlockingTime extends Audit {
       title: str_(i18n.UIStrings.totalBlockingTimeMetric),
       description: str_(UIStrings.description),
       scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
     };
   }
 
@@ -88,7 +88,8 @@ class TotalBlockingTime extends Audit {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const gatherContext = artifacts.GatherContext;
-    const metricComputationData = {trace, devtoolsLog, gatherContext, settings: context.settings};
+    const metricComputationData = {trace, devtoolsLog, gatherContext,
+      settings: context.settings, URL: artifacts.URL};
     if (
       gatherContext.gatherMode === 'timespan' &&
       context.settings.throttlingMethod === 'simulate'

package/lighthouse-core/audits/metrics.js

@@ -29,7 +29,7 @@ class Metrics extends Audit {
       title: 'Metrics',
       description: 'Collects all available metrics.',
       supportedModes: ['navigation'],
-      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext'],
+      requiredArtifacts: ['traces', 'devtoolsLogs', 'GatherContext', 'URL'],
     };
   }
 
@@ -42,8 +42,9 @@ class Metrics extends Audit {
     const gatherContext = artifacts.GatherContext;
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const URL = artifacts.URL;
     const summary = await ComputedTimingSummary
-      .request({trace, devtoolsLog, gatherContext, settings: context.settings}, context);
+      .request({trace, devtoolsLog, gatherContext, settings: context.settings, URL}, context);
     const metrics = summary.metrics;
     const debugInfo = summary.debugInfo;
 

package/lighthouse-core/audits/predictive-perf.js

@@ -47,10 +47,11 @@ class PredictivePerf extends Audit {
     const gatherContext = artifacts.GatherContext;
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const URL = artifacts.URL;
     /** @type {LH.Config.Settings} */
     // @ts-expect-error - TODO(bckenny): allow optional `throttling` settings
     const settings = {}; // Use default settings.
-    const computationData = {trace, devtoolsLog, gatherContext, settings};
+    const computationData = {trace, devtoolsLog, gatherContext, settings, URL};
     const fcp = await LanternFcp.request(computationData, context);
     const fmp = await LanternFmp.request(computationData, context);
     const tti = await LanternInteractive.request(computationData, context);

package/lighthouse-core/audits/preload-lcp-image.js

@@ -203,7 +203,7 @@ class PreloadLCPImageAudit extends Audit {
     const trace = artifacts.traces[PreloadLCPImageAudit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[PreloadLCPImageAudit.DEFAULT_PASS];
     const URL = artifacts.URL;
-    const metricData = {trace, devtoolsLog, gatherContext, settings: context.settings};
+    const metricData = {trace, devtoolsLog, gatherContext, settings: context.settings, URL};
     const lcpElement = artifacts.TraceElements
       .find(element => element.traceEventType === 'largest-contentful-paint');
 

package/lighthouse-core/audits/redirects.js

@@ -93,7 +93,7 @@ class Redirects extends Audit {
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
     const mainResource = await MainResource.request({URL: artifacts.URL, devtoolsLog}, context);
 
-    const metricComputationData = {trace, devtoolsLog, gatherContext, settings};
+    const metricComputationData = {trace, devtoolsLog, gatherContext, settings, URL: artifacts.URL};
     const metricResult = await LanternInteractive.request(metricComputationData, context);
 
     /** @type {Map<string, LH.Gatherer.Simulation.NodeTiming>} */

package/lighthouse-core/audits/timing-budget.js

@@ -140,8 +140,9 @@ class TimingBudget extends Audit {
     const gatherContext = artifacts.GatherContext;
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
-    const mainResource = await MainResource.request({URL: artifacts.URL, devtoolsLog}, context);
-    const data = {trace, devtoolsLog, gatherContext, settings: context.settings};
+    const URL = artifacts.URL;
+    const mainResource = await MainResource.request({URL, devtoolsLog}, context);
+    const data = {trace, devtoolsLog, gatherContext, settings: context.settings, URL};
     const summary = (await TimingSummary.request(data, context)).metrics;
     const budget = Budget.getMatchingBudget(context.settings.budgets, mainResource.url);
 

package/lighthouse-core/audits/uses-rel-preconnect.js

@@ -123,7 +123,7 @@ class UsesRelPreconnectAudit extends Audit {
         MainResource.request({devtoolsLog, URL: artifacts.URL}, context),
         LoadSimulator.request({devtoolsLog, settings}, context),
         ProcessedNavigation.request(processedTrace, context),
-        PageDependencyGraph.request({trace, devtoolsLog}, context),
+        PageDependencyGraph.request({trace, devtoolsLog, URL: artifacts.URL}, context),
       ]);
 
     const {rtt, additionalRttByOrigin} = loadSimulator.getOptions();

package/lighthouse-core/audits/uses-rel-preload.js

@@ -217,7 +217,7 @@ class UsesRelPreloadAudit extends Audit {
 
     const [mainResource, graph, simulator] = await Promise.all([
       MainResource.request({devtoolsLog, URL}, context),
-      PageDependencyGraph.request({trace, devtoolsLog}, context),
+      PageDependencyGraph.request({trace, devtoolsLog, URL}, context),
       LoadSimulator.request(simulatorOptions, context),
     ]);
 

package/lighthouse-core/computed/critical-request-chains.js

@@ -129,15 +129,8 @@ class CriticalRequestChains {
    * @return {Promise<LH.Artifacts.CriticalRequestNode>}
    */
   static async compute_(data, context) {
-    const mainResource = await MainResource.request({
-      URL: data.URL,
-      devtoolsLog: data.devtoolsLog,
-    }, context);
-
-    const graph = await PageDependencyGraph.request({
-      trace: data.trace,
-      devtoolsLog: data.devtoolsLog,
-    }, context);
+    const mainResource = await MainResource.request(data, context);
+    const graph = await PageDependencyGraph.request(data, context);
 
     return CriticalRequestChains.extractChainsFromGraph(mainResource, graph);
   }

package/lighthouse-core/computed/main-resource.js

@@ -22,7 +22,7 @@ class MainResource {
   static async compute_(data, context) {
     const finalUrl = data.URL.finalUrl;
     const requests = await NetworkRecords.request(data.devtoolsLog, context);
-    const mainResource = NetworkAnalyzer.findMainDocument(requests, finalUrl);
+    const mainResource = NetworkAnalyzer.findResourceForUrl(requests, finalUrl);
     if (!mainResource) {
       throw new Error('Unable to identify the main resource');
     }

package/lighthouse-core/computed/metrics/first-contentful-paint-all-frames.js

@@ -33,5 +33,5 @@ class FirstContentfulPaintAllFrames extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   FirstContentfulPaintAllFrames,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/first-contentful-paint.js

@@ -36,5 +36,5 @@ class FirstContentfulPaint extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   FirstContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/first-meaningful-paint.js

@@ -40,5 +40,5 @@ class FirstMeaningfulPaint extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   FirstMeaningfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/interactive.js

@@ -183,7 +183,7 @@ class Interactive extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   Interactive,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );
 
 /**

package/lighthouse-core/computed/metrics/lantern-first-contentful-paint.js

@@ -200,5 +200,5 @@ class LanternFirstContentfulPaint extends LanternMetric {
 
 module.exports = makeComputedArtifact(
   LanternFirstContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/lantern-first-meaningful-paint.js

@@ -79,5 +79,5 @@ class LanternFirstMeaningfulPaint extends LanternMetric {
 
 module.exports = makeComputedArtifact(
   LanternFirstMeaningfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/lantern-interactive.js

@@ -109,5 +109,5 @@ class LanternInteractive extends LanternMetric {
 
 module.exports = makeComputedArtifact(
   LanternInteractive,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/lantern-largest-contentful-paint.js

@@ -107,5 +107,5 @@ class LanternLargestContentfulPaint extends LanternMetric {
 
 module.exports = makeComputedArtifact(
   LanternLargestContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/lantern-max-potential-fid.js

@@ -89,5 +89,5 @@ class LanternMaxPotentialFID extends LanternMetricArtifact {
 
 module.exports = makeComputedArtifact(
   LanternMaxPotentialFID,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/lantern-metric.js

@@ -101,17 +101,15 @@ class LanternMetricArtifact {
   static async computeMetricWithGraphs(data, context, extras) {
     // TODO: remove this fallback when lighthouse-pub-ads plugin can update.
     const gatherContext = data.gatherContext || {gatherMode: 'navigation'};
-    const {trace, devtoolsLog, settings} = data;
     if (gatherContext.gatherMode !== 'navigation') {
       throw new Error(`Lantern metrics can only be computed on navigations`);
     }
 
     const metricName = this.name.replace('Lantern', '');
-    const graph = await PageDependencyGraph.request({trace, devtoolsLog}, context);
-    const processedTrace = await ProcessedTrace.request(trace, context);
+    const graph = await PageDependencyGraph.request(data, context);
+    const processedTrace = await ProcessedTrace.request(data.trace, context);
     const processedNavigation = await ProcessedNavigation.request(processedTrace, context);
-    const simulator = data.simulator ||
-        (await LoadSimulator.request({devtoolsLog, settings}, context));
+    const simulator = data.simulator || (await LoadSimulator.request(data, context));
 
     const optimisticGraph = this.getOptimisticGraph(graph, processedNavigation);
     const pessimisticGraph = this.getPessimisticGraph(graph, processedNavigation);

package/lighthouse-core/computed/metrics/lantern-speed-index.js

@@ -146,5 +146,5 @@ class LanternSpeedIndex extends LanternMetric {
 
 module.exports = makeComputedArtifact(
   LanternSpeedIndex,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/lantern-total-blocking-time.js

@@ -122,5 +122,5 @@ class LanternTotalBlockingTime extends LanternMetric {
 
 module.exports = makeComputedArtifact(
   LanternTotalBlockingTime,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/largest-contentful-paint-all-frames.js

@@ -41,5 +41,5 @@ class LargestContentfulPaintAllFrames extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   LargestContentfulPaintAllFrames,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/largest-contentful-paint.js

@@ -48,5 +48,5 @@ class LargestContentfulPaint extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   LargestContentfulPaint,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/max-potential-fid.js

@@ -41,5 +41,5 @@ class MaxPotentialFID extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   MaxPotentialFID,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/metric.js

@@ -34,6 +34,7 @@ class Metric {
       devtoolsLog: data.devtoolsLog,
       gatherContext: data.gatherContext,
       settings: data.settings,
+      URL: data.URL,
     };
   }
 

package/lighthouse-core/computed/metrics/speed-index.js

@@ -36,5 +36,5 @@ class SpeedIndex extends NavigationMetric {
 
 module.exports = makeComputedArtifact(
   SpeedIndex,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/timing-summary.js

@@ -26,11 +26,12 @@ class TimingSummary {
      * @param {LH.DevtoolsLog} devtoolsLog
      * @param {LH.Artifacts['GatherContext']} gatherContext
      * @param {ImmutableObject<LH.Config.Settings>} settings
+     * @param {LH.Artifacts['URL']} URL
      * @param {LH.Artifacts.ComputedContext} context
      * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
      */
-  static async summarize(trace, devtoolsLog, gatherContext, settings, context) {
-    const metricComputationData = {trace, devtoolsLog, gatherContext, settings};
+  static async summarize(trace, devtoolsLog, gatherContext, settings, URL, context) {
+    const metricComputationData = {trace, devtoolsLog, gatherContext, settings, URL};
     /**
      * @template TArtifacts
      * @template TReturn
@@ -134,17 +135,23 @@ class TimingSummary {
     return {metrics, debugInfo};
   }
   /**
-   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: ImmutableObject<LH.Config.Settings>}} data
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, gatherContext: LH.Artifacts['GatherContext']; settings: ImmutableObject<LH.Config.Settings>, URL: LH.Artifacts['URL']}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<{metrics: LH.Artifacts.TimingSummary, debugInfo: Record<string,boolean>}>}
    */
   static async compute_(data, context) {
-    return TimingSummary.summarize(data.trace, data.devtoolsLog, data.gatherContext, data.settings,
-      context);
+    return TimingSummary.summarize(
+      data.trace,
+      data.devtoolsLog,
+      data.gatherContext,
+      data.settings,
+      data.URL,
+      context
+    );
   }
 }
 
 module.exports = makeComputedArtifact(
   TimingSummary,
-  ['devtoolsLog', 'gatherContext', 'settings', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'trace', 'URL']
 );

package/lighthouse-core/computed/metrics/total-blocking-time.js

@@ -70,5 +70,5 @@ class TotalBlockingTime extends ComputedMetric {
 
 module.exports = makeComputedArtifact(
   TotalBlockingTime,
-  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace']
+  ['devtoolsLog', 'gatherContext', 'settings', 'simulator', 'trace', 'URL']
 );

package/lighthouse-core/computed/page-dependency-graph.js

@@ -8,13 +8,14 @@
 const makeComputedArtifact = require('./computed-artifact.js');
 const NetworkNode = require('../lib/dependency-graph/network-node.js');
 const CPUNode = require('../lib/dependency-graph/cpu-node.js');
-const NetworkAnalyzer = require('../lib/dependency-graph/simulator/network-analyzer.js');
 const TracingProcessor = require('../lib/tracehouse/trace-processor.js');
 const NetworkRequest = require('../lib/network-request.js');
 const ProcessedTrace = require('./processed-trace.js');
 const NetworkRecords = require('./network-records.js');
+const NetworkAnalyzer = require('../lib/dependency-graph/simulator/network-analyzer.js');
 
 /** @typedef {import('../lib/dependency-graph/base-node.js').Node} Node */
+/** @typedef {Omit<LH.Artifacts['URL'], 'initialUrl'|'finalUrl'>} URLArtifact */
 
 // Shorter tasks have negligible impact on simulation results.
 const SIGNIFICANT_DUR_THRESHOLD_MS = 10;
@@ -388,37 +389,24 @@ class PageDependencyGraph {
   /**
    * @param {LH.Artifacts.ProcessedTrace} processedTrace
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+   * @param {URLArtifact} URL
    * @return {Node}
    */
-  static createGraph(processedTrace, networkRecords) {
+  static createGraph(processedTrace, networkRecords, URL) {
     const networkNodeOutput = PageDependencyGraph.getNetworkNodeOutput(networkRecords);
     const cpuNodes = PageDependencyGraph.getCPUNodes(processedTrace);
+    const {requestedUrl, mainDocumentUrl} = URL;
+    if (!mainDocumentUrl) throw new Error('mainDocumentUrl is required to get the main resource');
 
-    // TODO: Remove this usage of `findMainDocument` and create a new function to get the first document request.
-    // https://github.com/GoogleChrome/lighthouse/issues/8984
-    //
-    // The main document request is the earliest network request *of type document*.
-    // This will be different from the root request when there are server redirects.
-    const mainDocumentRequest = NetworkAnalyzer.findMainDocument(networkRecords);
-    const mainDocumentNode = networkNodeOutput.idToNodeMap.get(mainDocumentRequest.requestId);
-    if (!mainDocumentNode) {
-      // mainDocumentNode should always be found.
-      throw new Error('mainDocumentNode not found.');
-    }
+    const rootRequest = NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
+    if (!rootRequest) throw new Error('rootRequest not found');
+    const rootNode = networkNodeOutput.idToNodeMap.get(rootRequest.requestId);
+    if (!rootNode) throw new Error('rootNode not found');
 
-    // The root request is the earliest request in the main document redirect chain.
-    // Will be undefined if there were no redirects.
-    const rootRequest = mainDocumentNode.record.redirects?.[0];
-
-    let rootNode;
-    if (rootRequest) {
-      // rootNode should always be found.
-      rootNode = rootRequest && networkNodeOutput.idToNodeMap.get(rootRequest.requestId);
-      if (!rootNode) throw new Error('rootNode not found');
-    } else {
-      // Use main document as root if there were no redirects.
-      rootNode = mainDocumentNode;
-    }
+    const mainDocumentRequest = NetworkAnalyzer.findResourceForUrl(networkRecords, mainDocumentUrl);
+    if (!mainDocumentRequest) throw new Error('mainDocumentRequest not found');
+    const mainDocumentNode = networkNodeOutput.idToNodeMap.get(mainDocumentRequest.requestId);
+    if (!mainDocumentNode) throw new Error('mainDocumentNode not found');
 
     PageDependencyGraph.linkNetworkNodes(rootNode, networkNodeOutput);
     PageDependencyGraph.linkCPUNodes(rootNode, networkNodeOutput, cpuNodes);
@@ -464,23 +452,58 @@ class PageDependencyGraph {
   }
 
   /**
-   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog}} data
+   * Recalculate `artifacts.URL` for clients that don't provide it.
+   *
+   * @param {LH.DevtoolsLog} devtoolsLog
+   * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+   * @param {LH.Artifacts.ProcessedTrace} processedTrace
+   * @return {URLArtifact}
+   */
+  static getDocumentUrls(devtoolsLog, networkRecords, processedTrace) {
+    const mainFrameId = processedTrace.mainFrameIds.frameId;
+
+    /** @type {string|undefined} */
+    let requestedUrl;
+    /** @type {string|undefined} */
+    let mainDocumentUrl;
+    for (const event of devtoolsLog) {
+      if (event.method === 'Page.frameNavigated' && event.params.frame.id === mainFrameId) {
+        const {url} = event.params.frame;
+        // Only set requestedUrl on the first main frame navigation.
+        if (!requestedUrl) requestedUrl = url;
+        mainDocumentUrl = url;
+      }
+    }
+    if (!requestedUrl || !mainDocumentUrl) throw new Error('No main frame navigations found');
+
+    const initialRequest = NetworkAnalyzer.findResourceForUrl(networkRecords, requestedUrl);
+    if (initialRequest?.redirects?.length) requestedUrl = initialRequest.redirects[0].url;
+
+    return {requestedUrl, mainDocumentUrl};
+  }
+
+  /**
+   * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL']}} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<Node>}
    */
   static async compute_(data, context) {
-    const trace = data.trace;
-    const devtoolsLog = data.devtoolsLog;
+    const {trace, devtoolsLog} = data;
     const [processedTrace, networkRecords] = await Promise.all([
       ProcessedTrace.request(trace, context),
       NetworkRecords.request(devtoolsLog, context),
     ]);
 
-    return PageDependencyGraph.createGraph(processedTrace, networkRecords);
+    // COMPAT: Backport for pre-10.0 clients that don't pass the URL artifact here (e.g. pubads).
+    // Calculates the URL artifact from the processed trace and DT log.
+    const URL = data.URL ||
+      PageDependencyGraph.getDocumentUrls(devtoolsLog, networkRecords, processedTrace);
+
+    return PageDependencyGraph.createGraph(processedTrace, networkRecords, URL);
   }
 }
 
-module.exports = makeComputedArtifact(PageDependencyGraph, ['devtoolsLog', 'trace']);
+module.exports = makeComputedArtifact(PageDependencyGraph, ['devtoolsLog', 'trace', 'URL']);
 
 /**
  * @typedef {Object} NetworkNodeOutput

package/lighthouse-core/gather/driver/execution-context.js

@@ -97,7 +97,8 @@ class ExecutionContext {
             .catch(${pageFunctions.wrapRuntimeEvalErrorInBrowserString})
             .then(resolve);
         });
-      }())`,
+      }())
+      //# sourceURL=_lighthouse-eval.js`,
       includeCommandLineAPI: true,
       awaitPromise: true,
       returnByValue: true,
@@ -195,7 +196,8 @@ class ExecutionContext {
       ${ExecutionContext._cachedNativesPreamble};
       ${depsSerialized};
       (${mainFn})(${argsSerialized});
-    })()`;
+    })()
+    //# sourceURL=_lighthouse-eval.js`;
 
     await this._session.sendCommand('Page.addScriptToEvaluateOnNewDocument', {source: expression});
   }

package/lighthouse-core/gather/gatherers/js-usage.js

@@ -50,12 +50,13 @@ class JsUsage extends FRGatherer {
     const usageByScriptId = {};
 
     for (const scriptUsage of this._scriptUsages) {
-      // If `url` is blank, that means the script was anonymous (eval, new Function, onload, ...).
-      // Or, it's because it was code Lighthouse over the protocol via `Runtime.evaluate`.
-      // We currently don't consider coverage of anonymous scripts, and we definitely don't want
-      // coverage of code Lighthouse ran to inspect the page, so we ignore this ScriptCoverage if
-      // url is blank.
-      if (scriptUsage.url === '') {
+      // If `url` is blank, that means the script was dynamically
+      // created (eval, new Function, onload, ...)
+      if (scriptUsage.url === '' || scriptUsage.url === '_lighthouse-eval.js') {
+        // We currently don't consider coverage of dynamic scripts, and we definitely don't want
+        // coverage of code Lighthouse ran to inspect the page, so we ignore this ScriptCoverage.
+        // Audits would work the same without this, it is only an optimization (not tracking coverage
+        // for scripts we don't care about).
         continue;
       }
 

package/lighthouse-core/gather/gatherers/scripts.js

@@ -28,6 +28,23 @@ async function runInSeriesOrParallel(values, promiseMapper, runInSeries) {
   }
 }
 
+/**
+ * Returns true if the script was created via our own calls
+ * to Runtime.evaluate.
+ * @param {LH.Crdp.Debugger.ScriptParsedEvent} script
+ */
+function isLighthouseRuntimeEvaluateScript(script) {
+  // Scripts created by Runtime.evaluate that run on the main session/frame
+  // result in an empty string for the embedderName.
+  // Or, it means the script was dynamically created (eval, new Function, onload, ...)
+  if (!script.embedderName) return true;
+
+  // Otherwise, when running our own code inside other frames, the embedderName
+  // is set to the frame's url. In that case, we rely on the special sourceURL that
+  // we set.
+  return script.hasSourceURL && script.url === '_lighthouse-eval.js';
+}
+
 /**
  * @fileoverview Gets JavaScript file contents.
  */
@@ -68,8 +85,9 @@ class Scripts extends FRGatherer {
     // it also blocks scripts from the same origin but that happen to run in a different process,
     // like a worker.
     if (event.method === 'Debugger.scriptParsed' && !sessionId) {
-      // Events without an embedderName (read: a url) are for JS that we ran over the protocol.
-      if (event.params.embedderName) this._scriptParsedEvents.push(event.params);
+      if (!isLighthouseRuntimeEvaluateScript(event.params)) {
+        this._scriptParsedEvents.push(event.params);
+      }
     }
   }