RPP: rename Timing helper methods

- Renamed `millisecondsToMicroseconds` to `milliToMicro`
- Renamed `secondsToMilliseconds` to `secondsToMilli`
- Renamed `secondsToMicroseconds` to `secondsToMicro`
- Renamed `microSecondsToMilliseconds` to `microToMilli`
- Renamed `microSecondsToSeconds` to `microToSeconds`

Bug: none
Change-Id: I14d6a93d87f181463035ec391fda3076c155a159
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6190947
Auto-Submit: Jack Franklin <[email protected]>
Commit-Queue: Adam Raine <[email protected]>
Reviewed-by: Adam Raine <[email protected]>

Author: jackfranklin

front_end/models/trace/Processor.ts

@@ -503,7 +503,7 @@ export class TraceProcessor extends EventTarget {
     if (navigations.length) {
       const bounds = Helpers.Timing.traceWindowFromMicroSeconds(parsedTrace.Meta.traceBounds.min, navigations[0].ts);
       // When using "Record and reload" option, it typically takes ~5ms. So use 50ms to be safe.
-      const threshold = Helpers.Timing.millisecondsToMicroseconds(50 as Types.Timing.MilliSeconds);
+      const threshold = Helpers.Timing.milliToMicro(50 as Types.Timing.MilliSeconds);
       if (bounds.range > threshold) {
         const context: Insights.Types.InsightSetContext = {
           bounds,

front_end/models/trace/extras/MainThreadActivity.test.ts

@@ -9,7 +9,7 @@ import * as Trace from '../trace.js';
 
 const DEVTOOLS_CATEGORY = 'disabled-by-default-devtools.timeline';
 function milliToMicro(x: number): Trace.Types.Timing.MicroSeconds {
-  return Trace.Helpers.Timing.millisecondsToMicroseconds(Trace.Types.Timing.MilliSeconds(x));
+  return Trace.Helpers.Timing.milliToMicro(Trace.Types.Timing.MilliSeconds(x));
 }
 
 function makeFakeBounds(min: number, max: number): Trace.Types.Timing.TraceWindowMicroSeconds {

front_end/models/trace/extras/TraceTree.test.ts

@@ -137,30 +137,28 @@ describeWithEnvironment('TraceTree', () => {
       assert.strictEqual(rootChildren.size, 2);
 
       const rootChildIterator = rootChildren.values();
-      assert.strictEqual(
-          rootChildIterator.next().value!.selfTime, Trace.Helpers.Timing.microSecondsToMilliseconds(eventA.dur));
+      assert.strictEqual(rootChildIterator.next().value!.selfTime, Trace.Helpers.Timing.microToMilli(eventA.dur));
 
       const nodeB = rootChildIterator.next().value as TraceTree.TopDownNode;
       const nodeBSelfTime = Trace.Types.Timing.MicroSeconds(eventB.dur - eventC.dur - eventD.dur);
-      assert.strictEqual(nodeB.selfTime, Trace.Helpers.Timing.microSecondsToMilliseconds(nodeBSelfTime));
+      assert.strictEqual(nodeB.selfTime, Trace.Helpers.Timing.microToMilli(nodeBSelfTime));
 
       const nodeBChildren = nodeB.children();
       assert.strictEqual(nodeBChildren.size, 2);
 
       const nodeBChildIterator = nodeBChildren.values();
-      assert.strictEqual(
-          nodeBChildIterator.next().value!.selfTime, Trace.Helpers.Timing.microSecondsToMilliseconds(eventC.dur));
+      assert.strictEqual(nodeBChildIterator.next().value!.selfTime, Trace.Helpers.Timing.microToMilli(eventC.dur));
 
       const nodeD = nodeBChildIterator.next().value!;
       const nodeDSelfTime = Trace.Types.Timing.MicroSeconds(eventD.dur - eventE.dur);
-      assert.strictEqual(nodeD.selfTime, Trace.Helpers.Timing.microSecondsToMilliseconds(nodeDSelfTime));
+      assert.strictEqual(nodeD.selfTime, Trace.Helpers.Timing.microToMilli(nodeDSelfTime));
 
       const nodeDChildren = nodeD.children();
       assert.strictEqual(nodeDChildren.size, 1);
 
       const nodeDChildIterator = nodeDChildren.values();
       const nodeE = nodeDChildIterator.next().value!;
-      assert.strictEqual(nodeE.selfTime, Trace.Helpers.Timing.microSecondsToMilliseconds(eventE.dur));
+      assert.strictEqual(nodeE.selfTime, Trace.Helpers.Timing.microToMilli(eventE.dur));
     });
   });
 
@@ -323,22 +321,21 @@ describeWithEnvironment('TraceTree', () => {
       assert.strictEqual(rootChildren.size, 5);
 
       const rootChildIterator = rootChildren.values();
-      assert.strictEqual(
-          rootChildIterator.next().value!.selfTime, Trace.Helpers.Timing.microSecondsToMilliseconds(eventA.dur));
+      assert.strictEqual(rootChildIterator.next().value!.selfTime, Trace.Helpers.Timing.microToMilli(eventA.dur));
 
       const nodeC = rootChildIterator.next().value as TraceTree.TopDownNode;
-      assert.strictEqual(nodeC.selfTime, Trace.Helpers.Timing.microSecondsToMilliseconds(eventC.dur));
+      assert.strictEqual(nodeC.selfTime, Trace.Helpers.Timing.microToMilli(eventC.dur));
 
       const nodeE = rootChildIterator.next().value as TraceTree.TopDownNode;
-      assert.strictEqual(nodeE.selfTime, Trace.Helpers.Timing.microSecondsToMilliseconds(eventE.dur));
+      assert.strictEqual(nodeE.selfTime, Trace.Helpers.Timing.microToMilli(eventE.dur));
 
       const nodeD = rootChildIterator.next().value as TraceTree.TopDownNode;
       const nodeDSelfTime = Trace.Types.Timing.MicroSeconds(eventD.dur - eventE.dur);
-      assert.strictEqual(nodeD.selfTime, Trace.Helpers.Timing.microSecondsToMilliseconds(nodeDSelfTime));
+      assert.strictEqual(nodeD.selfTime, Trace.Helpers.Timing.microToMilli(nodeDSelfTime));
 
       const nodeB = rootChildIterator.next().value as TraceTree.TopDownNode;
       const nodeBSelfTime = Trace.Types.Timing.MicroSeconds(eventB.dur - eventC.dur - eventD.dur);
-      assert.strictEqual(nodeB.selfTime, Trace.Helpers.Timing.microSecondsToMilliseconds(nodeBSelfTime));
+      assert.strictEqual(nodeB.selfTime, Trace.Helpers.Timing.microToMilli(nodeBSelfTime));
     });
 
     it('correctly keeps ProfileCall nodes and uses them to build up the tree', async function() {

front_end/models/trace/extras/TraceTree.ts

@@ -125,8 +125,8 @@ export class TopDownNode extends Node {
           onStartEvent,
           onEndEvent,
           onInstantEvent: instantEventCallback,
-          startTime: Helpers.Timing.millisecondsToMicroseconds(startTime),
-          endTime: Helpers.Timing.millisecondsToMicroseconds(endTime),
+          startTime: Helpers.Timing.milliToMicro(startTime),
+          endTime: Helpers.Timing.milliToMicro(endTime),
           eventFilter: root.filter,
           ignoreAsyncEvents: false,
         },
@@ -365,8 +365,8 @@ export class BottomUpRootNode extends Node {
         {
           onStartEvent,
           onEndEvent,
-          startTime: Helpers.Timing.millisecondsToMicroseconds(this.startTime),
-          endTime: Helpers.Timing.millisecondsToMicroseconds(this.endTime),
+          startTime: Helpers.Timing.milliToMicro(this.startTime),
+          endTime: Helpers.Timing.milliToMicro(this.endTime),
           eventFilter: this.filter,
           ignoreAsyncEvents: false,
         },
@@ -506,8 +506,8 @@ export class BottomUpNode extends Node {
         {
           onStartEvent,
           onEndEvent,
-          startTime: Helpers.Timing.millisecondsToMicroseconds(startTime),
-          endTime: Helpers.Timing.millisecondsToMicroseconds(endTime),
+          startTime: Helpers.Timing.milliToMicro(startTime),
+          endTime: Helpers.Timing.milliToMicro(endTime),
           eventFilter: this.root.filter,
           ignoreAsyncEvents: false,
         },

front_end/models/trace/handlers/LayoutShiftsHandler.ts

@@ -61,11 +61,11 @@ interface LayoutShifts {
 
 // This represents the maximum #time we will allow a cluster to go before we
 // reset it.
-export const MAX_CLUSTER_DURATION = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(5000));
+export const MAX_CLUSTER_DURATION = Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(5000));
 
 // This represents the maximum #time we will allow between layout shift events
 // before considering it to be the start of a new cluster.
-export const MAX_SHIFT_TIME_DELTA = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(1000));
+export const MAX_SHIFT_TIME_DELTA = Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(1000));
 
 // Layout shifts are reported globally to the developer, irrespective of which
 // frame they originated in. However, each process does have its own individual

front_end/models/trace/handlers/MetaHandler.ts

@@ -382,7 +382,7 @@ export async function finalize(): Promise<void> {
   // navigation happened very soon (0.5 seconds) after the trace started
   // recording.
   const firstMainFrameNav = mainFrameNavigations.at(0);
-  const firstNavTimeThreshold = Helpers.Timing.secondsToMicroseconds(Types.Timing.Seconds(0.5));
+  const firstNavTimeThreshold = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(0.5));
   if (firstMainFrameNav) {
     const navigationIsWithinThreshold = firstMainFrameNav.ts - traceBounds.min < firstNavTimeThreshold;
     if (firstMainFrameNav.args.data?.isOutermostMainFrame && firstMainFrameNav.args.data?.documentLoaderURL &&

front_end/models/trace/handlers/PageLoadMetricsHandler.ts

@@ -129,8 +129,7 @@ function storePageLoadMetricAgainstNavigationId(
     };
     storeMetricScore(frameId, navigationId, tti);
 
-    const tbtValue =
-        Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(event.args.args.total_blocking_time_ms));
+    const tbtValue = Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(event.args.args.total_blocking_time_ms));
     const tbt = {
       event,
       metricName: MetricName.TBT,
@@ -265,8 +264,8 @@ function getNavigationForPageLoadEvent(event: Types.Events.PageLoadEvent): Types
  */
 export function scoreClassificationForFirstContentfulPaint(fcpScoreInMicroseconds: Types.Timing.MicroSeconds):
     ScoreClassification {
-  const FCP_GOOD_TIMING = Helpers.Timing.secondsToMicroseconds(Types.Timing.Seconds(1.8));
-  const FCP_MEDIUM_TIMING = Helpers.Timing.secondsToMicroseconds(Types.Timing.Seconds(3.0));
+  const FCP_GOOD_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(1.8));
+  const FCP_MEDIUM_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(3.0));
   let scoreClassification = ScoreClassification.BAD;
   if (fcpScoreInMicroseconds <= FCP_MEDIUM_TIMING) {
     scoreClassification = ScoreClassification.OK;
@@ -284,8 +283,8 @@ export function scoreClassificationForFirstContentfulPaint(fcpScoreInMicrosecond
 
 export function scoreClassificationForTimeToInteractive(ttiTimeInMicroseconds: Types.Timing.MicroSeconds):
     ScoreClassification {
-  const TTI_GOOD_TIMING = Helpers.Timing.secondsToMicroseconds(Types.Timing.Seconds(3.8));
-  const TTI_MEDIUM_TIMING = Helpers.Timing.secondsToMicroseconds(Types.Timing.Seconds(7.3));
+  const TTI_GOOD_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(3.8));
+  const TTI_MEDIUM_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(7.3));
   let scoreClassification = ScoreClassification.BAD;
   if (ttiTimeInMicroseconds <= TTI_MEDIUM_TIMING) {
     scoreClassification = ScoreClassification.OK;
@@ -303,8 +302,8 @@ export function scoreClassificationForTimeToInteractive(ttiTimeInMicroseconds: T
 
 export function scoreClassificationForLargestContentfulPaint(lcpTimeInMicroseconds: Types.Timing.MicroSeconds):
     ScoreClassification {
-  const LCP_GOOD_TIMING = Helpers.Timing.secondsToMicroseconds(Types.Timing.Seconds(2.5));
-  const LCP_MEDIUM_TIMING = Helpers.Timing.secondsToMicroseconds(Types.Timing.Seconds(4));
+  const LCP_GOOD_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(2.5));
+  const LCP_MEDIUM_TIMING = Helpers.Timing.secondsToMicro(Types.Timing.Seconds(4));
   let scoreClassification = ScoreClassification.BAD;
   if (lcpTimeInMicroseconds <= LCP_MEDIUM_TIMING) {
     scoreClassification = ScoreClassification.OK;
@@ -330,8 +329,8 @@ export function scoreClassificationForDOMContentLoaded(_dclTimeInMicroseconds: T
 
 export function scoreClassificationForTotalBlockingTime(tbtTimeInMicroseconds: Types.Timing.MicroSeconds):
     ScoreClassification {
-  const TBT_GOOD_TIMING = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(200));
-  const TBT_MEDIUM_TIMING = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(600));
+  const TBT_GOOD_TIMING = Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(200));
+  const TBT_MEDIUM_TIMING = Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(600));
   let scoreClassification = ScoreClassification.BAD;
   if (tbtTimeInMicroseconds <= TBT_MEDIUM_TIMING) {
     scoreClassification = ScoreClassification.OK;

front_end/models/trace/handlers/SamplesHandler.ts

@@ -55,7 +55,7 @@ function buildProfileCalls(): void {
         if (threadId === undefined) {
           return;
         }
-        const ts = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(timeStampMilliseconds));
+        const ts = Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(timeStampMilliseconds));
         const nodeId = node.id as Helpers.TreeHelpers.TraceEntryNodeId;
 
         const profileCall = Helpers.Trace.makeProfileCall(node, profileId, sampleIndex, ts, processId, threadId);
@@ -83,8 +83,8 @@ function buildProfileCalls(): void {
             tid === undefined || traceEntryNode === undefined) {
           return;
         }
-        const dur = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(durMs));
-        const selfTime = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(selfTimeMs));
+        const dur = Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(durMs));
+        const selfTime = Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(selfTimeMs));
         profileCall.dur = dur;
         traceEntryNode.selfTime = selfTime;
 

front_end/models/trace/handlers/ServerTimingsHandler.ts

@@ -86,8 +86,7 @@ function createSyntheticServerTiming(
     if (timing.start === null) {
       continue;
     }
-    const convertedTimestamp =
-        Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(timing.start)) - offset;
+    const convertedTimestamp = Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(timing.start)) - offset;
     const parsedUrl = new URL(request.args.data.url);
     const origin = parsedUrl.origin;
 
@@ -98,7 +97,7 @@ function createSyntheticServerTiming(
       pid: Types.Events.ProcessID(0),
       tid: Types.Events.ThreadID(0),
       ts: Types.Timing.MicroSeconds(convertedTimestamp),
-      dur: Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(timing.value)),
+      dur: Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(timing.value)),
       cat: 'devtools.server-timing',
       args: {data: {desc: timing.description || undefined, origin}},
     });

