lighthouse 8.0.0-dev.20210709 → 8.0.0

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

@@ -168,13 +168,13 @@ class LanternFirstContentfulPaint extends LanternMetric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {LH.Artifacts.TraceOfTab} traceOfTab
    * @return {Node}
    */
-  static getOptimisticGraph(dependencyGraph, processedNavigation) {
+  static getOptimisticGraph(dependencyGraph, traceOfTab) {
     return this.getFirstPaintBasedGraph(
       dependencyGraph,
-      processedNavigation.timestamps.firstContentfulPaint,
+      traceOfTab.timestamps.firstContentfulPaint,
       // In the optimistic graph we exclude resources that appeared to be render blocking but were
       // initiated by a script. While they typically have a very high importance and tend to have a
       // significant impact on the page's content, these resources don't technically block rendering.
@@ -184,13 +184,13 @@ class LanternFirstContentfulPaint extends LanternMetric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {LH.Artifacts.TraceOfTab} traceOfTab
    * @return {Node}
    */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) {
+  static getPessimisticGraph(dependencyGraph, traceOfTab) {
     return this.getFirstPaintBasedGraph(
       dependencyGraph,
-      processedNavigation.timestamps.firstContentfulPaint,
+      traceOfTab.timestamps.firstContentfulPaint,
       node => node.hasRenderBlockingPriority()
     );
   }

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

@@ -26,11 +26,11 @@ class LanternFirstMeaningfulPaint extends LanternMetric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {LH.Artifacts.TraceOfTab} traceOfTab
    * @return {Node}
    */
-  static getOptimisticGraph(dependencyGraph, processedNavigation) {
-    const fmp = processedNavigation.timestamps.firstMeaningfulPaint;
+  static getOptimisticGraph(dependencyGraph, traceOfTab) {
+    const fmp = traceOfTab.timestamps.firstMeaningfulPaint;
     if (!fmp) {
       throw new LHError(LHError.errors.NO_FMP);
     }
@@ -46,11 +46,11 @@ class LanternFirstMeaningfulPaint extends LanternMetric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {LH.Artifacts.TraceOfTab} traceOfTab
    * @return {Node}
    */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) {
-    const fmp = processedNavigation.timestamps.firstMeaningfulPaint;
+  static getPessimisticGraph(dependencyGraph, traceOfTab) {
+    const fmp = traceOfTab.timestamps.firstMeaningfulPaint;
     if (!fmp) {
       throw new LHError(LHError.errors.NO_FMP);
     }

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

@@ -41,11 +41,11 @@ class LanternLargestContentfulPaint extends LanternMetric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {LH.Artifacts.TraceOfTab} traceOfTab
    * @return {Node}
    */
-  static getOptimisticGraph(dependencyGraph, processedNavigation) {
-    const lcp = processedNavigation.timestamps.largestContentfulPaint;
+  static getOptimisticGraph(dependencyGraph, traceOfTab) {
+    const lcp = traceOfTab.timestamps.largestContentfulPaint;
     if (!lcp) {
       throw new LHError(LHError.errors.NO_LCP);
     }
@@ -59,11 +59,11 @@ class LanternLargestContentfulPaint extends LanternMetric {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {LH.Artifacts.TraceOfTab} traceOfTab
    * @return {Node}
    */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) {
-    const lcp = processedNavigation.timestamps.largestContentfulPaint;
+  static getPessimisticGraph(dependencyGraph, traceOfTab) {
+    const lcp = traceOfTab.timestamps.largestContentfulPaint;
     if (!lcp) {
       throw new LHError(LHError.errors.NO_LCP);
     }

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

@@ -7,8 +7,7 @@
 
 const BaseNode = require('../../lib/dependency-graph/base-node.js');
 const NetworkRequest = require('../../lib/network-request.js');
-const ProcessedTrace = require('../processed-trace.js');
-const ProcessedNavigation = require('../processed-navigation.js');
+const TraceOfTab = require('../trace-of-tab.js');
 const PageDependencyGraph = require('../page-dependency-graph.js');
 const LoadSimulator = require('../load-simulator.js');
 
@@ -67,19 +66,19 @@ class LanternMetricArtifact {
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {LH.Artifacts.TraceOfTab} traceOfTab
    * @return {Node}
    */
-  static getOptimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars
+  static getOptimisticGraph(dependencyGraph, traceOfTab) { // eslint-disable-line no-unused-vars
     throw new Error('Optimistic graph unimplemented!');
   }
 
   /**
    * @param {Node} dependencyGraph
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {LH.Artifacts.TraceOfTab} traceOfTab
    * @return {Node}
    */
-  static getPessimisticGraph(dependencyGraph, processedNavigation) { // eslint-disable-line no-unused-vars
+  static getPessimisticGraph(dependencyGraph, traceOfTab) { // eslint-disable-line no-unused-vars
     throw new Error('Pessmistic graph unimplemented!');
   }
 
@@ -99,22 +98,15 @@ class LanternMetricArtifact {
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   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 processedNavigation = await ProcessedNavigation.request(processedTrace, context);
+    const traceOfTab = await TraceOfTab.request(trace, context);
     const simulator = data.simulator ||
         await LoadSimulator.request({devtoolsLog, settings}, context);
 
-    const optimisticGraph = this.getOptimisticGraph(graph, processedNavigation);
-    const pessimisticGraph = this.getPessimisticGraph(graph, processedNavigation);
+    const optimisticGraph = this.getOptimisticGraph(graph, traceOfTab);
+    const pessimisticGraph = this.getPessimisticGraph(graph, traceOfTab);
 
     /** @type {{flexibleOrdering?: boolean, label?: string}} */
     let simulateOptions = {label: `optimistic${metricName}`};

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

@@ -10,10 +10,10 @@
  */
 
 const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
+const ComputedMetric = require('./metric.js');
 const LHError = require('../../lib/lh-error.js');
 
-class LargestContentfulPaintAllFrames extends NavigationMetric {
+class LargestContentfulPaintAllFrames extends ComputedMetric {
   /**
    * TODO: Simulate LCP all frames in lantern.
    * @return {Promise<LH.Artifacts.LanternMetric>}
@@ -23,18 +23,18 @@ class LargestContentfulPaintAllFrames extends NavigationMetric {
   }
 
   /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.MetricComputationData} data
    * @return {Promise<LH.Artifacts.Metric>}
    */
   static async computeObservedMetric(data) {
-    const {processedNavigation} = data;
-    if (processedNavigation.timings.largestContentfulPaintAllFrames === undefined) {
+    const {traceOfTab} = data;
+    if (traceOfTab.timings.largestContentfulPaintAllFrames === undefined) {
       throw new LHError(LHError.errors.NO_LCP_ALL_FRAMES);
     }
 
     return {
-      timing: processedNavigation.timings.largestContentfulPaintAllFrames,
-      timestamp: processedNavigation.timestamps.largestContentfulPaintAllFrames,
+      timing: traceOfTab.timings.largestContentfulPaintAllFrames,
+      timestamp: traceOfTab.timestamps.largestContentfulPaintAllFrames,
     };
   }
 }

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

@@ -14,34 +14,33 @@
  */
 
 const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
+const ComputedMetric = require('./metric.js');
 const LHError = require('../../lib/lh-error.js');
 const LanternLargestContentfulPaint = require('./lantern-largest-contentful-paint.js');
 
-class LargestContentfulPaint extends NavigationMetric {
+class LargestContentfulPaint extends ComputedMetric {
   /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.MetricComputationData} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static computeSimulatedMetric(data, context) {
-    const metricData = NavigationMetric.getMetricComputationInput(data);
-    return LanternLargestContentfulPaint.request(metricData, context);
+    return LanternLargestContentfulPaint.request(data, context);
   }
 
   /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.MetricComputationData} data
    * @return {Promise<LH.Artifacts.Metric>}
    */
   static async computeObservedMetric(data) {
-    const {processedNavigation} = data;
-    if (processedNavigation.timings.largestContentfulPaint === undefined) {
+    const {traceOfTab} = data;
+    if (traceOfTab.timings.largestContentfulPaint === undefined) {
       throw new LHError(LHError.errors.NO_LCP);
     }
 
     return {
-      timing: processedNavigation.timings.largestContentfulPaint,
-      timestamp: processedNavigation.timestamps.largestContentfulPaint,
+      timing: traceOfTab.timings.largestContentfulPaint,
+      timestamp: traceOfTab.timestamps.largestContentfulPaint,
     };
   }
 }

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

@@ -6,30 +6,33 @@
 'use strict';
 
 const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
+const MetricArtifact = require('./metric.js');
 const LanternMaxPotentialFID = require('./lantern-max-potential-fid.js');
+const LHError = require('../../lib/lh-error.js');
 const TracingProcessor = require('../../lib/tracehouse/trace-processor.js');
 
-class MaxPotentialFID extends NavigationMetric {
+class MaxPotentialFID extends MetricArtifact {
   /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.MetricComputationData} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static computeSimulatedMetric(data, context) {
-    const metricData = NavigationMetric.getMetricComputationInput(data);
-    return LanternMaxPotentialFID.request(metricData, context);
+    return LanternMaxPotentialFID.request(data, context);
   }
 
   /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.MetricComputationData} data
    * @return {Promise<LH.Artifacts.Metric>}
    */
   static computeObservedMetric(data) {
-    const {firstContentfulPaint} = data.processedNavigation.timings;
+    const {firstContentfulPaint} = data.traceOfTab.timings;
+    if (!firstContentfulPaint) {
+      throw new LHError(LHError.errors.NO_FCP);
+    }
 
     const events = TracingProcessor.getMainThreadTopLevelEvents(
-      data.processedTrace,
+      data.traceOfTab,
       firstContentfulPaint
     ).filter(evt => evt.duration >= 1);
 

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

@@ -6,8 +6,7 @@
 'use strict';
 
 const TracingProcessor = require('../../lib/tracehouse/trace-processor.js');
-const ProcessedTrace = require('../processed-trace.js');
-const ProcessedNavigation = require('../processed-navigation.js');
+const TraceOfTab = require('../trace-of-tab.js');
 const NetworkRecords = require('../network-records.js');
 
 /**
@@ -19,24 +18,9 @@ const NetworkRecords = require('../network-records.js');
  *     - Override the computeSimulatedMetric method with the simulated-mode implementation (which
  *       may call another computed artifact with the name LanternMyMetricName).
  */
-class Metric {
+class ComputedMetric {
   constructor() {}
 
-  /**
-   * Narrows the metric computation data to the input so child metric requests can be cached.
-   *
-   * @param {LH.Artifacts.MetricComputationData} data
-   * @return {LH.Artifacts.MetricComputationDataInput}
-   */
-  static getMetricComputationInput(data) {
-    return {
-      trace: data.trace,
-      devtoolsLog: data.devtoolsLog,
-      gatherContext: data.gatherContext,
-      settings: data.settings,
-    };
-  }
-
   /**
    * @param {LH.Artifacts.MetricComputationData} data
    * @param {LH.Artifacts.ComputedContext} context
@@ -61,31 +45,20 @@ class Metric {
    * @return {Promise<LH.Artifacts.LanternMetric|LH.Artifacts.Metric>}
    */
   static async compute_(data, context) {
-    // TODO: remove this fallback when lighthouse-pub-ads plugin can update.
-    const gatherContext = data.gatherContext || {gatherMode: 'navigation'};
     const {trace, devtoolsLog, settings} = data;
     if (!trace || !devtoolsLog || !settings) {
       throw new Error('Did not provide necessary metric computation data');
     }
 
-    const processedTrace = await ProcessedTrace.request(trace, context);
-    const processedNavigation = await ProcessedNavigation.request(processedTrace, context);
-
     const augmentedData = Object.assign({
       networkRecords: await NetworkRecords.request(devtoolsLog, context),
-      gatherContext,
-      processedTrace,
-      processedNavigation,
+      traceOfTab: await TraceOfTab.request(trace, context),
     }, data);
 
-    TracingProcessor.assertHasToplevelEvents(augmentedData.processedTrace.mainThreadEvents);
+    TracingProcessor.assertHasToplevelEvents(augmentedData.traceOfTab.mainThreadEvents);
 
     switch (settings.throttlingMethod) {
       case 'simulate':
-        if (gatherContext.gatherMode !== 'navigation') {
-          throw new Error(`${gatherContext.gatherMode} does not support throttlingMethod simulate`);
-        }
-
         return this.computeSimulatedMetric(augmentedData, context);
       case 'provided':
       case 'devtools':
@@ -96,4 +69,4 @@ class Metric {
   }
 }
 
-module.exports = Metric;
+module.exports = ComputedMetric;

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

@@ -6,23 +6,22 @@
 'use strict';
 
 const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
+const ComputedMetric = require('./metric.js');
 const LanternSpeedIndex = require('./lantern-speed-index.js');
 const Speedline = require('../speedline.js');
 
-class SpeedIndex extends NavigationMetric {
+class SpeedIndex extends ComputedMetric {
   /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.MetricComputationData} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
   static computeSimulatedMetric(data, context) {
-    const metricData = NavigationMetric.getMetricComputationInput(data);
-    return LanternSpeedIndex.request(metricData, context);
+    return LanternSpeedIndex.request(data, context);
   }
 
   /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.MetricComputationData} data
    * @param {LH.Artifacts.ComputedContext} context
    * @return {Promise<LH.Artifacts.Metric>}
    */

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

@@ -5,8 +5,7 @@
  */
 'use strict';
 
-const ProcessedTrace = require('../processed-trace.js');
-const ProcessedNavigation = require('../processed-navigation.js');
+const TraceOfTab = require('../trace-of-tab.js');
 const Speedline = require('../speedline.js');
 const FirstContentfulPaint = require('./first-contentful-paint.js');
 const FirstContentfulPaintAllFrames = require('./first-contentful-paint-all-frames.js');
@@ -24,13 +23,12 @@ class TimingSummary {
   /**
      * @param {LH.Trace} trace
      * @param {LH.DevtoolsLog} devtoolsLog
-     * @param {LH.Artifacts['GatherContext']} gatherContext
      * @param {ImmutableObject<LH.Config.Settings>} settings
      * @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, settings, context) {
+    const metricComputationData = {trace, devtoolsLog, settings};
     /**
      * @template TArtifacts
      * @template TReturn
@@ -42,21 +40,18 @@ class TimingSummary {
       return Artifact.request(artifact, context).catch(_ => undefined);
     };
 
-    /* eslint-disable max-len */
-
-    const processedTrace = await ProcessedTrace.request(trace, context);
-    const processedNavigation = await requestOrUndefined(ProcessedNavigation, processedTrace);
+    const traceOfTab = await TraceOfTab.request(trace, context);
     const speedline = await Speedline.request(trace, context);
-    const firstContentfulPaint = await requestOrUndefined(FirstContentfulPaint, metricComputationData);
-    const firstContentfulPaintAllFrames = await requestOrUndefined(FirstContentfulPaintAllFrames, metricComputationData);
-    const firstMeaningfulPaint = await requestOrUndefined(FirstMeaningfulPaint, metricComputationData);
-    const largestContentfulPaint = await requestOrUndefined(LargestContentfulPaint, metricComputationData);
-    const largestContentfulPaintAllFrames = await requestOrUndefined(LargestContentfulPaintAllFrames, metricComputationData);
+    const firstContentfulPaint = await FirstContentfulPaint.request(metricComputationData, context);
+    const firstContentfulPaintAllFrames = await requestOrUndefined(FirstContentfulPaintAllFrames, metricComputationData); // eslint-disable-line max-len
+    const firstMeaningfulPaint = await FirstMeaningfulPaint.request(metricComputationData, context);
+    const largestContentfulPaint = await requestOrUndefined(LargestContentfulPaint, metricComputationData); // eslint-disable-line max-len
+    const largestContentfulPaintAllFrames = await requestOrUndefined(LargestContentfulPaintAllFrames, metricComputationData); // eslint-disable-line max-len
     const interactive = await requestOrUndefined(Interactive, metricComputationData);
     const cumulativeLayoutShiftValues = await requestOrUndefined(CumulativeLayoutShift, trace);
     const maxPotentialFID = await requestOrUndefined(MaxPotentialFID, metricComputationData);
     const speedIndex = await requestOrUndefined(SpeedIndex, metricComputationData);
-    const totalBlockingTime = await requestOrUndefined(TotalBlockingTime, metricComputationData);
+    const totalBlockingTime = await TotalBlockingTime.request(metricComputationData, context); // eslint-disable-line max-len
 
     const {
       cumulativeLayoutShift,
@@ -67,50 +62,51 @@ class TimingSummary {
     /** @type {LH.Artifacts.TimingSummary} */
     const metrics = {
       // Include the simulated/observed performance metrics
-      firstContentfulPaint: firstContentfulPaint && firstContentfulPaint.timing,
-      firstContentfulPaintTs: firstContentfulPaint && firstContentfulPaint.timestamp,
-      firstContentfulPaintAllFrames: firstContentfulPaintAllFrames && firstContentfulPaintAllFrames.timing,
-      firstContentfulPaintAllFramesTs: firstContentfulPaintAllFrames && firstContentfulPaintAllFrames.timestamp,
-      firstMeaningfulPaint: firstMeaningfulPaint && firstMeaningfulPaint.timing,
-      firstMeaningfulPaintTs: firstMeaningfulPaint && firstMeaningfulPaint.timestamp,
+      firstContentfulPaint: firstContentfulPaint.timing,
+      firstContentfulPaintTs: firstContentfulPaint.timestamp,
+      firstContentfulPaintAllFrames: firstContentfulPaintAllFrames && firstContentfulPaintAllFrames.timing, // eslint-disable-line max-len
+      firstContentfulPaintAllFramesTs: firstContentfulPaintAllFrames && firstContentfulPaintAllFrames.timestamp, // eslint-disable-line max-len
+      firstMeaningfulPaint: firstMeaningfulPaint.timing,
+      firstMeaningfulPaintTs: firstMeaningfulPaint.timestamp,
       largestContentfulPaint: largestContentfulPaint && largestContentfulPaint.timing,
       largestContentfulPaintTs: largestContentfulPaint && largestContentfulPaint.timestamp,
-      largestContentfulPaintAllFrames: largestContentfulPaintAllFrames && largestContentfulPaintAllFrames.timing,
-      largestContentfulPaintAllFramesTs: largestContentfulPaintAllFrames && largestContentfulPaintAllFrames.timestamp,
+      largestContentfulPaintAllFrames: largestContentfulPaintAllFrames && largestContentfulPaintAllFrames.timing, // eslint-disable-line max-len
+      largestContentfulPaintAllFramesTs: largestContentfulPaintAllFrames && largestContentfulPaintAllFrames.timestamp, // eslint-disable-line max-len
       interactive: interactive && interactive.timing,
       interactiveTs: interactive && interactive.timestamp,
       speedIndex: speedIndex && speedIndex.timing,
       speedIndexTs: speedIndex && speedIndex.timestamp,
-      totalBlockingTime: totalBlockingTime && totalBlockingTime.timing,
+      totalBlockingTime: totalBlockingTime.timing,
       maxPotentialFID: maxPotentialFID && maxPotentialFID.timing,
       cumulativeLayoutShift,
       cumulativeLayoutShiftMainFrame,
       totalCumulativeLayoutShift,
 
       // Include all timestamps of interest from trace of tab
-      observedTimeOrigin: processedTrace.timings.timeOrigin,
-      observedTimeOriginTs: processedTrace.timestamps.timeOrigin,
+      observedTimeOrigin: traceOfTab.timings.timeOrigin,
+      observedTimeOriginTs: traceOfTab.timestamps.timeOrigin,
       // For now, navigationStart is always timeOrigin.
-      observedNavigationStart: processedNavigation && processedNavigation.timings.timeOrigin,
-      observedNavigationStartTs: processedNavigation && processedNavigation.timestamps.timeOrigin,
-      observedFirstPaint: processedNavigation && processedNavigation.timings.firstPaint,
-      observedFirstPaintTs: processedNavigation && processedNavigation.timestamps.firstPaint,
-      observedFirstContentfulPaint: processedNavigation && processedNavigation.timings.firstContentfulPaint,
-      observedFirstContentfulPaintTs: processedNavigation && processedNavigation.timestamps.firstContentfulPaint,
-      observedFirstContentfulPaintAllFrames: processedNavigation && processedNavigation.timings.firstContentfulPaintAllFrames,
-      observedFirstContentfulPaintAllFramesTs: processedNavigation && processedNavigation.timestamps.firstContentfulPaintAllFrames,
-      observedFirstMeaningfulPaint: processedNavigation && processedNavigation.timings.firstMeaningfulPaint,
-      observedFirstMeaningfulPaintTs: processedNavigation && processedNavigation.timestamps.firstMeaningfulPaint,
-      observedLargestContentfulPaint: processedNavigation && processedNavigation.timings.largestContentfulPaint,
-      observedLargestContentfulPaintTs: processedNavigation && processedNavigation.timestamps.largestContentfulPaint,
-      observedLargestContentfulPaintAllFrames: processedNavigation && processedNavigation.timings.largestContentfulPaintAllFrames,
-      observedLargestContentfulPaintAllFramesTs: processedNavigation && processedNavigation.timestamps.largestContentfulPaintAllFrames,
-      observedTraceEnd: processedTrace.timings.traceEnd,
-      observedTraceEndTs: processedTrace.timestamps.traceEnd,
-      observedLoad: processedNavigation && processedNavigation.timings.load,
-      observedLoadTs: processedNavigation && processedNavigation.timestamps.load,
-      observedDomContentLoaded: processedNavigation && processedNavigation.timings.domContentLoaded,
-      observedDomContentLoadedTs: processedNavigation && processedNavigation.timestamps.domContentLoaded,
+      // These properties might be undefined in a future major version, but preserve them for now.
+      observedNavigationStart: traceOfTab.timings.timeOrigin,
+      observedNavigationStartTs: traceOfTab.timestamps.timeOrigin,
+      observedFirstPaint: traceOfTab.timings.firstPaint,
+      observedFirstPaintTs: traceOfTab.timestamps.firstPaint,
+      observedFirstContentfulPaint: traceOfTab.timings.firstContentfulPaint,
+      observedFirstContentfulPaintTs: traceOfTab.timestamps.firstContentfulPaint,
+      observedFirstContentfulPaintAllFrames: traceOfTab.timings.firstContentfulPaintAllFrames,
+      observedFirstContentfulPaintAllFramesTs: traceOfTab.timestamps.firstContentfulPaintAllFrames,
+      observedFirstMeaningfulPaint: traceOfTab.timings.firstMeaningfulPaint,
+      observedFirstMeaningfulPaintTs: traceOfTab.timestamps.firstMeaningfulPaint,
+      observedLargestContentfulPaint: traceOfTab.timings.largestContentfulPaint,
+      observedLargestContentfulPaintTs: traceOfTab.timestamps.largestContentfulPaint,
+      observedLargestContentfulPaintAllFrames: traceOfTab.timings.largestContentfulPaintAllFrames,
+      observedLargestContentfulPaintAllFramesTs: traceOfTab.timestamps.largestContentfulPaintAllFrames, // eslint-disable-line max-len
+      observedTraceEnd: traceOfTab.timings.traceEnd,
+      observedTraceEndTs: traceOfTab.timestamps.traceEnd,
+      observedLoad: traceOfTab.timings.load,
+      observedLoadTs: traceOfTab.timestamps.load,
+      observedDomContentLoaded: traceOfTab.timings.domContentLoaded,
+      observedDomContentLoadedTs: traceOfTab.timestamps.domContentLoaded,
       observedCumulativeLayoutShift: cumulativeLayoutShift,
       observedCumulativeLayoutShiftMainFrame: cumulativeLayoutShiftMainFrame,
       observedTotalCumulativeLayoutShift: totalCumulativeLayoutShift,
@@ -123,24 +119,18 @@ class TimingSummary {
       observedSpeedIndex: speedline.speedIndex,
       observedSpeedIndexTs: (speedline.speedIndex + speedline.beginning) * 1000,
     };
-
-    /* eslint-enable max-len */
-
     /** @type {Record<string,boolean>} */
-    const debugInfo = {
-      lcpInvalidated: !!(processedNavigation && processedNavigation.lcpInvalidated),
-    };
+    const debugInfo = {lcpInvalidated: traceOfTab.lcpInvalidated};
 
     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, settings: ImmutableObject<LH.Config.Settings>}} 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.settings, context);
   }
 }