[RPP] Ignore cached requests in Lantern network analysis

Also check if the network analysis failed to compute a result, and
proactively decide not to make a Lantern context, rather than waiting
for it to throw an error.

Bug: None
Change-Id: Iffdb256114a56effe9c73818d74b8e9490e6d545
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/5949390
Commit-Queue: Paul Irish <[email protected]>
Commit-Queue: Connor Clark <[email protected]>
Auto-Submit: Connor Clark <[email protected]>
Reviewed-by: Paul Irish <[email protected]>

Author: Connor Clark

front_end/models/trace/Processor.ts

@@ -319,6 +319,10 @@ export class TraceProcessor extends EventTarget {
     const processedNavigation = LanternComputationData.createProcessedNavigation(parsedTrace, frameId, navigationId);
 
     const networkAnalysis = Lantern.Core.NetworkAnalyzer.analyze(requests);
+    if (!networkAnalysis) {
+      return;
+    }
+
     const simulator: Lantern.Simulation.Simulator<Types.Events.SyntheticNetworkRequest> =
         Lantern.Simulation.Simulator.createSimulator({
           // TODO(crbug.com/372674229): if devtools throttling was on, does this network analysis capture
@@ -451,7 +455,7 @@ export class TraceProcessor extends EventTarget {
         } else if (!expectedErrors.some(err => e.message === err)) {
           // To reduce noise from tests, only print errors that are not expected to occur because a trace is
           // too old (for which there is no single check).
-          console.error(e.message);
+          console.error(e);
         }
       }
 

front_end/models/trace/lantern/core/NetworkAnalyzer.test.ts

@@ -42,7 +42,7 @@ describe('NetworkAnalyzer', () => {
           connectionReused: false,
           networkRequestTime: 10,
           networkEndTime: 10,
-          transferSize: 0,
+          transferSize: 10000,
           protocol: opts.protocol || 'http/1.1',
           parsedURL: {scheme: url.match(/https?/)[0], securityOrigin: url.match(/.*\.com/)[0]},
           timing: opts.timing || null,
@@ -339,9 +339,9 @@ describe('NetworkAnalyzer', () => {
       );
     }
 
-    it('should return Infinity for no/missing records', () => {
-      assert.strictEqual(estimateThroughput([]), Infinity);
-      assert.strictEqual(estimateThroughput([createThroughputRecord(0, 0, {finished: false})]), Infinity);
+    it('should return null for no/missing records', () => {
+      assert.strictEqual(estimateThroughput([]), null);
+      assert.strictEqual(estimateThroughput([createThroughputRecord(0, 0, {finished: false})]), null);
     });
 
     it('should compute correctly for a basic waterfall', () => {

front_end/models/trace/lantern/core/NetworkAnalyzer.ts

@@ -412,7 +412,7 @@ class NetworkAnalyzer {
       function collectEstimates(estimator: (e: RequestInfo) => number[] | number | undefined, multiplier = 1): void {
         for (const request of originRequests) {
           const timing = request.timing;
-          if (!timing) {
+          if (!timing || !request.transferSize) {
             continue;
           }
 
@@ -489,9 +489,9 @@ class NetworkAnalyzer {
   /**
    * Computes the average throughput for the given requests in bits/second.
    * Excludes data URI, failed or otherwise incomplete, and cached requests.
-   * Returns Infinity if there were no analyzable network requests.
+   * Returns null if there were no analyzable network requests.
    */
-  static estimateThroughput(records: Lantern.NetworkRequest[]): number {
+  static estimateThroughput(records: Lantern.NetworkRequest[]): number|null {
     let totalBytes = 0;
 
     // We will measure throughput by summing the total bytes downloaded by the total time spent
@@ -518,7 +518,7 @@ class NetworkAnalyzer {
                                .sort((a, b) => a.time - b.time);
 
     if (!timeBoundaries.length) {
-      return Infinity;
+      return null;
     }
 
     let inflight = 0;
@@ -576,8 +576,12 @@ class NetworkAnalyzer {
     };
   }
 
-  static analyze(records: Lantern.NetworkRequest[]): Lantern.Simulation.Settings['networkAnalysis'] {
+  static analyze(records: Lantern.NetworkRequest[]): Lantern.Simulation.Settings['networkAnalysis']|null {
     const throughput = NetworkAnalyzer.estimateThroughput(records);
+    if (throughput === null) {
+      return null;
+    }
+
     return {
       throughput,
       ...NetworkAnalyzer.computeRTTAndServerResponseTime(records),

front_end/models/trace/lantern/simulation/Simulator.ts

@@ -143,7 +143,7 @@ class Simulator<T = Lantern.AnyNetworkObject> {
       throw new Core.LanternError(`Invalid rtt ${this._rtt}`);
     }
     if (!Number.isFinite(this.throughput)) {
-      throw new Core.LanternError(`Invalid rtt ${this.throughput}`);
+      throw new Core.LanternError(`Invalid throughput ${this.throughput}`);
     }
   }
 

front_end/models/trace/lantern/testing/MetricTestUtils.ts

@@ -32,6 +32,10 @@ async function getComputationDataFromFixture({trace, settings, url}: {
   const parsedTrace = await runTrace(trace);
   const requests = Trace.LanternComputationData.createNetworkRequests(trace, parsedTrace);
   const networkAnalysis = Lantern.Core.NetworkAnalyzer.analyze(requests);
+  if (!networkAnalysis) {
+    throw new Error('no networkAnalysis');
+  }
+
   const frameId = parsedTrace.Meta.mainFrameId;
   const navigationId = parsedTrace.Meta.mainFrameNavigations[0].args.data?.navigationId;
   if (!navigationId) {