Revert "Reland "Support console timestamp measurements with performance.now() timestamps""

This reverts commit 5bc0a06.

Reason for revert: Compile errors on CI

Original change's description:
> Reland "Support console timestamp measurements with performance.now() timestamps"
>
> This is a reland of commit 1693f4f
>
> The culprit stems from a stale build state triggered by the update to a value our Event.Name const enum, which isn't always picked up by release builds. This causes timestamps events to not be added to the flamechart due to the lack of a style for it (since event styles are defined by event name). To work around this, the key of the updated enum entry is updated
> (See https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6372399/3..12)
> Original change's description:
> > Support console timestamp measurements with performance.now() timestamps
> >
> > Relevant Chromium CL: https://chromium-review.googlesource.com/c/chromium/src/+/6311629
> >
> > Bug: 399851200
> > Change-Id: I082d27bf0b791a439748f5c100bb791c1588145e
> > Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6308724
> > Reviewed-by: Nancy Li <[email protected]>
> > Commit-Queue: Nancy Li <[email protected]>
> > Auto-Submit: Andres Olivares <[email protected]>
>
> Bug: 399851200
> Change-Id: I9353bfb41250a7de6923613d371dbe29deda9f3f
> Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6372399
> Commit-Queue: Nancy Li <[email protected]>
> Reviewed-by: Nancy Li <[email protected]>
> Auto-Submit: Andres Olivares <[email protected]>

Bug: 399851200
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Change-Id: I581168e23b533da24639903902504caf7b7b6e02
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6373029
Commit-Queue: Rubber Stamper <[email protected]>
Auto-Submit: Philip Pfaffe <[email protected]>
Bot-Commit: Rubber Stamper <[email protected]>

Author: pfaffe

front_end/models/trace/handlers/ExtensionTraceDataHandler.test.ts

