lighthouse 8.0.0-dev.20210709 → 8.0.0

package/lighthouse-core/audits/seo/http-status-code.js

@@ -6,11 +6,10 @@
 'use strict';
 
 const Audit = require('../audit.js');
-const NetworkRecords = require('../../computed/network-records.js');
+const MainResource = require('../../computed/main-resource.js');
 const HTTP_UNSUCCESSFUL_CODE_LOW = 400;
 const HTTP_UNSUCCESSFUL_CODE_HIGH = 599;
 const i18n = require('../../lib/i18n/i18n.js');
-const NetworkAnalyzer = require('../../lib/dependency-graph/simulator/network-analyzer.js');
 
 const UIStrings = {
   /** Title of a Lighthouse audit that provides detail on the HTTP status code a page responds with. This descriptive title is shown when the page has responded with a valid HTTP status code. */
@@ -34,7 +33,7 @@ class HTTPStatusCode extends Audit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      requiredArtifacts: ['devtoolsLogs', 'URL', 'GatherContext'],
+      requiredArtifacts: ['devtoolsLogs', 'URL'],
     };
   }
 
@@ -43,30 +42,26 @@ class HTTPStatusCode extends Audit {
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static async audit(artifacts, context) {
+  static audit(artifacts, context) {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const URL = artifacts.URL;
-    const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    const mainResource = NetworkAnalyzer.findOptionalMainDocument(networkRecords, URL.finalUrl);
 
-    if (!mainResource) {
-      if (artifacts.GatherContext.gatherMode === 'timespan') return {notApplicable: true, score: 1};
-      throw new Error(`Unable to locate main resource`);
-    }
+    return MainResource.request({devtoolsLog, URL}, context)
+      .then(mainResource => {
+        const statusCode = mainResource.statusCode;
 
-    const statusCode = mainResource.statusCode;
-
-    if (statusCode >= HTTP_UNSUCCESSFUL_CODE_LOW &&
+        if (statusCode >= HTTP_UNSUCCESSFUL_CODE_LOW &&
           statusCode <= HTTP_UNSUCCESSFUL_CODE_HIGH) {
-      return {
-        score: 0,
-        displayValue: `${statusCode}`,
-      };
-    }
+          return {
+            score: 0,
+            displayValue: `${statusCode}`,
+          };
+        }
 
-    return {
-      score: 1,
-    };
+        return {
+          score: 1,
+        };
+      });
   }
 }
 

package/lighthouse-core/audits/seo/is-crawlable.js

@@ -32,7 +32,7 @@ const str_ = i18n.createMessageInstanceIdFn(__filename, UIStrings);
 /**
  * Checks if given directive is a valid unavailable_after directive with a date in the past
  * @param {string} directive
- * @return {boolean}
+ * @returns {boolean}
  */
 function isUnavailable(directive) {
   const parts = directive.split(':');
@@ -49,7 +49,7 @@ function isUnavailable(directive) {
 /**
  * Returns true if any of provided directives blocks page from being indexed
  * @param {string} directives
- * @return {boolean}
+ * @returns {boolean}
  */
 function hasBlockingDirective(directives) {
   return directives.split(',')
@@ -60,7 +60,7 @@ function hasBlockingDirective(directives) {
 /**
  * Returns true if robots header specifies user agent (e.g. `googlebot: noindex`)
  * @param {string} directives
- * @return {boolean}
+ * @returns {boolean}
  */
 function hasUserAgent(directives) {
   const parts = directives.match(/^([^,:]+):/);
@@ -80,7 +80,6 @@ class IsCrawlable extends Audit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      supportedModes: ['navigation'],
       requiredArtifacts: ['MetaElements', 'RobotsTxt', 'URL', 'devtoolsLogs'],
     };
   }

package/lighthouse-core/audits/seo/robots-txt.js

@@ -101,7 +101,7 @@ function verifyDirective(directiveName, directiveValue) {
 /**
  * @param {string} line single line from a robots.txt file
  * @throws will throw an exception if given line has errors
- * @return {{directive: string, value: string}|null}
+ * @returns {{directive: string, value: string}|null}
  */
 function parseLine(line) {
   const hashIndex = line.indexOf('#');
@@ -135,7 +135,7 @@ function parseLine(line) {
 
 /**
  * @param {string} content
- * @return {Array<{index: string, line: string, message: string}>}
+ * @returns {Array<{index: string, line: string, message: string}>}
  */
 function validateRobots(content) {
   /**

package/lighthouse-core/audits/seo/tap-targets.js

@@ -72,7 +72,7 @@ function clientRectBelowMinimumSize(cr) {
 /**
  * A target is "too small" if none of its clientRects are at least the size of a finger.
  * @param {BoundedTapTarget[]} targets
- * @return {BoundedTapTarget[]}
+ * @returns {BoundedTapTarget[]}
  */
 function getTooSmallTargets(targets) {
   return targets.filter(target => {
@@ -83,7 +83,7 @@ function getTooSmallTargets(targets) {
 /**
  * @param {BoundedTapTarget[]} tooSmallTargets
  * @param {BoundedTapTarget[]} allTargets
- * @return {TapTargetOverlapFailure[]}
+ * @returns {TapTargetOverlapFailure[]}
  */
 function getAllOverlapFailures(tooSmallTargets, allTargets) {
   /** @type {TapTargetOverlapFailure[]} */
@@ -138,7 +138,7 @@ function getAllOverlapFailures(tooSmallTargets, allTargets) {
 /**
  * @param {LH.Artifacts.Rect[]} tappableRects
  * @param {LH.Artifacts.Rect[]} maybeOverlappingRects
- * @return {ClientRectOverlapFailure | null}
+ * @returns {ClientRectOverlapFailure | null}
  */
 function getOverlapFailureForTargetPair(tappableRects, maybeOverlappingRects) {
   /** @type ClientRectOverlapFailure | null */
@@ -176,7 +176,7 @@ function getOverlapFailureForTargetPair(tappableRects, maybeOverlappingRects) {
 /**
  * Only report one failure if two targets overlap each other
  * @param {TapTargetOverlapFailure[]} overlapFailures
- * @return {TapTargetOverlapFailure[]}
+ * @returns {TapTargetOverlapFailure[]}
  */
 function mergeSymmetricFailures(overlapFailures) {
   /** @type TapTargetOverlapFailure[] */
@@ -212,7 +212,7 @@ function mergeSymmetricFailures(overlapFailures) {
 
 /**
  * @param {TapTargetOverlapFailure[]} overlapFailures
- * @return {TapTargetTableItem[]}
+ * @returns {TapTargetTableItem[]}
  */
 function getTableItems(overlapFailures) {
   const tableItems = overlapFailures.map(failure => {

package/lighthouse-core/audits/server-response-time.js

@@ -8,8 +8,6 @@
 const Audit = require('./audit.js');
 const i18n = require('../lib/i18n/i18n.js');
 const MainResource = require('../computed/main-resource.js');
-const NetworkRecords = require('../computed/network-records.js');
-const NetworkAnalyzer = require('../lib/dependency-graph/simulator/network-analyzer.js');
 
 const UIStrings = {
   /** Title of a diagnostic audit that provides detail on how long it took from starting a request to when the server started responding. This descriptive title is shown to users when the amount is acceptable and no user action is required. */
@@ -39,8 +37,7 @@ class ServerResponseTime extends Audit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      supportedModes: ['timespan', 'navigation'],
-      requiredArtifacts: ['devtoolsLogs', 'URL', 'GatherContext'],
+      requiredArtifacts: ['devtoolsLogs', 'URL'],
     };
   }
 
@@ -59,22 +56,7 @@ class ServerResponseTime extends Audit {
    */
   static async audit(artifacts, context) {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
-
-    /** @type {LH.Artifacts.NetworkRequest} */
-    let mainResource;
-    if (artifacts.GatherContext.gatherMode === 'timespan') {
-      const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-      const optionalMainResource = NetworkAnalyzer.findOptionalMainDocument(
-        networkRecords,
-        artifacts.URL.finalUrl
-      );
-      if (!optionalMainResource) {
-        return {score: null, notApplicable: true};
-      }
-      mainResource = optionalMainResource;
-    } else {
-      mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
-    }
+    const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
 
     const responseTime = ServerResponseTime.calculateResponseTime(mainResource);
     const passed = responseTime < TOO_SLOW_THRESHOLD_MS;

package/lighthouse-core/audits/splash-screen.js

@@ -45,7 +45,6 @@ class SplashScreen extends MultiCheckAudit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      supportedModes: ['navigation'],
       requiredArtifacts: ['WebAppManifest', 'InstallabilityErrors'],
     };
   }

package/lighthouse-core/audits/themed-omnibox.js

@@ -42,7 +42,6 @@ class ThemedOmnibox extends MultiCheckAudit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      supportedModes: ['navigation'],
       requiredArtifacts: ['WebAppManifest', 'InstallabilityErrors', 'MetaElements'],
     };
   }

package/lighthouse-core/audits/third-party-facades.js

@@ -85,7 +85,6 @@ class ThirdPartyFacades extends Audit {
       title: str_(UIStrings.title),
       failureTitle: str_(UIStrings.failureTitle),
       description: str_(UIStrings.description),
-      supportedModes: ['navigation'],
       requiredArtifacts: ['traces', 'devtoolsLogs', 'URL'],
     };
   }

package/lighthouse-core/audits/third-party-summary.js

@@ -10,6 +10,7 @@ const BootupTime = require('./bootup-time.js');
 const i18n = require('../lib/i18n/i18n.js');
 const thirdPartyWeb = require('../lib/third-party-web.js');
 const NetworkRecords = require('../computed/network-records.js');
+const MainResource = require('../computed/main-resource.js');
 const MainThreadTasks = require('../computed/main-thread-tasks.js');
 
 const UIStrings = {
@@ -197,7 +198,8 @@ class ThirdPartySummary extends Audit {
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
-    const mainEntity = thirdPartyWeb.getEntity(artifacts.URL.finalUrl);
+    const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
+    const mainEntity = thirdPartyWeb.getEntity(mainResource.url);
     const tasks = await MainThreadTasks.request(trace, context);
     const multiplier = settings.throttlingMethod === 'simulate' ?
       settings.throttling.cpuSlowdownMultiplier : 1;

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

@@ -36,8 +36,7 @@ class TimingBudget extends Audit {
       title: str_(UIStrings.title),
       description: str_(UIStrings.description),
       scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
-      supportedModes: ['navigation'],
-      requiredArtifacts: ['devtoolsLogs', 'traces', 'URL', 'GatherContext'],
+      requiredArtifacts: ['devtoolsLogs', 'traces', 'URL'],
     };
   }
 
@@ -137,11 +136,10 @@ class TimingBudget extends Audit {
    * @return {Promise<LH.Audit.Product>}
    */
   static async audit(artifacts, context) {
-    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 data = {trace, devtoolsLog, settings: context.settings};
     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

@@ -13,8 +13,7 @@ const i18n = require('../lib/i18n/i18n.js');
 const NetworkRecords = require('../computed/network-records.js');
 const MainResource = require('../computed/main-resource.js');
 const LoadSimulator = require('../computed/load-simulator.js');
-const ProcessedTrace = require('../computed/processed-trace.js');
-const ProcessedNavigation = require('../computed/processed-navigation.js');
+const TraceOfTab = require('../computed/trace-of-tab.js');
 const PageDependencyGraph = require('../computed/page-dependency-graph.js');
 const LanternLCP = require('../computed/metrics/lantern-largest-contentful-paint.js');
 
@@ -63,7 +62,6 @@ class UsesRelPreconnectAudit extends Audit {
       id: 'uses-rel-preconnect',
       title: str_(UIStrings.title),
       description: str_(UIStrings.description),
-      supportedModes: ['navigation'],
       requiredArtifacts: ['traces', 'devtoolsLogs', 'URL', 'LinkElements'],
       scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
     };
@@ -115,19 +113,16 @@ class UsesRelPreconnectAudit extends Audit {
     /** @type {Array<LH.IcuMessage>} */
     const warnings = [];
 
-    const processedTrace = await ProcessedTrace.request(trace, context);
-
-    const [networkRecords, mainResource, loadSimulator, processedNavigation, pageGraph] =
-      await Promise.all([
-        NetworkRecords.request(devtoolsLog, context),
-        MainResource.request({devtoolsLog, URL: artifacts.URL}, context),
-        LoadSimulator.request({devtoolsLog, settings}, context),
-        ProcessedNavigation.request(processedTrace, context),
-        PageDependencyGraph.request({trace, devtoolsLog}, context),
-      ]);
+    const [networkRecords, mainResource, loadSimulator, traceOfTab, pageGraph] = await Promise.all([
+      NetworkRecords.request(devtoolsLog, context),
+      MainResource.request({devtoolsLog, URL: artifacts.URL}, context),
+      LoadSimulator.request({devtoolsLog, settings}, context),
+      TraceOfTab.request(trace, context),
+      PageDependencyGraph.request({trace, devtoolsLog}, context),
+    ]);
 
     const {rtt, additionalRttByOrigin} = loadSimulator.getOptions();
-    const lcpGraph = await LanternLCP.getPessimisticGraph(pageGraph, processedNavigation);
+    const lcpGraph = await LanternLCP.getPessimisticGraph(pageGraph, traceOfTab);
     /** @type {Set<string>} */
     const lcpGraphURLs = new Set();
     lcpGraph.traverse(node => {

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

@@ -42,7 +42,6 @@ class UsesRelPreloadAudit extends Audit {
       id: 'uses-rel-preload',
       title: str_(UIStrings.title),
       description: str_(UIStrings.description),
-      supportedModes: ['navigation'],
       requiredArtifacts: ['devtoolsLogs', 'traces', 'URL'],
       scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
     };
@@ -209,11 +208,11 @@ class UsesRelPreloadAudit extends Audit {
    * @param {LH.Audit.Context} context
    * @return {Promise<LH.Audit.Product>}
    */
-  static async audit_(artifacts, context) {
+  static async audit(artifacts, context) {
     const trace = artifacts.traces[UsesRelPreloadAudit.DEFAULT_PASS];
     const devtoolsLog = artifacts.devtoolsLogs[UsesRelPreloadAudit.DEFAULT_PASS];
     const URL = artifacts.URL;
-    const simulatorOptions = {devtoolsLog, settings: context.settings};
+    const simulatorOptions = {trace, devtoolsLog, settings: context.settings};
 
     const [mainResource, graph, simulator] = await Promise.all([
       MainResource.request({devtoolsLog, URL}, context),
@@ -252,16 +251,6 @@ class UsesRelPreloadAudit extends Audit {
       warnings,
     };
   }
-
-  /**
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit() {
-    // Preload advice is dangerous until https://bugs.chromium.org/p/chromium/issues/detail?id=788757
-    // has been fixed and validated. All preload audits are on hold until then.
-    // See https://github.com/GoogleChrome/lighthouse/issues/11960 for more discussion.
-    return {score: 1, notApplicable: true, details: Audit.makeOpportunityDetails([], [], 0)};
-  }
 }
 
 module.exports = UsesRelPreloadAudit;

package/lighthouse-core/computed/main-thread-tasks.js

@@ -7,7 +7,7 @@
 
 const makeComputedArtifact = require('./computed-artifact.js');
 const MainThreadTasks_ = require('../lib/tracehouse/main-thread-tasks.js');
-const ProcessedTrace = require('./processed-trace.js');
+const TraceOfTab = require('./trace-of-tab.js');
 
 class MainThreadTasks {
   /**
@@ -16,7 +16,7 @@ class MainThreadTasks {
    * @return {Promise<Array<LH.Artifacts.TaskNode>>}
    */
   static async compute_(trace, context) {
-    const {mainThreadEvents, frames, timestamps} = await ProcessedTrace.request(trace, context);
+    const {mainThreadEvents, frames, timestamps} = await TraceOfTab.request(trace, context);
     return MainThreadTasks_.getMainThreadTasks(mainThreadEvents, frames, timestamps.traceEnd);
   }
 }

package/lighthouse-core/computed/metrics/cumulative-layout-shift.js

@@ -6,7 +6,7 @@
 'use strict';
 
 const makeComputedArtifact = require('../computed-artifact.js');
-const ProcessedTrace = require('../processed-trace.js');
+const TraceOfTab = require('../trace-of-tab.js');
 const LHError = require('../../lib/lh-error.js');
 
 /** @typedef {{ts: number, isMainFrame: boolean, weightedScore: number}} LayoutShiftEvent */
@@ -108,10 +108,10 @@ class CumulativeLayoutShift {
    * @return {Promise<{cumulativeLayoutShift: number, cumulativeLayoutShiftMainFrame: number, totalCumulativeLayoutShift: number}>}
    */
   static async compute_(trace, context) {
-    const processedTrace = await ProcessedTrace.request(trace, context);
+    const traceOfTab = await TraceOfTab.request(trace, context);
 
     const allFrameShiftEvents =
-        CumulativeLayoutShift.getLayoutShiftEvents(processedTrace.frameTreeEvents);
+        CumulativeLayoutShift.getLayoutShiftEvents(traceOfTab.frameTreeEvents);
     const mainFrameShiftEvents = allFrameShiftEvents.filter(e => e.isMainFrame);
 
     // The original Cumulative Layout Shift metric, the sum of all main-frame shift events.

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

@@ -6,9 +6,9 @@
 'use strict';
 
 const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
+const ComputedMetric = require('./metric.js');
 
-class FirstContentfulPaintAllFrames extends NavigationMetric {
+class FirstContentfulPaintAllFrames extends ComputedMetric {
   /**
    * @return {Promise<LH.Artifacts.LanternMetric>}
    */
@@ -18,15 +18,15 @@ class FirstContentfulPaintAllFrames extends NavigationMetric {
   }
 
   /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.MetricComputationData} data
    * @return {Promise<LH.Artifacts.Metric>}
    */
   static async computeObservedMetric(data) {
-    const {processedNavigation} = data;
+    const {traceOfTab} = data;
 
     return {
-      timing: processedNavigation.timings.firstContentfulPaintAllFrames,
-      timestamp: processedNavigation.timestamps.firstContentfulPaintAllFrames,
+      timing: traceOfTab.timings.firstContentfulPaintAllFrames,
+      timestamp: traceOfTab.timestamps.firstContentfulPaintAllFrames,
     };
   }
 }

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

@@ -6,30 +6,29 @@
 'use strict';
 
 const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
+const ComputedMetric = require('./metric.js');
 const LanternFirstContentfulPaint = require('./lantern-first-contentful-paint.js');
 
-class FirstContentfulPaint extends NavigationMetric {
+class FirstContentfulPaint 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 LanternFirstContentfulPaint.request(metricData, context);
+    return LanternFirstContentfulPaint.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;
+    const {traceOfTab} = data;
 
     return {
-      timing: processedNavigation.timings.firstContentfulPaint,
-      timestamp: processedNavigation.timestamps.firstContentfulPaint,
+      timing: traceOfTab.timings.firstContentfulPaint,
+      timestamp: traceOfTab.timestamps.firstContentfulPaint,
     };
   }
 }

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

@@ -6,34 +6,33 @@
 'use strict';
 
 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 LanternFirstMeaningfulPaint = require('./lantern-first-meaningful-paint.js');
 
-class FirstMeaningfulPaint extends NavigationMetric {
+class FirstMeaningfulPaint 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 LanternFirstMeaningfulPaint.request(metricData, context);
+    return LanternFirstMeaningfulPaint.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.firstMeaningfulPaint === undefined) {
+    const {traceOfTab} = data;
+    if (traceOfTab.timings.firstMeaningfulPaint === undefined) {
       throw new LHError(LHError.errors.NO_FMP);
     }
 
     return {
-      timing: processedNavigation.timings.firstMeaningfulPaint,
-      timestamp: processedNavigation.timestamps.firstMeaningfulPaint,
+      timing: traceOfTab.timings.firstMeaningfulPaint,
+      timestamp: traceOfTab.timestamps.firstMeaningfulPaint,
     };
   }
 }

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

@@ -6,7 +6,7 @@
 'use strict';
 
 const makeComputedArtifact = require('../computed-artifact.js');
-const NavigationMetric = require('./navigation-metric.js');
+const ComputedMetric = require('./metric.js');
 const LanternInteractive = require('./lantern-interactive.js');
 
 const NetworkMonitor = require('../../gather/driver/network-monitor.js');
@@ -21,16 +21,16 @@ const ALLOWED_CONCURRENT_REQUESTS = 2;
  * resources and is mostly idle.
  * @see https://docs.google.com/document/d/1yE4YWsusi5wVXrnwhR61j-QyjK9tzENIzfxrCjA1NAk/edit#heading=h.yozfsuqcgpc4
  */
-class Interactive extends NavigationMetric {
+class Interactive extends ComputedMetric {
   /**
    * Finds all time periods where the number of inflight requests is less than or equal to the
    * number of allowed concurrent requests (2).
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-   * @param {{timestamps: {traceEnd: number}}} processedNavigation
+   * @param {{timestamps: {traceEnd: number}}} traceOfTab
    * @return {Array<TimePeriod>}
    */
-  static _findNetworkQuietPeriods(networkRecords, processedNavigation) {
-    const traceEndTsInMs = processedNavigation.timestamps.traceEnd / 1000;
+  static _findNetworkQuietPeriods(networkRecords, traceOfTab) {
+    const traceEndTsInMs = traceOfTab.timestamps.traceEnd / 1000;
     // Ignore records that failed, never finished, or were POST/PUT/etc.
     const filteredNetworkRecords = networkRecords.filter(record => {
       return record.finished && record.requestMethod === 'GET' && !record.failed &&
@@ -44,12 +44,12 @@ class Interactive extends NavigationMetric {
   /**
    * Finds all time periods where there are no long tasks.
    * @param {Array<TimePeriod>} longTasks
-   * @param {{timestamps: {timeOrigin: number, traceEnd: number}}} processedNavigation
+   * @param {{timestamps: {timeOrigin: number, traceEnd: number}}} traceOfTab
    * @return {Array<TimePeriod>}
    */
-  static _findCPUQuietPeriods(longTasks, processedNavigation) {
-    const timeOriginTsInMs = processedNavigation.timestamps.timeOrigin / 1000;
-    const traceEndTsInMs = processedNavigation.timestamps.traceEnd / 1000;
+  static _findCPUQuietPeriods(longTasks, traceOfTab) {
+    const timeOriginTsInMs = traceOfTab.timestamps.timeOrigin / 1000;
+    const traceEndTsInMs = traceOfTab.timestamps.traceEnd / 1000;
     if (longTasks.length === 0) {
       return [{start: 0, end: traceEndTsInMs}];
     }
@@ -84,19 +84,19 @@ class Interactive extends NavigationMetric {
    * Finds the first time period where a network quiet period and a CPU quiet period overlap.
    * @param {Array<TimePeriod>} longTasks
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-   * @param {LH.Artifacts.ProcessedNavigation} processedNavigation
+   * @param {LH.Artifacts.TraceOfTab} traceOfTab
    * @return {{cpuQuietPeriod: TimePeriod, networkQuietPeriod: TimePeriod, cpuQuietPeriods: Array<TimePeriod>, networkQuietPeriods: Array<TimePeriod>}}
    */
-  static findOverlappingQuietPeriods(longTasks, networkRecords, processedNavigation) {
-    const FcpTsInMs = processedNavigation.timestamps.firstContentfulPaint / 1000;
+  static findOverlappingQuietPeriods(longTasks, networkRecords, traceOfTab) {
+    const FcpTsInMs = traceOfTab.timestamps.firstContentfulPaint / 1000;
 
     /** @type {function(TimePeriod):boolean} */
     const isLongEnoughQuietPeriod = period =>
         period.end > FcpTsInMs + REQUIRED_QUIET_WINDOW &&
         period.end - period.start >= REQUIRED_QUIET_WINDOW;
-    const networkQuietPeriods = this._findNetworkQuietPeriods(networkRecords, processedNavigation)
+    const networkQuietPeriods = this._findNetworkQuietPeriods(networkRecords, traceOfTab)
         .filter(isLongEnoughQuietPeriod);
-    const cpuQuietPeriods = this._findCPUQuietPeriods(longTasks, processedNavigation)
+    const cpuQuietPeriods = this._findCPUQuietPeriods(longTasks, traceOfTab)
         .filter(isLongEnoughQuietPeriod);
 
     const cpuQueue = cpuQuietPeriods.slice();
@@ -141,42 +141,41 @@ class Interactive extends NavigationMetric {
   }
 
   /**
-   * @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 LanternInteractive.request(metricData, context);
+    return LanternInteractive.request(data, context);
   }
 
   /**
-   * @param {LH.Artifacts.NavigationMetricComputationData} data
+   * @param {LH.Artifacts.MetricComputationData} data
    * @return {Promise<LH.Artifacts.Metric>}
    */
   static computeObservedMetric(data) {
-    const {processedTrace, processedNavigation, networkRecords} = data;
+    const {traceOfTab, networkRecords} = data;
 
-    if (!processedNavigation.timestamps.domContentLoaded) {
+    if (!traceOfTab.timestamps.domContentLoaded) {
       throw new LHError(LHError.errors.NO_DCL);
     }
 
-    const longTasks = TracingProcessor.getMainThreadTopLevelEvents(processedTrace)
+    const longTasks = TracingProcessor.getMainThreadTopLevelEvents(traceOfTab)
         .filter(event => event.duration >= 50);
     const quietPeriodInfo = Interactive.findOverlappingQuietPeriods(
       longTasks,
       networkRecords,
-      processedNavigation
+      traceOfTab
     );
 
     const cpuQuietPeriod = quietPeriodInfo.cpuQuietPeriod;
 
     const timestamp = Math.max(
       cpuQuietPeriod.start,
-      processedNavigation.timestamps.firstContentfulPaint / 1000,
-      processedNavigation.timestamps.domContentLoaded / 1000
+      traceOfTab.timestamps.firstContentfulPaint / 1000,
+      traceOfTab.timestamps.domContentLoaded / 1000
     ) * 1000;
-    const timing = (timestamp - processedNavigation.timestamps.timeOrigin) / 1000;
+    const timing = (timestamp - traceOfTab.timestamps.timeOrigin) / 1000;
     return Promise.resolve({timing, timestamp});
   }
 }