[DocumentLatency] Get server response time from header for Lightrider

I thought I fixed this, but I overlooked that the trace processor does
not set this field. Only the Lantern usage from Lighthouse was getting
the correct server response time in Lightrider, but the document
lantency insight was still wrong.

Bug: 352244434
Change-Id: I5eb711df4ff791618248426154a8e6a64c923223
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/7001852
Reviewed-by: Paul Irish <paulirish@chromium.org>
Commit-Queue: Connor Clark <cjamcl@chromium.org>

Author: Connor Clark

front_end/models/trace/LanternComputationData.ts

@@ -192,6 +192,7 @@ function createLanternRequest(
     priority: request.args.data.priority,
     frameId: request.args.data.frame,
     fromWorker,
+    serverResponseTime: request.args.data.lrServerResponseTime ?? undefined,
     // Set later.
     redirects: undefined,
     redirectSource: undefined,

front_end/models/trace/handlers/NetworkRequestsHandler.ts

@@ -295,6 +295,7 @@ export async function finalize(): Promise<void> {
      *
      * See `_updateTimingsForLightrider` in Lighthouse for more detail.
      */
+    let lrServerResponseTime;
     if (isLightrider && request.receiveResponse?.args.data.headers) {
       timing = {
         requestTime: Helpers.Timing.microToSeconds(request.sendRequests.at(0)?.ts ?? 0 as Types.Timing.Micro),
@@ -330,6 +331,14 @@ export async function finalize(): Promise<void> {
         timing.connectEnd = TCPMs as Types.Timing.Milli;
         timing.sslEnd = TCPMs as Types.Timing.Milli;
       }
+
+      // Lightrider does not have any equivalent for `sendEnd` timing values. The
+      // closest we can get to the server response time is from a header that
+      // Lightrider sets.
+      const ResponseMsHeader = request.receiveResponse.args.data.headers.find(h => h.name === 'X-ResponseMs');
+      if (ResponseMsHeader) {
+        lrServerResponseTime = Math.max(0, parseInt(ResponseMsHeader.value, 10)) as Types.Timing.Milli;
+      }
     }
 
     // TODO: consider allowing chrome / about.
@@ -526,6 +535,7 @@ export async function finalize(): Promise<void> {
               initiator: finalSendRequest.args.data.initiator,
               stackTrace: finalSendRequest.args.data.stackTrace,
               timing,
+              lrServerResponseTime,
               url,
               failed: request.resourceFinish?.args.data.didFail ?? false,
               finished: Boolean(request.resourceFinish),

front_end/models/trace/insights/DocumentLatency.test.ts

@@ -64,6 +64,51 @@ describeWithEnvironment('DocumentLatency', function() {
     assert.deepEqual(insight.metricSavings, {FCP: 943, LCP: 943} as Trace.Insights.Types.MetricSavings);
   });
 
+  describe('Lightrider', () => {
+    before(() => {
+      // @ts-expect-error
+      globalThis.isLightrider = true;
+    });
+
+    after(() => {
+      // @ts-expect-error
+      delete globalThis.isLightrider;
+    });
+
+    it('reports savings for server with slow server response time (Lightrider)', async function() {
+      const traceEvents = [...await TraceLoader.rawEvents(this, 'lantern/paul/trace.json.gz')];
+      const processor = Trace.Processor.TraceProcessor.createWithAllHandlers();
+
+      const mainRequestEventIndex = traceEvents.findIndex(e => e.name === 'ResourceReceiveResponse');
+      const mainRequestEvent = structuredClone(traceEvents[mainRequestEventIndex]);
+      assert(Types.Events.isResourceReceiveResponse(mainRequestEvent));
+      assert.strictEqual(mainRequestEvent.args.data.requestId, '1000C0FDC0A75327167272FC7438E999');
+      if (!mainRequestEvent.args.data.timing) {
+        throw new Error('missing timing field');
+      }
+
+      delete mainRequestEvent.args.data.timing;
+      mainRequestEvent.args.data.headers = [
+        {name: 'X-ResponseMs', value: '1234'},
+      ];
+
+      traceEvents[mainRequestEventIndex] = mainRequestEvent;
+
+      await processor.parse(traceEvents, {isCPUProfile: false, isFreshRecording: true});
+      const data = processor.data;
+      if (!data) {
+        throw new Error('missing data');
+      }
+
+      const navigation = getFirstOrError(data.Meta.navigationsByNavigationId.values());
+      const context = createContextForNavigation(data, navigation, data.Meta.mainFrameId);
+      const insight = Trace.Insights.Models.DocumentLatency.generateInsight(data, context);
+      assert.strictEqual(insight.data?.serverResponseTime, 1234);
+      assert.isFalse(insight.data?.checklist.serverResponseIsFast.value);
+      assert.deepEqual(insight.metricSavings, {FCP: 1134, LCP: 1134} as Trace.Insights.Types.MetricSavings);
+    });
+  });
+
   it('reports no compression savings for compressed text', async function() {
     const {data, insights} = await processTrace(this, 'lantern/paul/trace.json.gz');
     const insight =

front_end/models/trace/insights/DocumentLatency.ts

@@ -95,15 +95,14 @@ export type DocumentLatencyInsightModel = InsightModel<typeof UIStrings, {
   },
 }>;
 
-function getServerResponseTime(
-    request: Types.Events.SyntheticNetworkRequest, context: InsightSetContext): Types.Timing.Milli|null {
-  // Prefer the value as given by the Lantern provider.
-  // For PSI, Lighthouse uses this to set a better value for the server response
-  // time. For technical reasons, in Lightrider we do not have `sendEnd` timing
-  // values. See Lighthouse's `asLanternNetworkRequest` function for more.
-  const lanternRequest = context.navigation && context.lantern?.requests.find(r => r.rawRequest === request);
-  if (lanternRequest?.serverResponseTime !== undefined) {
-    return lanternRequest.serverResponseTime as Types.Timing.Milli;
+function getServerResponseTime(request: Types.Events.SyntheticNetworkRequest): Types.Timing.Milli|null {
+  // For technical reasons, Lightrider does not have `sendEnd` timing values. The
+  // closest we can get to the server response time is from a header that Lightrider
+  // sets.
+  // @ts-expect-error
+  const isLightrider = globalThis.isLightrider;
+  if (isLightrider) {
+    return request.args.data.lrServerResponseTime ?? null;
   }
 
   const timing = request.args.data.timing;
@@ -202,7 +201,7 @@ export function generateInsight(
     return finalize({warnings: [InsightWarning.NO_DOCUMENT_REQUEST]});
   }
 
-  const serverResponseTime = getServerResponseTime(documentRequest, context);
+  const serverResponseTime = getServerResponseTime(documentRequest);
   if (serverResponseTime === null) {
     throw new Error('missing document request timing');
   }

front_end/models/trace/types/TraceEvents.ts

@@ -415,6 +415,8 @@ export interface SyntheticNetworkRequest extends Complete, SyntheticBased<Phase.
       initiator?: Initiator,
       requestMethod?: string,
       timing?: ResourceReceiveResponseTimingData,
+      /** Server response time according to Lightrider. */
+      lrServerResponseTime?: Milli,
     },
   };
   cat: 'loading';