front_end/models/trace/handlers/UserInteractionsHandler.ts

@@ -21,10 +21,10 @@ const allEvents: Types.Events.EventTimingBeginOrEnd[] = [];
 const beginCommitCompositorFrameEvents: Types.Events.BeginCommitCompositorFrame[] = [];
 const parseMetaViewportEvents: Types.Events.ParseMetaViewport[] = [];
 
-export const LONG_INTERACTION_THRESHOLD = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(200));
+export const LONG_INTERACTION_THRESHOLD = Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(200));
 
 const INP_GOOD_TIMING = LONG_INTERACTION_THRESHOLD;
-const INP_MEDIUM_TIMING = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(500));
+const INP_MEDIUM_TIMING = Helpers.Timing.milliToMicro(Types.Timing.MilliSeconds(500));
 
 export interface UserInteractionsData {
   /** All the user events we found in the trace */
@@ -291,13 +291,12 @@ export async function finalize(): Promise<void> {
     // that is relative to event.ts, and can be used when drawing boxes.
     // There is some inaccuracy here as we are converting milliseconds to microseconds, but it is good enough until the backend emits more accurate numbers.
     const processingStartRelativeToTraceTime = Types.Timing.MicroSeconds(
-        Helpers.Timing.millisecondsToMicroseconds(processingStart) -
-            Helpers.Timing.millisecondsToMicroseconds(timeStamp) + interactionStartEvent.ts,
+        Helpers.Timing.milliToMicro(processingStart) - Helpers.Timing.milliToMicro(timeStamp) +
+            interactionStartEvent.ts,
     );
 
     const processingEndRelativeToTraceTime = Types.Timing.MicroSeconds(
-        (Helpers.Timing.millisecondsToMicroseconds(processingEnd) -
-         Helpers.Timing.millisecondsToMicroseconds(timeStamp)) +
+        (Helpers.Timing.milliToMicro(processingEnd) - Helpers.Timing.milliToMicro(timeStamp)) +
         interactionStartEvent.ts);
 
     // Ultimate frameId fallback only needed for TSC, see comments in the type.