@@ -14,8 +14,8 @@ export interface PerformanceAPIExtensionTestData {
 
 export interface ConsoleAPIExtensionTestData {
   name: string;
-  start?: string|number;
-  end?: string|number;
+  start?: string;
+  end?: string;
   track?: string;
   trackGroup?: string;
   color?: string;
@@ -59,13 +59,13 @@ function makeTimingEventWithPerformanceExtensionData(
 function makeTimingEventWithConsoleExtensionData({name, ts, start, end, track, trackGroup, color}:
                                                      ConsoleAPIExtensionTestData): Trace.Types.Events.ConsoleTimeStamp {
   return {
-    cat: 'devtools.timeline',
+    cat: 'disabled-by-default-v8.inspector',
     pid: Trace.Types.Events.ProcessID(2017),
     tid: Trace.Types.Events.ThreadID(259),
-    name: Trace.Types.Events.Name.TIME_STAMP,
+    name: Trace.Types.Events.Name.CONSOLE_TIME_STAMP,
     args: {
       data: {
-        message: name,
+        name,
         start,
         end,
         track,
@@ -74,7 +74,7 @@ function makeTimingEventWithConsoleExtensionData({name, ts, start, end, track, t
       }
     },
     ts: Trace.Types.Timing.Micro(ts),
-    ph: Trace.Types.Events.Phase.INSTANT,
+    ph: Trace.Types.Events.Phase.COMPLETE,
 
   };
 }
@@ -441,7 +441,7 @@ describe('ExtensionTraceDataHandler', function() {
         assert.deepEqual(Object.keys(fourthTrackData.entriesByTrack), ['Ungrouped Track 2']);
         assert.deepEqual(Object.values(fourthTrackData.entriesByTrack).map(entries => entries.length), [2]);
       });
-      it('calculates self time sub track by sub track for events added with the performance API', async function() {
+      it('calculates self time sub track by sub track', async function() {
         const extensionDevToolsObjects: PerformanceAPIExtensionTestData[] = [
           // Track group 1
           {
@@ -622,20 +622,6 @@ describe('ExtensionTraceDataHandler', function() {
           end: 'Mark 4',
           ts: 300,
         },
-        // numeric start and end
-        {
-          track: 'Custom track 1',
-          name: 'Measure 6',
-          start: 300,
-          end: 400,
-          ts: 300,
-        },
-        {
-          track: 'Custom track 1',
-          name: 'Measure 7',
-          start: 350,
-          ts: 400,
-        }
       ];
       return createTraceExtensionDataFromConsoleAPITestInput(extensionData);
     }
@@ -646,26 +632,23 @@ describe('ExtensionTraceDataHandler', function() {
       });
       it('parses track data correctly', async () => {
         assert.lengthOf(extensionHandlerOutput.extensionTrackData, 3);
-        const expectedData: Record<string, Array<{name: string, ts: number, dur: number}>> = {
-          'Custom track 3': [{name: 'Measure 3', ts: 100, dur: 200}, {name: 'Measure 4', ts: 100, dur: 100}],
-          'Custom track 1': [
-            {name: 'Measure 1', ts: 100, dur: 100}, {name: 'Measure 6', ts: 300, dur: 100},
-            {name: 'Measure 7', ts: 350, dur: 50}
-          ],
-          'Custom track 2': [{name: 'Measure 2', ts: 100, dur: 100}]
-        };
-        for (let i = 0; i < extensionHandlerOutput.extensionTrackData.length; i++) {
-          const track = extensionHandlerOutput.extensionTrackData[i];
-          assert.strictEqual(track.name, Object.keys(expectedData)[i]);
-          const actualTrackData = track.entriesByTrack[track.name];
-          const expectedTrackData = expectedData[track.name];
-          for (let j = 0; j < actualTrackData.length; j++) {
-            const {name, ts, dur} = actualTrackData[j];
-            assert.strictEqual(name, expectedTrackData[j].name);
-            assert.strictEqual(ts, expectedTrackData[j].ts);
-            assert.strictEqual(dur, expectedTrackData[j].dur);
-          }
-        }
+
+        assert.strictEqual(extensionHandlerOutput.extensionTrackData[0].name, 'Custom track 3');
+        assert.lengthOf(extensionHandlerOutput.extensionTrackData[0].entriesByTrack['Custom track 3'], 2);
+        assert.strictEqual(
+            extensionHandlerOutput.extensionTrackData[0].entriesByTrack['Custom track 3'][0].name, 'Measure 3');
+        assert.strictEqual(
+            extensionHandlerOutput.extensionTrackData[0].entriesByTrack['Custom track 3'][1].name, 'Measure 4');
+
+        assert.strictEqual(extensionHandlerOutput.extensionTrackData[1].name, 'Custom track 1');
+        assert.lengthOf(extensionHandlerOutput.extensionTrackData[1].entriesByTrack['Custom track 1'], 1);
+        assert.strictEqual(
+            extensionHandlerOutput.extensionTrackData[1].entriesByTrack['Custom track 1'][0].name, 'Measure 1');
+
+        assert.strictEqual(extensionHandlerOutput.extensionTrackData[2].name, 'Custom track 2');
+        assert.lengthOf(extensionHandlerOutput.extensionTrackData[2].entriesByTrack['Custom track 2'], 1);
+        assert.strictEqual(
+            extensionHandlerOutput.extensionTrackData[2].entriesByTrack['Custom track 2'][0].name, 'Measure 2');
       });
       it('parses synthetic console timings for the timings track', async () => {
         assert.lengthOf(extensionHandlerOutput.syntheticConsoleEntriesForTimingsTrack, 1);
@@ -752,7 +735,7 @@ describe('ExtensionTraceDataHandler', function() {
         assert.deepEqual(Object.keys(fourthTrackData.entriesByTrack), ['Ungrouped Track 2']);
         assert.deepEqual(Object.values(fourthTrackData.entriesByTrack).map(entries => entries.length), [2]);
       });
-      it('calculates self time sub track by sub track for events added with the console API', async function() {
+      it('calculates self time sub track by sub track', async function() {
         const extensionDevToolsObjects: ConsoleAPIExtensionTestData[] = [
           // Track group 1
           {
@@ -809,13 +792,6 @@ describe('ExtensionTraceDataHandler', function() {
             start: 'F',
             ts: 80,
           },
-          {
-            trackGroup: 'Group 1',
-            track: 'Track 1',
-            name: 'Measurement 5',
-            start: 75,
-            ts: 80,
-          },
           {
             name: 'G',
             ts: 0,
@@ -872,8 +848,7 @@ describe('ExtensionTraceDataHandler', function() {
           {name: 'Measurement 1', selfTime: 40},
           {name: 'Measurement 2', selfTime: 20},
           {name: 'Measurement 3', selfTime: 30},
-          {name: 'Measurement 4', selfTime: 5},
-          {name: 'Measurement 5', selfTime: 5},
+          {name: 'Measurement 4', selfTime: 10},
         ]);
 
         const testDataTrack2 = trackGroupData.entriesByTrack['Track 2'].map(entry => {

front_end/models/trace/handlers/ExtensionTraceDataHandler.ts

@@ -85,27 +85,22 @@ export function extractConsoleAPIExtensionEntries(): void {
     if (!currentTimeStamp.args.data) {
       continue;
     }
-    const timeStampName = String(currentTimeStamp.args.data.name ?? currentTimeStamp.args.data.message);
+    const timeStampName = String(currentTimeStamp.args.data.name);
     timeStampByName.set(timeStampName, currentTimeStamp);
     const extensionData = extensionDataInConsoleTimeStamp(currentTimeStamp);
-    const start = currentTimeStamp.args.data.start;
-    const end = currentTimeStamp.args.data.end;
-    if (!extensionData && !start && !end) {
+    const startName = currentTimeStamp.args.data.start;
+    const endName = currentTimeStamp.args.data.end;
+    if (!extensionData && !startName && !endName) {
       continue;
     }
-    // If the start or end is a number, it's assumed to be a timestamp
-    // from the tracing clock, so we use that directly, otherwise we
-    // assume it's the label of a previous console timestamp, in which
-    // case we use its corresponding timestamp.
-    const startTimeStamp =
-        typeof start === 'number' ? Types.Timing.Micro(start) : timeStampByName.get(String(start))?.ts;
-    const endTimeStamp = typeof end === 'number' ? Types.Timing.Micro(end) : timeStampByName.get(String(end))?.ts;
-    if (endTimeStamp !== undefined && startTimeStamp === undefined) {
+    const startTimeStamp = startName ? timeStampByName.get(String(startName)) : undefined;
+    const endTimeStamp = endName ? timeStampByName.get(String(endName)) : undefined;
+    if (endTimeStamp && !startTimeStamp) {
       // Invalid data
       continue;
     }
-    const entryStartTime = startTimeStamp ?? currentTimeStamp.ts;
-    const entryEndTime = endTimeStamp ?? currentTimeStamp.ts;
+    const entryStartTime = startTimeStamp?.ts ?? currentTimeStamp.ts;
+    const entryEndTime = endTimeStamp?.ts ?? currentTimeStamp.ts;
     if (extensionData) {
       const unregisteredExtensionEntry: Omit<Types.Extensions.SyntheticExtensionTrackEntry, '_tag'> = {
         ...currentTimeStamp,
@@ -115,7 +110,6 @@ export function extractConsoleAPIExtensionEntries(): void {
         rawSourceEvent: currentTimeStamp,
         dur: Types.Timing.Micro(entryEndTime - entryStartTime),
         ts: entryStartTime,
-        ph: Types.Events.Phase.COMPLETE,
       };
       const extensionEntry =
           Helpers.SyntheticEvents.SyntheticEventsManager.getActiveManager()

front_end/models/trace/handlers/UserTimingsHandler.test.ts

@@ -177,9 +177,9 @@ describeWithEnvironment('UserTimingsHandler', function() {
     describe('console.timestamp events parsing', function() {
       it('parses console.timestamp events correctly', async function() {
         assert.lengthOf(timingsData.timestampEvents, 3);
-        assert.strictEqual(timingsData.timestampEvents[0].args.data?.message, 'a timestamp');
-        assert.strictEqual(timingsData.timestampEvents[1].args.data?.message, 'another timestamp');
-        assert.strictEqual(timingsData.timestampEvents[2].args.data?.message, 'yet another timestamp');
+        assert.strictEqual(timingsData.timestampEvents[0].args.data?.name, 'a timestamp');
+        assert.strictEqual(timingsData.timestampEvents[1].args.data?.name, 'another timestamp');
+        assert.strictEqual(timingsData.timestampEvents[2].args.data?.name, 'yet another timestamp');
       });
     });
   });

front_end/models/trace/helpers/SamplesIntegrator.test.ts

@@ -5,7 +5,7 @@
 import type * as Protocol from '../../../generated/protocol.js';
 import * as CPUProfile from '../../../models/cpu_profile/cpu_profile.js';
 import {describeWithEnvironment} from '../../../testing/EnvironmentHelpers.js';
-import {makeCompleteEvent, makeInstantEvent} from '../../../testing/TraceHelpers.js';
+import {makeCompleteEvent} from '../../../testing/TraceHelpers.js';
 import {TraceLoader} from '../../../testing/TraceLoader.js';
 import * as Trace from '../trace.js';
 
@@ -272,8 +272,8 @@ describeWithEnvironment('SamplesIntegrator', function() {
       const evaluateScript = makeCompleteEvent(Trace.Types.Events.Name.EVALUATE_SCRIPT, 0, 500);
       const v8Run = makeCompleteEvent('v8.run', 10, 490);
       const consoleTimeStamp =
-          makeInstantEvent(Trace.Types.Events.Name.TIME_STAMP, 350) as Trace.Types.Events.ConsoleTimeStamp;
-      consoleTimeStamp.args = {data: {message: 'A timestamp', sampleTraceId: traceId}};
+          makeCompleteEvent(Trace.Types.Events.Name.CONSOLE_TIME_STAMP, 350, 10) as Trace.Types.Events.ConsoleTimeStamp;
+      consoleTimeStamp.args = {data: {name: 'A timestamp', sampleTraceId: traceId}};
       const traceEvents = [evaluateScript, v8Run, consoleTimeStamp];
       const constructedCalls = integrator.buildProfileCalls(traceEvents);
       assert.lengthOf(constructedCalls, 4);

front_end/models/trace/helpers/SamplesIntegrator.ts

@@ -126,7 +126,7 @@ export class SamplesIntegrator {
       // Because instant trace events have no duration, they don't provide
       // useful information for possible changes in the duration of calls
       // in the JS stack.
-      if (event.ph === Types.Events.Phase.INSTANT && !extractSampleTraceId(event)) {
+      if (event.ph === Types.Events.Phase.INSTANT) {
         continue;
       }
       if (stack.length === 0) {

front_end/models/trace/types/TraceEvents.ts

@@ -1424,15 +1424,14 @@ export interface ConsoleTimeEnd extends PairableAsyncEnd {
 export type ConsoleTime = ConsoleTimeBegin|ConsoleTimeEnd;
 
 export interface ConsoleTimeStamp extends Event {
-  cat: 'devtools.timeline';
-  name: Name.TIME_STAMP;
-  ph: Phase.INSTANT;
+  cat: 'disabled-by-default-v8.inspector';
+  name: Name.CONSOLE_TIME_STAMP;
+  ph: Phase.COMPLETE;
   args: Args&{
     data?: ArgsData & {
       // The console.timeStamp allows to pass integers as values as well
       // as strings
-      message: string,
-      name?: string|number,
+      name: string | number,
       start?: string|number,
       end?: string|number,
       track?: string|number,
@@ -2324,7 +2323,7 @@ export function isConsoleTime(event: Event): event is ConsoleTime {
 }
 
 export function isConsoleTimeStamp(event: Event): event is ConsoleTimeStamp {
-  return event.ph === Phase.INSTANT && event.name === Name.TIME_STAMP;
+  return event.ph === Phase.COMPLETE && event.name === Name.CONSOLE_TIME_STAMP;
 }
 
 export function isUserTimingMeasure(event: Event): event is UserTimingMeasure {
@@ -2989,7 +2988,7 @@ export const enum Name {
   CONSOLE_TIME = 'ConsoleTime',
   USER_TIMING = 'UserTiming',
   INTERACTIVE_TIME = 'InteractiveTime',
-  TIME_STAMP = 'TimeStamp',
+  CONSOLE_TIME_STAMP = 'V8Console::TimeStamp',
 
   /* Frames */
   BEGIN_FRAME = 'BeginFrame',

front_end/panels/timeline/CompatibilityTracksAppender.ts

@@ -76,7 +76,8 @@ export function entryIsVisibleInTimeline(
   // events are hidden by default.
   const eventStyle = TimelineUtils.EntryStyles.getEventStyle(entry.name as Trace.Types.Events.Name);
   const eventIsTiming = Trace.Types.Events.isConsoleTime(entry) || Trace.Types.Events.isPerformanceMeasure(entry) ||
-      Trace.Types.Events.isPerformanceMark(entry) || Trace.Types.Events.isConsoleTimeStamp(entry);
+      Trace.Types.Events.isPerformanceMark(entry);
+
   return (eventStyle && !eventStyle.hidden) || eventIsTiming;
 }
 

front_end/panels/timeline/TimelineUIUtils.ts

@@ -661,7 +661,7 @@ export class TimelineUIUtils {
       return title;
     }
     if (Trace.Types.Events.isConsoleTimeStamp(event) && event.args.data) {
-      return i18nString(UIStrings.sS, {PH1: title, PH2: event.args.data.name ?? event.args.data.message});
+      return i18nString(UIStrings.sS, {PH1: title, PH2: event.args.data.name});
     }
     if (Trace.Types.Events.isAnimation(event) && event.args.data.name) {
       return i18nString(UIStrings.sS, {PH1: title, PH2: event.args.data.name});
@@ -756,7 +756,7 @@ export class TimelineUIUtils {
         }
         break;
       }
-      case Trace.Types.Events.Name.TIME_STAMP:
+      case Trace.Types.Events.Name.CONSOLE_TIME_STAMP:
         detailsText = unsafeEventData['message'];
         break;
 
@@ -2392,7 +2392,7 @@ export class TimelineUIUtils {
         color = 'var(--sys-color-green)';
         tall = true;
         break;
-      case Trace.Types.Events.Name.TIME_STAMP:
+      case Trace.Types.Events.Name.CONSOLE_TIME_STAMP:
         color = 'orange';
         break;
     }
@@ -2631,7 +2631,7 @@ export function timeStampForEventAdjustedForClosestNavigationIfPossible(
 export function isMarkerEvent(parsedTrace: Trace.Handlers.Types.ParsedTrace, event: Trace.Types.Events.Event): boolean {
   const {Name} = Trace.Types.Events;
 
-  if (event.name === Name.TIME_STAMP || event.name === Name.NAVIGATION_START) {
+  if (event.name === Name.CONSOLE_TIME_STAMP || event.name === Name.NAVIGATION_START) {
     return true;
   }
 

front_end/panels/timeline/TimingsTrackAppender.ts

@@ -77,6 +77,7 @@ export class TimingsTrackAppender implements TrackAppender {
         m => !Trace.Handlers.ModelHandlers.ExtensionTraceData.extensionDataInPerformanceTiming(m));
     const timestampEvents = this.#parsedTrace.UserTimings.timestampEvents;
     const consoleTimings = this.#parsedTrace.UserTimings.consoleTimings;
+
     if (extensionMarkersAreEmpty && performanceMarks.length === 0 && performanceMeasures.length === 0 &&
         timestampEvents.length === 0 && consoleTimings.length === 0) {
       return trackStartLevel;
@@ -243,7 +244,7 @@ export class TimingsTrackAppender implements TrackAppender {
       }
     }
     if (Trace.Types.Events.isConsoleTimeStamp(event)) {
-      return `TimeStamp: ${event.args.data?.message ?? '(name unknown)'}`;
+      return `TimeStamp: ${event.args.data?.name ?? '(name unknown)'}`;
     }
     if (Trace.Types.Events.isPerformanceMark(event)) {
       return `[mark]: ${event.name}`;