Introduce computedArtifacts

lighthouse-core/audits/critical-request-chains.js

@@ -30,7 +30,7 @@ class CriticalRequestChains extends Audit {
       name: 'critical-request-chains',
       description: 'Critical Request Chains',
       optimalValue: 0,
-      requiredArtifacts: ['CriticalRequestChains']
+      requiredArtifacts: ['networkRecords']
     };
   }
 
@@ -40,31 +40,33 @@ class CriticalRequestChains extends Audit {
    * @return {!AuditResult} The score from the audit, ranging from 0-100.
    */
   static audit(artifacts) {
-    let chainCount = 0;
-    function walk(node, depth) {
-      const children = Object.keys(node);
+    return artifacts.requestCriticalRequestChains(artifacts.networkRecords).then(chains => {
+      let chainCount = 0;
+      function walk(node, depth) {
+        const children = Object.keys(node);
 
-      // Since a leaf node indicates the end of a chain, we can inspect the number
-      // of child nodes, and, if the count is zero, increment the count.
-      if (children.length === 0) {
-        chainCount++;
-      }
+        // Since a leaf node indicates the end of a chain, we can inspect the number
+        // of child nodes, and, if the count is zero, increment the count.
+        if (children.length === 0) {
+          chainCount++;
+        }
 
-      children.forEach(id => {
-        const child = node[id];
-        walk(child.children, depth + 1);
-      }, '');
-    }
+        children.forEach(id => {
+          const child = node[id];
+          walk(child.children, depth + 1);
+        }, '');
+      }
 
-    walk(artifacts.CriticalRequestChains, 0);
+      walk(chains, 0);
 
-    return CriticalRequestChains.generateAuditResult({
-      rawValue: chainCount,
-      optimalValue: this.meta.optimalValue,
-      extendedInfo: {
-        formatter: Formatter.SUPPORTED_FORMATS.CRITICAL_REQUEST_CHAINS,
-        value: artifacts.CriticalRequestChains
-      }
+      return CriticalRequestChains.generateAuditResult({
+        rawValue: chainCount,
+        optimalValue: this.meta.optimalValue,
+        extendedInfo: {
+          formatter: Formatter.SUPPORTED_FORMATS.CRITICAL_REQUEST_CHAINS,
+          value: chains
+        }
+      });
     });
   }
 }

lighthouse-core/audits/estimated-input-latency.js

@@ -35,56 +35,60 @@ class EstimatedInputLatency extends Audit {
       name: 'estimated-input-latency',
       description: 'Estimated Input Latency',
       optimalValue: SCORING_POINT_OF_DIMINISHING_RETURNS.toLocaleString() + 'ms',
-      requiredArtifacts: ['traceContents', 'Speedline']
+      requiredArtifacts: ['traceContents']
     };
   }
 
+  static calculate(speedline, trace) {
+    // Use speedline's first paint as start of range for input latency check.
+    const startTime = speedline.first;
+
+    const tracingProcessor = new TracingProcessor();
+    const model = tracingProcessor.init(trace);
+    const latencyPercentiles = TracingProcessor.getRiskToResponsiveness(model, trace, startTime);
+
+    const ninetieth = latencyPercentiles.find(result => result.percentile === 0.9);
+    const rawValue = parseFloat(ninetieth.time.toFixed(1));
+
+    // Use the CDF of a log-normal distribution for scoring.
+    //  10th Percentile ≈ 58ms
+    //  25th Percentile ≈ 75ms
+    //  Median = 100ms
+    //  75th Percentile ≈ 133ms
+    //  95th Percentile ≈ 199ms
+    const distribution = TracingProcessor.getLogNormalDistribution(SCORING_MEDIAN,
+        SCORING_POINT_OF_DIMINISHING_RETURNS);
+    let score = 100 * distribution.computeComplementaryPercentile(ninetieth.time);
+
+    return EstimatedInputLatency.generateAuditResult({
+      score: Math.round(score),
+      optimalValue: this.meta.optimalValue,
+      rawValue,
+      displayValue: `${rawValue}ms`,
+      extendedInfo: {
+        value: latencyPercentiles,
+        formatter: Formatter.SUPPORTED_FORMATS.ESTIMATED_INPUT_LATENCY
+      }
+    });
+  }
+
   /**
    * Audits the page to estimate input latency.
    * @see https://github.com/GoogleChrome/lighthouse/issues/28
    * @param {!Artifacts} artifacts The artifacts from the gather phase.
-   * @return {!AuditResult} The score from the audit, ranging from 0-100.
+   * @return {!Promise<!AuditResult>} The score from the audit, ranging from 0-100.
    */
   static audit(artifacts) {
-    try {
-      // Use speedline's first paint as start of range for input latency check.
-      const startTime = artifacts.Speedline.first;
-
-      const trace = artifacts.traces[this.DEFAULT_TRACE] &&
-        artifacts.traces[this.DEFAULT_TRACE].traceEvents;
-      const tracingProcessor = new TracingProcessor();
-      const model = tracingProcessor.init(trace);
-      const latencyPercentiles = TracingProcessor.getRiskToResponsiveness(model, trace, startTime);
-
-      const ninetieth = latencyPercentiles.find(result => result.percentile === 0.9);
-      const rawValue = parseFloat(ninetieth.time.toFixed(1));
+    const trace = artifacts.traces[this.DEFAULT_TRACE];
 
-      // Use the CDF of a log-normal distribution for scoring.
-      //  10th Percentile ≈ 58ms
-      //  25th Percentile ≈ 75ms
-      //  Median = 100ms
-      //  75th Percentile ≈ 133ms
-      //  95th Percentile ≈ 199ms
-      const distribution = TracingProcessor.getLogNormalDistribution(SCORING_MEDIAN,
-          SCORING_POINT_OF_DIMINISHING_RETURNS);
-      let score = 100 * distribution.computeComplementaryPercentile(ninetieth.time);
-
-      return EstimatedInputLatency.generateAuditResult({
-        score: Math.round(score),
-        optimalValue: this.meta.optimalValue,
-        rawValue,
-        displayValue: `${rawValue}ms`,
-        extendedInfo: {
-          value: latencyPercentiles,
-          formatter: Formatter.SUPPORTED_FORMATS.ESTIMATED_INPUT_LATENCY
-        }
-      });
-    } catch (err) {
-      return EstimatedInputLatency.generateAuditResult({
-        rawValue: -1,
-        debugString: 'Unable to parse trace contents: ' + err.message
+    return artifacts.requestSpeedline(trace)
+      .then(speedline => EstimatedInputLatency.calculate(speedline, trace))
+      .catch(err => {
+        return EstimatedInputLatency.generateAuditResult({
+          rawValue: -1,
+          debugString: 'Speedline unable to parse trace contents: ' + err.message
+        });
       });
-    }
   }
 }
 

lighthouse-core/audits/first-meaningful-paint.js

@@ -57,7 +57,6 @@ class FirstMeaningfulPaint extends Audit {
       if (!traceContents || !Array.isArray(traceContents)) {
         throw new Error(FAILURE_MESSAGE);
       }
-
       const evts = this.collectEvents(traceContents);
 
       const navStart = evts.navigationStart;

lighthouse-core/audits/screenshots.js

@@ -29,30 +29,38 @@ class Screenshots extends Audit {
       category: 'Performance',
       name: 'screenshots',
       description: 'Screenshots of all captured frames',
-      requiredArtifacts: ['ScreenshotFilmstrip']
+      requiredArtifacts: ['traceContents']
     };
   }
 
   /**
    * @param {!Artifacts} artifacts
-   * @return {!AuditResultInput}
+   * @return {!Promise<!AuditResult>}
    */
   static audit(artifacts) {
-    const screenshots = artifacts.ScreenshotFilmstrip;
-
-    if (typeof screenshots === 'undefined') {
-      return Screenshots.generateAuditResult({
+    const trace = artifacts.traces[this.DEFAULT_TRACE];
+    if (typeof trace === 'undefined') {
+      return Promise.resolve(Screenshots.generateAuditResult({
         rawValue: -1,
-        debugString: 'No screenshot artifact'
-      });
+        debugString: 'No trace found to generate screenshots'
+      }));
     }
 
-    return Screenshots.generateAuditResult({
-      rawValue: screenshots.length || 0,
-      extendedInfo: {
-        formatter: Formatter.SUPPORTED_FORMATS.NULL,
-        value: screenshots
+    return artifacts.requestScreenshots(trace).then(screenshots => {
+      if (typeof screenshots === 'undefined') {
+        return Screenshots.generateAuditResult({
+          rawValue: -1,
+          debugString: 'No screenshot artifact'
+        });
       }
+
+      return Screenshots.generateAuditResult({
+        rawValue: screenshots.length || 0,
+        extendedInfo: {
+          formatter: Formatter.SUPPORTED_FORMATS.NULL,
+          value: screenshots
+        }
+      });
     });
   }
 }

lighthouse-core/audits/speed-index-metric.js

@@ -36,7 +36,7 @@ class SpeedIndexMetric extends Audit {
       name: 'speed-index-metric',
       description: 'Speed Index',
       optimalValue: SCORING_POINT_OF_DIMINISHING_RETURNS.toLocaleString(),
-      requiredArtifacts: ['Speedline']
+      requiredArtifacts: ['traceContents']
     };
   }
 
@@ -47,36 +47,35 @@ class SpeedIndexMetric extends Audit {
    * @return {!Promise<!AuditResult>} The score from the audit, ranging from 0-100.
    */
   static audit(artifacts) {
-    return new Promise((resolve, reject) => {
-      const speedline = artifacts.Speedline;
-
-      // Speedline gather failed; pass on error condition.
-      if (speedline.debugString) {
-        return resolve(SpeedIndexMetric.generateAuditResult({
-          rawValue: -1,
-          debugString: speedline.debugString
-        }));
-      }
+    const trace = artifacts.traces[this.DEFAULT_TRACE];
+    if (typeof trace === 'undefined') {
+      return SpeedIndexMetric.generateAuditResult({
+        rawValue: -1,
+        debugString: 'No trace found to generate screenshots'
+      });
+    }
 
+    // run speedline
+    return artifacts.requestSpeedline(trace).then(speedline => {
       if (speedline.frames.length === 0) {
-        return resolve(SpeedIndexMetric.generateAuditResult({
+        return SpeedIndexMetric.generateAuditResult({
           rawValue: -1,
           debugString: 'Trace unable to find visual progress frames.'
-        }));
+        });
       }
 
       if (speedline.frames.length < 3) {
-        return resolve(SpeedIndexMetric.generateAuditResult({
+        return SpeedIndexMetric.generateAuditResult({
           rawValue: -1,
           debugString: 'Trace unable to find sufficient frames to evaluate Speed Index.'
-        }));
+        });
       }
 
       if (speedline.speedIndex === 0) {
-        return resolve(SpeedIndexMetric.generateAuditResult({
+        return SpeedIndexMetric.generateAuditResult({
           rawValue: -1,
           debugString: 'Error in Speedline calculating Speed Index (speedIndex of 0).'
-        }));
+        });
       }
 
       // Use the CDF of a log-normal distribution for scoring.
@@ -86,7 +85,7 @@ class SpeedIndexMetric extends Audit {
       //  75th Percentile = 8,820
       //  95th Percentile = 17,400
       const distribution = TracingProcessor.getLogNormalDistribution(SCORING_MEDIAN,
-          SCORING_POINT_OF_DIMINISHING_RETURNS);
+        SCORING_POINT_OF_DIMINISHING_RETURNS);
       let score = 100 * distribution.computeComplementaryPercentile(speedline.speedIndex);
 
       // Clamp the score to 0 <= x <= 100.
@@ -105,15 +104,20 @@ class SpeedIndexMetric extends Audit {
         })
       };
 
-      resolve(SpeedIndexMetric.generateAuditResult({
+      return SpeedIndexMetric.generateAuditResult({
         score: Math.round(score),
         rawValue: Math.round(speedline.speedIndex),
         optimalValue: this.meta.optimalValue,
         extendedInfo: {
           formatter: Formatter.SUPPORTED_FORMATS.SPEEDLINE,
           value: extendedInfo
         }
-      }));
+      });
+    }).catch(err => {
+      return SpeedIndexMetric.generateAuditResult({
+        rawValue: -1,
+        debugString: err.message
+      });
     });
   }
 }

lighthouse-core/audits/time-to-interactive.js

@@ -28,7 +28,7 @@ class TTIMetric extends Audit {
       name: 'time-to-interactive',
       description: 'Time To Interactive (alpha)',
       optimalValue: SCORING_POINT_OF_DIMINISHING_RETURNS.toLocaleString(),
-      requiredArtifacts: ['traceContents', 'speedline']
+      requiredArtifacts: ['traceContents']
     };
   }
 
@@ -54,11 +54,17 @@ class TTIMetric extends Audit {
    * will be changing in the future to a more accurate number.
    *
    * @param {!Artifacts} artifacts The artifacts from the gather phase.
-   * @return {!AuditResult} The score from the audit, ranging from 0-100.
+   * @return {!Promise<!AuditResult>} The score from the audit, ranging from 0-100.
    */
   static audit(artifacts) {
+    const trace = artifacts.traces[Audit.DEFAULT_TRACE];
+    const pendingSpeedline = artifacts.requestSpeedline(trace);
+    const pendingFMP = FMPMetric.audit(artifacts);
+
     // We start looking at Math.Max(FMPMetric, visProgress[0.85])
-    return FMPMetric.audit(artifacts).then(fmpResult => {
+    return Promise.all([pendingSpeedline, pendingFMP]).then(results => {
+      const speedline = results[0];
+      const fmpResult = results[1];
       if (fmpResult.rawValue === -1) {
         return generateError(fmpResult.debugString);
       }
@@ -68,8 +74,8 @@ class TTIMetric extends Audit {
 
       // Process the trace
       const tracingProcessor = new TracingProcessor();
-      const traceContents = artifacts.traces[Audit.DEFAULT_TRACE].traceEvents;
-      const model = tracingProcessor.init(traceContents);
+      const trace = artifacts.traces[Audit.DEFAULT_TRACE];
+      const model = tracingProcessor.init(trace);
       const endOfTraceTime = model.bounds.max;
 
       // TODO: Wait for DOMContentLoadedEndEvent
@@ -81,8 +87,8 @@ class TTIMetric extends Audit {
       // look at speedline results for 85% starting at FMP
       let visuallyReadyTiming = 0;
 
-      if (artifacts.Speedline.frames) {
-        const eightyFivePctVC = artifacts.Speedline.frames.find(frame => {
+      if (speedline.frames) {
+        const eightyFivePctVC = speedline.frames.find(frame => {
           return frame.getTimeStamp() >= fMPts && frame.getProgress() >= 85;
         });
 
@@ -111,7 +117,7 @@ class TTIMetric extends Audit {
         }
         // Get our expected latency for the time window
         const latencies = TracingProcessor.getRiskToResponsiveness(
-          model, traceContents, startTime, endTime, percentiles);
+          model, trace, startTime, endTime, percentiles);
         const estLatency = latencies[0].time.toFixed(2);
         foundLatencies.push({
           estLatency: estLatency,
@@ -151,7 +157,7 @@ class TTIMetric extends Audit {
         rawValue: timeToInteractive,
         displayValue: `${timeToInteractive}ms`,
         optimalValue: this.meta.optimalValue,
-        debugString: artifacts.Speedline.debugString,
+        debugString: speedline.debugString,
         extendedInfo: {
           value: extendedInfo,
           formatter: Formatter.SUPPORTED_FORMATS.NULL
@@ -170,6 +176,6 @@ function generateError(err) {
     value: -1,
     rawValue: -1,
     optimalValue: TTIMetric.meta.optimalValue,
-    debugString: err
+    debugString: err.message || err
   });
 }