chrome-devtools-frontend 1.0.1402249 → 1.0.1418433

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

@@ -2,8 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// @ts-nocheck TODO(crbug.com/348449529)
-
+import type * as Protocol from '../../../../generated/protocol.js';
 import {TraceLoader} from '../../../../testing/TraceLoader.js';
 import * as Trace from '../../trace.js';
 import * as Lantern from '../lantern.js';
@@ -15,45 +14,70 @@ const {Simulator, DNSCache} = Lantern.Simulation;
 let nextRequestId = 1;
 let nextTid = 1;
 
-async function createGraph(trace: Lantern.Trace) {
+async function createGraph(trace: Lantern.Types.Trace) {
   const parsedTrace = await runTrace(trace);
   const requests = Trace.LanternComputationData.createNetworkRequests(trace, parsedTrace);
   return Trace.LanternComputationData.createGraph(requests, trace, parsedTrace);
 }
 
-function request(opts) {
+interface FakeRequestOpts {
+  startTime?: number;
+  endTime?: number;
+  requestId?: number;
+  transferSize?: number;
+  scheme?: number;
+  timing?: Protocol.Network.ResourceTiming;
+  fromDiskCache?: boolean;
+  url?: string;
+  parsedURL?: {scheme?: string, host?: string, securityOrigin?: string};
+  protocol?: string;
+  networkRequestTime?: number;
+  connectionId?: number;
+  priority?: Lantern.Types.ResourcePriority;
+  resourceSize?: number;
+}
+// Instantiating a Simulator instance requires this value, but it isn't really
+// needed for the sake of these tests, so we hardcode a reasonable value here
+// to use throughout.
+const observedThroughput = 240000;
+
+function request(opts: FakeRequestOpts): Lantern.Types.NetworkRequest {
   const scheme = opts.scheme || 'http';
   const url = `${scheme}://example.com`;
-  const rendererStartTime = opts.startTime;
-  const networkEndTime = opts.endTime;
+  const rendererStartTime = opts.startTime ?? 0;
+  const networkEndTime = opts.endTime ?? 0;
   delete opts.startTime;
   delete opts.endTime;
 
   return Object.assign(
-      {
-        requestId: opts.requestId || nextRequestId++,
-        url,
-        transferSize: opts.transferSize || 1000,
-        protocol: scheme,
-        parsedURL: {scheme, host: 'example.com', securityOrigin: url},
-        timing: opts.timing,
-        rendererStartTime,
-        networkEndTime,
-      },
-      opts);
+             {
+               requestId: opts.requestId || nextRequestId++,
+               url,
+               transferSize: opts.transferSize || 1000,
+               protocol: scheme,
+               parsedURL: {scheme, host: 'example.com', securityOrigin: url},
+               timing: opts.timing,
+               rendererStartTime,
+               networkEndTime,
+             },
+             opts) as unknown as Lantern.Types.NetworkRequest;
 }
 
-function cpuTask({tid, ts, duration}) {
+function cpuTask({tid, ts, duration}: {
+  tid?: number,
+  ts?: number,
+  duration?: number,
+}): Trace.Lantern.Types.TraceEvent {
   tid = tid || nextTid++;
   ts = ts || 0;
   const dur = ((duration || 0) * 1000) / 5;
-  return {tid, ts, dur};
+  return {tid, ts, dur} as Trace.Lantern.Types.TraceEvent;
 }
 
 describe('DependencyGraph/Simulator', () => {
   // Insulate the simulator tests from DNS multiplier changes
-  let originalDNSMultiplier;
-  let trace: Lantern.Trace;
+  let originalDNSMultiplier: number = 1;
+  let trace: Lantern.Types.Trace;
 
   before(async function() {
     trace = toLanternTrace(await TraceLoader.rawEvents(this, 'lantern/progressive-app/trace.json.gz'));
@@ -68,17 +92,20 @@ describe('DependencyGraph/Simulator', () => {
   describe('.simulate', () => {
     const serverResponseTimeByOrigin = new Map([['http://example.com', 500]]);
 
-    function assertNodeTiming(result, node, assertions) {
+    function assertNodeTiming(
+        result: Lantern.Simulation.Result, node: Lantern.Graph.NetworkNode|Lantern.Graph.CPUNode,
+        assertions: Partial<Trace.Lantern.Types.Simulation.NodeTiming>) {
       const timing = result.nodeTimings.get(node);
       assert.isOk(timing, 'missing node timing information');
-      Object.keys(assertions).forEach(key => {
+      Object.keys(assertions).forEach(k => {
+        const key = k as keyof Trace.Lantern.Types.Simulation.NodeTiming;
         assert.strictEqual(timing[key], assertions[key]);
       });
     }
 
     it('should simulate basic network graphs', () => {
       const rootNode = new NetworkNode(request({}));
-      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const simulator = new Simulator({serverResponseTimeByOrigin, observedThroughput: 1});
       const result = simulator.simulate(rootNode);
       // should be 3 RTTs and 500ms for the server response time
       assert.strictEqual(result.timeInMs, 450 + 500);
@@ -93,6 +120,7 @@ describe('DependencyGraph/Simulator', () => {
       const simulator = new Simulator({
         serverResponseTimeByOrigin,
         cpuSlowdownMultiplier: 5,
+        observedThroughput: 1,
       });
       const result = simulator.simulate(rootNode);
       // should be 3 RTTs and 500ms for the server response time + 200 CPU
@@ -111,7 +139,7 @@ describe('DependencyGraph/Simulator', () => {
       nodeB.addDependent(nodeC);
       nodeC.addDependent(nodeD);
 
-      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const simulator = new Simulator({serverResponseTimeByOrigin, observedThroughput: 1});
       const result = simulator.simulate(nodeA);
       // should be 950ms for A, 650ms each for B, C, D (no DNS and one-way connection)
       assert.strictEqual(result.timeInMs, 2900);
@@ -126,7 +154,7 @@ describe('DependencyGraph/Simulator', () => {
       const nodeB = new NetworkNode(request({startTime: 0, endTime: 3, fromDiskCache: true}));
       nodeA.addDependent(nodeB);
 
-      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const simulator = new Simulator({serverResponseTimeByOrigin, observedThroughput: 1});
       const result = simulator.simulate(nodeA);
       // should be ~8ms each for A, B
       assert.strictEqual(result.timeInMs, 16);
@@ -143,7 +171,7 @@ describe('DependencyGraph/Simulator', () => {
           new NetworkNode(request({startTime: 0, endTime: 3, url, parsedURL, protocol, resourceSize: 1024 * 1024}));
       nodeA.addDependent(nodeB);
 
-      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const simulator = new Simulator({serverResponseTimeByOrigin, observedThroughput: 1});
       const result = simulator.simulate(nodeA);
 
       // should be ~2ms for A (resourceSize 0), ~12ms for B (resourceSize 1MB)
@@ -165,6 +193,7 @@ describe('DependencyGraph/Simulator', () => {
       const simulator = new Simulator({
         serverResponseTimeByOrigin,
         cpuSlowdownMultiplier: 5,
+        observedThroughput: 1,
       });
       const result = simulator.simulate(nodeA);
       // should be 800ms A, then 1000 ms total for B, C, D in serial
@@ -192,6 +221,7 @@ describe('DependencyGraph/Simulator', () => {
       const simulator = new Simulator({
         serverResponseTimeByOrigin,
         cpuSlowdownMultiplier: 5,
+        observedThroughput: 1,
       });
       const result = simulator.simulate(nodeA);
       // should be 950ms for A, 650ms each for B, C, D, with F finishing 700 ms after D
@@ -208,7 +238,7 @@ describe('DependencyGraph/Simulator', () => {
       nodeA.addDependent(nodeC);
       nodeA.addDependent(nodeD);
 
-      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const simulator = new Simulator({serverResponseTimeByOrigin, observedThroughput: 1});
       const result = simulator.simulate(nodeA);
       // should be 950ms for A and 950ms for C (2 round trips of downloading, but no DNS)
       assert.strictEqual(result.timeInMs, 950 + 950);
@@ -224,7 +254,7 @@ describe('DependencyGraph/Simulator', () => {
       nodeA.addDependent(nodeC);
       nodeA.addDependent(nodeD);
 
-      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const simulator = new Simulator({serverResponseTimeByOrigin, observedThroughput: 1});
       const result = simulator.simulate(nodeA);
       // should be 950ms for A, 650ms for B reusing connection, 800ms for C and D in parallel.
       assert.strictEqual(result.timeInMs, 950 + 800);
@@ -251,7 +281,7 @@ describe('DependencyGraph/Simulator', () => {
       // 1 RT 80 kbps b/c it needs to grow congestion window from being shared
       // 1 RT 160 kbps b/c TCP
       // 2 RT 240 kbps b/c throughput cap
-      const simulator = new Simulator({serverResponseTimeByOrigin, throughput: 240000});
+      const simulator = new Simulator({serverResponseTimeByOrigin, throughput: 240000, observedThroughput: 240000});
       const result = simulator.simulate(nodeA);
       // should be 950ms for A and 1400ms for C (5 round trips of downloading)
       assert.strictEqual(result.timeInMs, 950 + (150 + 750 + 500));
@@ -273,7 +303,8 @@ describe('DependencyGraph/Simulator', () => {
         rootNode.addDependent(imageNode);
       }
 
-      const simulator = new Simulator({serverResponseTimeByOrigin, maximumConcurrentRequests: 1});
+      const simulator =
+          new Simulator({serverResponseTimeByOrigin, maximumConcurrentRequests: 1, observedThroughput: 1});
       const result = simulator.simulate(rootNode);
 
       // should be 3 RTs + SRT for rootNode (950ms)
@@ -302,7 +333,7 @@ describe('DependencyGraph/Simulator', () => {
         rootNode.addDependent(imageNode);
       }
 
-      const simulator = new Simulator({serverResponseTimeByOrigin, maximumConcurrentRequests: 1});
+      const simulator = new Simulator({serverResponseTimeByOrigin, maximumConcurrentRequests: 1, observedThroughput});
       const result = simulator.simulate(rootNode);
 
       // should be 3 RTs + SRT for rootNode (950ms)
@@ -316,7 +347,7 @@ describe('DependencyGraph/Simulator', () => {
     });
 
     it('should simulate two graphs in a row', () => {
-      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const simulator = new Simulator({serverResponseTimeByOrigin, observedThroughput});
 
       const nodeA = new NetworkNode(request({}));
       const nodeB = new NetworkNode(request({}));
@@ -344,7 +375,7 @@ describe('DependencyGraph/Simulator', () => {
     });
 
     it('should maximize throughput with H2', () => {
-      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const simulator = new Simulator({serverResponseTimeByOrigin, observedThroughput});
       const connectionDefaults = {protocol: 'h2', connectionId: 1};
       const nodeA = new NetworkNode(request({startTime: 0, endTime: 1, ...connectionDefaults}));
       const nodeB = new NetworkNode(request({startTime: 1, endTime: 2, ...connectionDefaults}));
@@ -372,7 +403,7 @@ describe('DependencyGraph/Simulator', () => {
       rootNode.addDependency(depNode);
       depNode.addDependency(rootNode);
 
-      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const simulator = new Simulator({serverResponseTimeByOrigin, observedThroughput});
       assert.throws(() => simulator.simulate(rootNode), /cycle/);
     });
 
@@ -381,14 +412,14 @@ describe('DependencyGraph/Simulator', () => {
 
       it('should compute a timeInMs', async function() {
         const graph = await createGraph(trace);
-        const simulator = new Simulator({serverResponseTimeByOrigin});
+        const simulator = new Simulator({serverResponseTimeByOrigin, observedThroughput});
         const result = simulator.simulate(graph);
         expect(result.timeInMs).to.be.greaterThan(100);
       });
 
       it('should sort the task event times', async () => {
         const graph = await createGraph(trace);
-        const simulator = new Simulator({serverResponseTimeByOrigin});
+        const simulator = new Simulator({serverResponseTimeByOrigin, observedThroughput});
         const result = simulator.simulate(graph);
         const nodeTimings = Array.from(result.nodeTimings.entries());
 

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

@@ -279,7 +279,7 @@ class Simulator<T = Lantern.AnyNetworkObject> {
   }
 
   /**
-   * Estimates the number of milliseconds remaining given current condidtions before the node is complete.
+   * Estimates the number of milliseconds remaining given current conditions before the node is complete.
    */
   estimateTimeRemaining(node: Graph.Node): number {
     if (node.type === Graph.BaseNode.types.CPU) {
@@ -353,7 +353,7 @@ class Simulator<T = Lantern.AnyNetworkObject> {
   }
 
   /**
-   * Given a time period, computes the progress toward completion that the node made durin that time.
+   * Given a time period, computes the progress toward completion that the node made during that time.
    */
   updateProgressMadeInTimePeriod(node: Graph.Node, timePeriodLength: number, totalElapsedTime: number): void {
     const timingData = this.nodeTimings.getInProgress(node);
@@ -488,7 +488,7 @@ class Simulator<T = Lantern.AnyNetworkObject> {
         throw new Core.LanternError('Failed to start a node');
       }
 
-      // set the available throughput for all connections based on # inflight
+      // set the available throughput for all connections based on # in-flight
       this.updateNetworkCapacity();
 
       // find the time that the next node will finish
@@ -535,6 +535,7 @@ class Simulator<T = Lantern.AnyNetworkObject> {
     return Math.round(wastedMs / 10) * 10;
   }
 
+  // Used by Lighthouse asset-saver
   static get allNodeTimings(): Map<string, Map<Graph.Node, CompleteNodeTiming>> {
     return ALL_SIMULATION_NODE_TIMINGS;
   }

package/front_end/models/trace/lantern/simulation/TCPConnection.ts

@@ -70,10 +70,6 @@ class TCPConnection {
     this.warmed = warmed;
   }
 
-  isWarm(): boolean {
-    return this.warmed;
-  }
-
   isH2(): boolean {
     return this.h2;
   }

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

@@ -50,7 +50,7 @@ async function getComputationDataFromFixture({trace, settings, url}: {
 }
 
 export {
-  toLanternTrace,
-  runTrace,
   getComputationDataFromFixture,
+  runTrace,
+  toLanternTrace,
 };

package/front_end/models/trace/lantern/types/Lantern.ts

@@ -25,8 +25,8 @@ export const NetworkRequestTypes = {
   Prefetch: 'Prefetch',
 } as const;
 
-export type TraceEvent = {
-  name: string,
+export interface TraceEvent {
+  name: string;
   args: {
     name?: string,
     data?: {
@@ -37,42 +37,42 @@ export type TraceEvent = {
       }[],
       url?: string,
     },
-  },
-  pid: number,
-  tid: number,
+  };
+  pid: number;
+  tid: number;
   /** Timestamp of the event in microseconds. */
-  ts: number,
-  dur: number,
-};
-export type Trace = {
-  traceEvents: TraceEvent[],
-};
+  ts: number;
+  dur: number;
+}
+export interface Trace {
+  traceEvents: TraceEvent[];
+}
 export type ResourcePriority = ('VeryLow'|'Low'|'Medium'|'High'|'VeryHigh');
 export type ResourceType = keyof typeof NetworkRequestTypes;
 type InitiatorType = ('parser'|'script'|'preload'|'SignedExchange'|'preflight'|'other');
 export type ResourceTiming = Protocol.Network.ResourceTiming;
-type CallStack = {
+export interface CallStack {
   callFrames: Array<{
     scriptId: string,
     url: string,
     lineNumber: number,
     columnNumber: number,
     functionName: string,
-  }>,
-  parent?: CallStack,
-};
+  }>;
+  parent?: CallStack;
+}
 
-export type ParsedURL = {
+export interface ParsedURL {
   /**
    * Equivalent to a `new URL(url).protocol` BUT w/o the trailing colon (:)
    */
-  scheme: string,
+  scheme: string;
   /**
    * Equivalent to a `new URL(url).hostname`
    */
-  host: string,
-  securityOrigin: string,
-};
+  host: string;
+  securityOrigin: string;
+}
 
 // When Lantern NetworkRequests are constructed, the source-of-truth of the network record is given as `rawRequest`.
 // Internally Lantern doesn't care about the type of this field, so a default type is given to simplify internal code
@@ -82,70 +82,70 @@ export type ParsedURL = {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type AnyNetworkObject = any;
 
-export type NetworkRequest<T = AnyNetworkObject> = {
-  requestId: string,
-  connectionId: number,
-  connectionReused: boolean,
-  url: string,
-  protocol: string,
-  parsedURL: ParsedURL,
-  documentURL: string,
+export interface NetworkRequest<T = AnyNetworkObject> {
+  requestId: string;
+  connectionId: number;
+  connectionReused: boolean;
+  url: string;
+  protocol: string;
+  parsedURL: ParsedURL;
+  documentURL: string;
   /** When the renderer process initially discovers a network request, in milliseconds. */
-  rendererStartTime: number,
+  rendererStartTime: number;
   /**
    * When the network service is about to handle a request, ie. just before going to the
    * HTTP cache or going to the network for DNS/connection setup, in milliseconds.
    */
-  networkRequestTime: number,
+  networkRequestTime: number;
   /**
    * When the last byte of the response headers is received, in milliseconds.
-   * Equal to networkRequestTime if no data is recieved over the
+   * Equal to networkRequestTime if no data is received over the
    * network (ex: cached requests or data urls).
    */
-  responseHeadersEndTime: number,
+  responseHeadersEndTime: number;
   /** When the last byte of the response body is received, in milliseconds. */
-  networkEndTime: number,
-  transferSize: number,
-  resourceSize: number,
-  fromDiskCache: boolean,
-  fromMemoryCache: boolean,
-  isLinkPreload: boolean,
-  finished: boolean,
-  failed: boolean,
-  statusCode: number,
+  networkEndTime: number;
+  transferSize: number;
+  resourceSize: number;
+  fromDiskCache: boolean;
+  fromMemoryCache: boolean;
+  isLinkPreload: boolean;
+  finished: boolean;
+  failed: boolean;
+  statusCode: number;
   /** The network request that redirected to this one */
-  redirectSource: NetworkRequest<T>|undefined,
+  redirectSource: NetworkRequest<T>|undefined;
   /** The network request that this one redirected to */
-  redirectDestination: NetworkRequest<T>|undefined,
+  redirectDestination: NetworkRequest<T>|undefined;
   // TODO: can't use Protocol.Network.Initiator because of type mismatch in Lighthouse initiator.
   initiator: {
     type: InitiatorType,
     url?: string,
     stack?: CallStack,
-  },
-  initiatorRequest: NetworkRequest<T>|undefined,
+  };
+  initiatorRequest: NetworkRequest<T>|undefined;
   /** The chain of network requests that redirected to this one */
-  redirects: NetworkRequest[]|undefined,
-  timing: Protocol.Network.ResourceTiming|undefined,
-  resourceType: ResourceType|undefined,
-  mimeType: string,
-  priority: ResourcePriority,
-  frameId: string|undefined,
-  fromWorker: boolean,
+  redirects: NetworkRequest[]|undefined;
+  timing: Protocol.Network.ResourceTiming|undefined;
+  resourceType: ResourceType|undefined;
+  mimeType: string;
+  priority: ResourcePriority;
+  frameId: string|undefined;
+  fromWorker: boolean;
   /**
    * Optional value for how long the server took to respond to this request.
    * When not provided, the server response time is derived from the timing object.
    */
-  serverResponseTime?: number,
+  serverResponseTime?: number;
   /**
-   * Implementation-specific canoncial data structure that this Lantern NetworkRequest
+   * Implementation-specific canonical data structure that this Lantern NetworkRequest
    * was derived from.
    * Users of Lantern create a NetworkRequest matching this interface,
    * but can store the source-of-truth for their network model in this property.
    * This is then accessible as a read-only property on NetworkNode.
    */
-  rawRequest?: T,
-};
+  rawRequest?: T;
+}
 
 export namespace Simulation {
   export interface URL {

package/front_end/models/trace/root-causes/LayoutShift.test.ts

@@ -40,7 +40,7 @@ function createMockMatchedRules(cssProperties: {name: string, value: string}[]):
 describeWithMockConnection('LayoutShift root causes', () => {
   /*
      * This test has to do a lot of mocking and creating of fake data in order
-     * to function. Normally in the perfomance panel tests we prefer to parse a
+     * to function. Normally in the performance panel tests we prefer to parse a
      * real trace and use that, but in this case because LayoutShift root causes
      * rely on having an actual DevTools instance open with access to the DOM,
      * we can't do that. So therefore we completely mock the set of data
@@ -78,7 +78,7 @@ describeWithMockConnection('LayoutShift root causes', () => {
         shift.args = {
           frame: 'frame-id-123',
         };
-        shift.name = 'LayoutShift';
+        shift.name = Trace.Types.Events.Name.SYNTHETIC_LAYOUT_SHIFT;
       }
 
       const clusters = [{events: shifts}] as unknown as Trace.Types.Events.SyntheticLayoutShiftCluster[];
@@ -265,7 +265,7 @@ describeWithMockConnection('LayoutShift root causes', () => {
              return cause.unsizedMedia.map(media => Number(media.node.backendNodeId));
            });
 
-           // Test the nodes from the LI events are assinged as the potential root causes to layout shifts correctly.
+           // Test the nodes from the LI events are assigned as the potential root causes to layout shifts correctly.
            assert.lengthOf(shiftCausesNodeIds[0], 1);
            assert.strictEqual(shiftCausesNodeIds[0][0], resizeEventsNodeIds[0]);
 
@@ -294,7 +294,6 @@ describeWithMockConnection('LayoutShift root causes', () => {
         const authoredDimensions = rootCause?.unsizedMedia[0].authoredDimensions;
         if (!authoredDimensions) {
           assert.fail('Expected defined authored dimensions');
-          return;
         }
         // Assert inline styles are preferred.
         assert.strictEqual(authoredDimensions.height, '20px');
@@ -314,7 +313,6 @@ describeWithMockConnection('LayoutShift root causes', () => {
         const authoredDimensions = rootCause?.unsizedMedia[0].authoredDimensions;
         if (!authoredDimensions) {
           assert.fail('Expected defined authored dimensions');
-          return;
         }
         // Assert matched CSS rules styles are preferred.
         assert.strictEqual(authoredDimensions.height, '30px');
@@ -332,7 +330,6 @@ describeWithMockConnection('LayoutShift root causes', () => {
         const computedDimensions = rootCause?.unsizedMedia[0].computedDimensions;
         if (!computedDimensions) {
           assert.fail('Expected defined computed dimensions');
-          return;
         }
         // Assert correct computed styles are set.
         assert.strictEqual(computedDimensions.height, height);
@@ -414,7 +411,7 @@ describeWithMockConnection('LayoutShift root causes', () => {
           shift.args = {
             frame: 'frame-id-123',
           };
-          shift.name = 'LayoutShift';
+          shift.name = Trace.Types.Events.Name.SYNTHETIC_LAYOUT_SHIFT;
         }
 
         const clusters = [{events: shifts}] as unknown as Trace.Types.Events.SyntheticLayoutShiftCluster[];
@@ -435,7 +432,7 @@ describeWithMockConnection('LayoutShift root causes', () => {
              return cause.iframes.map(node => Number(node.iframe.backendNodeId));
            });
 
-           // Test the nodes from the LI events are assinged as the potential root causes to layout shifts correctly.
+           // Test the nodes from the LI events are assigned as the potential root causes to layout shifts correctly.
            assert.lengthOf(shiftCausesNodeIds[0], 1);
            assert.strictEqual(shiftCausesNodeIds[0][0], iframesNodeIds[0]);
 
@@ -467,8 +464,8 @@ describeWithMockConnection('LayoutShift root causes', () => {
       // that correspond to font changes.
       const fontRequests = [
         {
-          dur: Trace.Types.Timing.MicroSeconds(2),
-          ts: Trace.Types.Timing.MicroSeconds(0),
+          dur: Trace.Types.Timing.Micro(2),
+          ts: Trace.Types.Timing.Micro(0),
           args: {
             data: {
               url: fontSource,
@@ -477,8 +474,8 @@ describeWithMockConnection('LayoutShift root causes', () => {
           },
         },
         {
-          dur: Trace.Types.Timing.MicroSeconds(30),
-          ts: Trace.Types.Timing.MicroSeconds(0),
+          dur: Trace.Types.Timing.Micro(30),
+          ts: Trace.Types.Timing.Micro(0),
           args: {
             data: {
               url: fontSource,
@@ -510,8 +507,8 @@ describeWithMockConnection('LayoutShift root causes', () => {
 
       it('ignores requests for fonts whose font-display property is "optional"', async () => {
         const optionalFontRequests = [{
-                                       dur: Trace.Types.Timing.MicroSeconds(2),
-                                       ts: Trace.Types.Timing.MicroSeconds(0),
+                                       dur: Trace.Types.Timing.Micro(2),
+                                       ts: Trace.Types.Timing.Micro(0),
                                        args: {
                                          data: {
                                            url: fontSource,
@@ -536,8 +533,8 @@ describeWithMockConnection('LayoutShift root causes', () => {
       it('ignores requests for fonts that lie outside the fixed time window from ending at the "font change" layout invalidation event',
          async () => {
            const optionalFontRequests = [{
-                                          dur: Trace.Types.Timing.MicroSeconds(2),
-                                          ts: Trace.Types.Timing.MicroSeconds(85),
+                                          dur: Trace.Types.Timing.Micro(2),
+                                          ts: Trace.Types.Timing.Micro(85),
                                           args: {
                                             data: {
                                               url: fontSource,
@@ -564,8 +561,8 @@ describeWithMockConnection('LayoutShift root causes', () => {
     describe('Render blocking request', () => {
       const RenderBlockingRequest = [
         {
-          dur: Trace.Types.Timing.MicroSeconds(2),
-          ts: Trace.Types.Timing.MicroSeconds(0),
+          dur: Trace.Types.Timing.Micro(2),
+          ts: Trace.Types.Timing.Micro(0),
           args: {
             data: {
               url: renderBlockSource,
@@ -575,8 +572,8 @@ describeWithMockConnection('LayoutShift root causes', () => {
           },
         },
         {
-          dur: Trace.Types.Timing.MicroSeconds(30),
-          ts: Trace.Types.Timing.MicroSeconds(0),
+          dur: Trace.Types.Timing.Micro(30),
+          ts: Trace.Types.Timing.Micro(0),
           args: {
             data: {
               url: renderBlockSource,