chrome-devtools-frontend 1.0.1473514 → 1.0.1510180

package/front_end/models/trace/handlers/WarningsHandler.ts

@@ -20,39 +20,39 @@ export interface WarningsData {
 
 export type Warning = 'LONG_TASK'|'IDLE_CALLBACK_OVER_TIME'|'FORCED_REFLOW'|'LONG_INTERACTION';
 
-const warningsPerEvent: WarningsData['perEvent'] = new Map();
-const eventsPerWarning: WarningsData['perWarning'] = new Map();
+let warningsPerEvent: WarningsData['perEvent'] = new Map();
+let eventsPerWarning: WarningsData['perWarning'] = new Map();
 
 /**
  * Tracks the stack formed by nested trace events up to a given point
  */
-const allEventsStack: Types.Events.Event[] = [];
+let allEventsStack: Types.Events.Event[] = [];
 /**
  * Tracks the stack formed by JS invocation trace events up to a given point.
  * F.e. FunctionCall, EvaluateScript, V8Execute.
  * Not to be confused with ProfileCalls.
  */
-const jsInvokeStack: Types.Events.Event[] = [];
+let jsInvokeStack: Types.Events.Event[] = [];
 /**
  * Tracks reflow events in a task.
  */
-const taskReflowEvents: Types.Events.Event[] = [];
+let taskReflowEvents: Types.Events.Event[] = [];
 /**
  * Tracks events containing long running tasks. These are compared later against the worker thread pool to filter out long tasks from worker threads.
  */
-const longTaskEvents: Types.Events.Event[] = [];
+let longTaskEvents: Types.Events.Event[] = [];
 
 export const FORCED_REFLOW_THRESHOLD = Helpers.Timing.milliToMicro(Types.Timing.Milli(30));
 
 export const LONG_MAIN_THREAD_TASK_THRESHOLD = Helpers.Timing.milliToMicro(Types.Timing.Milli(50));
 
 export function reset(): void {
-  warningsPerEvent.clear();
-  eventsPerWarning.clear();
-  allEventsStack.length = 0;
-  jsInvokeStack.length = 0;
-  taskReflowEvents.length = 0;
-  longTaskEvents.length = 0;
+  warningsPerEvent = new Map();
+  eventsPerWarning = new Map();
+  allEventsStack = [];
+  jsInvokeStack = [];
+  taskReflowEvents = [];
+  longTaskEvents = [];
 }
 
 function storeWarning(event: Types.Events.Event, warning: Warning): void {

package/front_end/models/trace/handlers/WorkersHandler.ts

@@ -10,14 +10,14 @@ export interface WorkersData {
   workerURLById: Map<Types.Events.WorkerId, string>;
 }
 
-const sessionIdEvents: Types.Events.TracingSessionIdForWorker[] = [];
-const workerIdByThread = new Map<Types.Events.ThreadID, Types.Events.WorkerId>();
-const workerURLById = new Map<Types.Events.WorkerId, string>();
+let sessionIdEvents: Types.Events.TracingSessionIdForWorker[] = [];
+let workerIdByThread = new Map<Types.Events.ThreadID, Types.Events.WorkerId>();
+let workerURLById = new Map<Types.Events.WorkerId, string>();
 
 export function reset(): void {
-  sessionIdEvents.length = 0;
-  workerIdByThread.clear();
-  workerURLById.clear();
+  sessionIdEvents = [];
+  workerIdByThread = new Map();
+  workerURLById = new Map();
 }
 
 export function handleEvent(event: Types.Events.Event): void {

package/front_end/models/trace/handlers/helpers.ts

@@ -16,23 +16,28 @@ export type Entity = typeof ThirdPartyWeb.ThirdPartyWeb.entities[number]&{
 export interface EntityMappings {
   createdEntityCache: Map<string, Entity>;
   entityByEvent: Map<Types.Events.Event, Entity>;
-  /**
-   * This holds the entities that had to be created, because they were not found using the
-   * ThirdPartyWeb database.
-   */
   eventsByEntity: Map<Entity, Types.Events.Event[]>;
+  entityByUrlCache: Map<string, Entity>;
 }
 
-export function getEntityForEvent(event: Types.Events.Event, entityCache: Map<string, Entity>): Entity|undefined {
+export function getEntityForEvent(event: Types.Events.Event, entityMappings: EntityMappings): Entity|undefined {
   const url = getNonResolvedURL(event);
   if (!url) {
     return;
   }
-  return getEntityForUrl(url, entityCache);
+  return getEntityForUrl(url, entityMappings);
 }
 
-export function getEntityForUrl(url: string, entityCache: Map<string, Entity>): Entity|undefined {
-  return ThirdPartyWeb.ThirdPartyWeb.getEntity(url) ?? makeUpEntity(entityCache, url);
+export function getEntityForUrl(url: string, entityMappings: EntityMappings): Entity|undefined {
+  const cachedByUrl = entityMappings.entityByUrlCache.get(url);
+  if (cachedByUrl) {
+    return cachedByUrl;
+  }
+  const entity = ThirdPartyWeb.ThirdPartyWeb.getEntity(url) ?? makeUpEntity(entityMappings.createdEntityCache, url);
+  if (entity) {
+    entityMappings.entityByUrlCache.set(url, entity);
+  }
+  return entity;
 }
 
 export function getNonResolvedURL(
@@ -159,17 +164,17 @@ function makeUpChromeExtensionEntity(entityCache: Map<string, Entity>, url: stri
 }
 
 export function addEventToEntityMapping(event: Types.Events.Event, entityMappings: EntityMappings): void {
-  const entity = getEntityForEvent(event, entityMappings.createdEntityCache);
-  if (!entity) {
-    return;
-  }
-
   // As we share the entityMappings between Network and Renderer... We can have ResourceSendRequest events passed in here
   // that were already mapped in Network. So, to avoid mapping twice, we always check that we didn't yet.
   if (entityMappings.entityByEvent.has(event)) {
     return;
   }
 
+  const entity = getEntityForEvent(event, entityMappings);
+  if (!entity) {
+    return;
+  }
+
   const mappedEvents = entityMappings.eventsByEntity.get(entity);
   if (mappedEvents) {
     mappedEvents.push(event);
@@ -183,7 +188,7 @@ export function addEventToEntityMapping(event: Types.Events.Event, entityMapping
 export function addNetworkRequestToEntityMapping(
     networkRequest: Types.Events.SyntheticNetworkRequest, entityMappings: EntityMappings,
     requestTraceEvents: TraceEventsForNetworkRequest): void {
-  const entity = getEntityForEvent(networkRequest, entityMappings.createdEntityCache);
+  const entity = getEntityForEvent(networkRequest, entityMappings);
   if (!entity) {
     return;
   }

package/front_end/models/trace/handlers/types.ts

@@ -5,10 +5,14 @@
 import type * as Types from './../types/types.js';
 import type * as ModelHandlers from './ModelHandlers.js';
 
+export type FinalizeOptions = Types.Configuration.ParseOptions&{
+  allTraceEvents: readonly Types.Events.Event[],
+};
+
 export interface Handler {
   reset(): void;
   handleEvent(data: object): void;
-  finalize(options?: Types.Configuration.ParseOptions): Promise<void>;
+  finalize(options?: FinalizeOptions): Promise<void>;
   data(): unknown;
   deps?(): HandlerName[];
   handleUserConfig?(config: Types.Configuration.Configuration): void;

package/front_end/models/trace/helpers/Extensions.ts

@@ -23,18 +23,18 @@ export function buildTrackDataFromExtensionEntries(
     // we use the standalone track data, but use a fixed prefix in the
     // batch key to prevent collisions where a track group has the
     // same name as a standalone track.
-    const key = entry.args.trackGroup || `track-name-${entry.args.track}`;
-    const batchedData =
-        Platform.MapUtilities.getWithDefault(dataByTrack, key, () => ({
-                                                                 name: entry.args.trackGroup || entry.args.track,
-                                                                 isTrackGroup: Boolean(entry.args.trackGroup),
-                                                                 entriesByTrack: {[entry.args.track]: []},
-                                                               }));
+    const key = entry.devtoolsObj.trackGroup || `track-name-${entry.devtoolsObj.track}`;
+    const batchedData = Platform.MapUtilities.getWithDefault(
+        dataByTrack, key, () => ({
+                            name: entry.devtoolsObj.trackGroup || entry.devtoolsObj.track,
+                            isTrackGroup: Boolean(entry.devtoolsObj.trackGroup),
+                            entriesByTrack: {[entry.devtoolsObj.track]: []},
+                          }));
 
-    if (!batchedData.entriesByTrack[entry.args.track]) {
-      batchedData.entriesByTrack[entry.args.track] = [];
+    if (!batchedData.entriesByTrack[entry.devtoolsObj.track]) {
+      batchedData.entriesByTrack[entry.devtoolsObj.track] = [];
     }
-    const entriesInTrack = batchedData.entriesByTrack[entry.args.track];
+    const entriesInTrack = batchedData.entriesByTrack[entry.devtoolsObj.track];
     entriesInTrack.push(entry);
   }
   // Calculate self time if possible for track entries, on a track

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

@@ -498,50 +498,41 @@ export class SamplesIntegrator {
 
   static createFakeTraceFromCpuProfile(profile: Protocol.Profiler.Profile, tid: Types.Events.ThreadID):
       Types.File.TraceFile {
-    const events: Types.Events.Event[] = [];
-
-    const threadName = `Thread ${tid}`;
-    appendEvent('TracingStartedInPage', {data: {sessionId: '1'}}, 0, 0, Types.Events.Phase.METADATA);
-    appendEvent(Types.Events.Name.THREAD_NAME, {name: threadName}, 0, 0, Types.Events.Phase.METADATA, '__metadata');
     if (!profile) {
-      return {traceEvents: events, metadata: {}};
+      return {traceEvents: [], metadata: {}};
     }
-
-    // Append a root to show the start time of the profile (which is earlier than first sample), so the Performance
+    // The |Name.CPU_PROFILE| will let MetaHandler to set |traceIsGeneric| to false
+    // The start time and duration is important here because we'll use them to determine the traceBounds
+    // We use the start and end time of the profile (which is longer than all samples), so the Performance
     // panel won't truncate this time period.
-    // 'JSRoot' doesn't exist in the new engine and is not the name of an actual trace event, but changing it might break other trace processing tools that rely on this, so we stick with this name.
-    // TODO(crbug.com/341234884): consider removing this or clarify why it's required.
-    appendEvent(
-        'JSRoot', {}, profile.startTime, profile.endTime - profile.startTime, Types.Events.Phase.COMPLETE, 'toplevel');
+    const cpuProfileEvent: Types.Events.SyntheticCpuProfile = {
+      cat: 'disabled-by-default-devtools.timeline',
+      name: Types.Events.Name.CPU_PROFILE,
+      ph: Types.Events.Phase.COMPLETE,
+      pid: Types.Events.ProcessID(1),
+      tid,
+      ts: Types.Timing.Micro(profile.startTime),
+      dur: Types.Timing.Micro(profile.endTime - profile.startTime),
+      args: {data: {cpuProfile: profile}},
+      // Create an arbitrary profile id.
+      id: '0x1' as Types.Events.ProfileID,
+    };
 
-    // TODO: create a `Profile` event instead, as `cpuProfile` is legacy
-    appendEvent('CpuProfile', {data: {cpuProfile: profile}}, profile.endTime, 0, Types.Events.Phase.COMPLETE);
     return {
-      traceEvents: events,
+      traceEvents: [cpuProfileEvent],
       metadata: {
         dataOrigin: Types.File.DataOrigin.CPU_PROFILE,
       }
     };
+  }
 
-    function appendEvent(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        name: string, args: any, ts: number, dur?: number, ph?: Types.Events.Phase, cat?: string): Types.Events.Event {
-      const event: Types.Events.Event = {
-        cat: cat || 'disabled-by-default-devtools.timeline',
-        name,
-        ph: ph || Types.Events.Phase.COMPLETE,
-        pid: Types.Events.ProcessID(1),
-        tid,
-        ts: Types.Timing.Micro(ts),
-        args,
-      };
-
-      if (dur) {
-        event.dur = Types.Timing.Micro(dur);
-      }
-      events.push(event);
-      return event;
+  static extractCpuProfileFromFakeTrace(traceEvents: readonly Types.Events.Event[]): Protocol.Profiler.Profile {
+    const profileEvent = traceEvents.find(e => Types.Events.isSyntheticCpuProfile(e));
+    const profile = profileEvent?.args.data.cpuProfile;
+    if (!profile) {
+      throw new Error('Missing cpuProfile data');
     }
+    return profile;
   }
 }
 

package/front_end/models/trace/helpers/SyntheticEvents.ts

@@ -40,7 +40,7 @@ export class SyntheticEventsManager {
 
   static registerSyntheticEvent<T extends Types.Events.SyntheticBased>(syntheticEvent: Omit<T, '_tag'>): T {
     try {
-      return SyntheticEventsManager.getActiveManager().registerSyntheticEvent(syntheticEvent);
+      return SyntheticEventsManager.getActiveManager().#registerSyntheticEvent(syntheticEvent);
     } catch {
       // If no active manager has been initialized, we assume the trace engine is
       // not running as part of the Performance panel. In this case we don't
@@ -59,7 +59,7 @@ export class SyntheticEventsManager {
    * be created with this method to ensure they are registered and made
    * available to load events using serialized keys.
    */
-  registerSyntheticEvent<T extends Types.Events.SyntheticBased>(syntheticEvent: Omit<T, '_tag'>): T {
+  #registerSyntheticEvent<T extends Types.Events.SyntheticBased>(syntheticEvent: Omit<T, '_tag'>): T {
     const rawIndex = this.#rawTraceEvents.indexOf(syntheticEvent.rawSourceEvent);
     if (rawIndex < 0) {
       throw new Error('Attempted to register a synthetic event paired to an unknown raw event.');

package/front_end/models/trace/helpers/Timing.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as Platform from '../../../core/platform/platform.js';
 import * as Types from '../types/types.js';
 
 import {getNavigationForTraceEvent} from './Trace.js';
@@ -118,7 +119,7 @@ export function traceWindowFromMicroSeconds(
   const traceWindow: Types.Timing.TraceWindowMicro = {
     min,
     max,
-    range: Types.Timing.Micro(max - min),
+    range: (max - min) as Types.Timing.Micro,
   };
   return traceWindow;
 }
@@ -126,11 +127,73 @@ export function traceWindowFromMicroSeconds(
 export function traceWindowFromEvent(event: Types.Events.Event): Types.Timing.TraceWindowMicro {
   return {
     min: event.ts,
-    max: Types.Timing.Micro(event.ts + (event.dur ?? 0)),
-    range: event.dur ?? Types.Timing.Micro(0),
+    max: event.ts + (event.dur ?? 0) as Types.Timing.Micro,
+    range: event.dur ?? 0 as Types.Timing.Micro,
   };
 }
 
+export function traceWindowFromOverlay(overlay: Types.Overlays.Overlay): Types.Timing.TraceWindowMicro|null {
+  switch (overlay.type) {
+    case 'ENTRY_LABEL':
+    case 'ENTRY_OUTLINE':
+    case 'ENTRY_SELECTED': {
+      return traceWindowFromEvent(overlay.entry);
+    }
+
+    case 'TIMESPAN_BREAKDOWN': {
+      const windows = overlay.sections.map(s => s.bounds);
+      if (overlay.entry) {
+        windows.push(traceWindowFromEvent(overlay.entry));
+      }
+      return combineTraceWindowsMicro(windows);
+    }
+
+    case 'CANDY_STRIPED_TIME_RANGE':
+    case 'TIME_RANGE': {
+      return structuredClone(overlay.bounds);
+    }
+
+    case 'ENTRIES_LINK': {
+      const from = traceWindowFromEvent(overlay.entryFrom);
+      if (!overlay.entryTo) {
+        return from;
+      }
+
+      const to = traceWindowFromEvent(overlay.entryTo);
+      return combineTraceWindowsMicro([from, to]);
+    }
+
+    case 'TIMESTAMP_MARKER':
+      return traceWindowFromMicroSeconds(overlay.timestamp, overlay.timestamp);
+    case 'TIMINGS_MARKER':
+      return traceWindowFromMicroSeconds(overlay.adjustedTimestamp, overlay.adjustedTimestamp);
+    case 'BOTTOM_INFO_BAR':
+      return null;
+
+    default:
+      Platform.TypeScriptUtilities.assertNever(overlay, `Unexpected overlay ${overlay}`);
+  }
+}
+
+/**
+ * Combines (as in a union) multiple windows into one.
+ */
+export function combineTraceWindowsMicro(windows: Types.Timing.TraceWindowMicro[]): Types.Timing.TraceWindowMicro|null {
+  if (!windows.length) {
+    return null;
+  }
+
+  const result: Types.Timing.TraceWindowMicro = structuredClone(windows[0]);
+  for (const bounds of windows.slice(1)) {
+    result.min = Math.min(result.min, bounds.min) as Types.Timing.Micro;
+    result.max = Math.max(result.max, bounds.max) as Types.Timing.Micro;
+  }
+
+  result.range = result.max - result.min as Types.Timing.Micro;
+
+  return result;
+}
+
 export interface BoundsIncludeTimeRange {
   timeRange: Types.Timing.TraceWindowMicro;
   bounds: Types.Timing.TraceWindowMicro;

package/front_end/models/trace/helpers/Trace.ts

@@ -106,29 +106,36 @@ export function addEventToProcessThread<T extends Types.Events.Event>(
   eventsInProcessThread.set(event.pid, eventsInThread);
 }
 
-export interface TimeSpan {
-  ts: Types.Timing.Micro;
-  dur?: Types.Timing.Micro;
-}
-export function eventTimeComparator(a: Types.Events.Event, b: Types.Events.Event): -1|0|1 {
-  const aBeginTime = a.ts;
-  const bBeginTime = b.ts;
+export function compareBeginAndEnd(aBeginTime: number, bBeginTime: number, aEndTime: number, bEndTime: number): -1|0|1 {
   if (aBeginTime < bBeginTime) {
     return -1;
   }
   if (aBeginTime > bBeginTime) {
     return 1;
   }
-  const aDuration = a.dur ?? 0;
-  const bDuration = b.dur ?? 0;
-  const aEndTime = aBeginTime + aDuration;
-  const bEndTime = bBeginTime + bDuration;
+
   if (aEndTime > bEndTime) {
     return -1;
   }
   if (aEndTime < bEndTime) {
     return 1;
   }
+
+  return 0;
+}
+
+export function eventTimeComparator(a: Types.Events.Event, b: Types.Events.Event): -1|0|1 {
+  const aBeginTime = a.ts;
+  const bBeginTime = b.ts;
+  const aDuration = a.dur ?? 0;
+  const bDuration = b.dur ?? 0;
+  const aEndTime = aBeginTime + aDuration;
+  const bEndTime = bBeginTime + bDuration;
+  const timeDifference = compareBeginAndEnd(aBeginTime, bBeginTime, aEndTime, bEndTime);
+  if (timeDifference) {
+    return timeDifference;
+  }
+
   // If times are equal, prioritize profile calls over trace events,
   // since an exactly equal timestamp with a trace event is likely
   // indicates that the SamplesIntegrator meant to parent the trace
@@ -180,6 +187,30 @@ export function mergeEventsInOrder<T1 extends Types.Events.Event, T2 extends Typ
   return result;
 }
 
+export function parseDevtoolsDetails(timingDetail: string, key: string): Types.Extensions.DevToolsObj|
+    Types.Extensions.ExtensionTrackEntryPayloadDeeplink|null {
+  try {
+    // Attempt to parse the detail as an object that might be coming from a
+    // DevTools Perf extension.
+    // Wrapped in a try-catch because timingDetail might either:
+    // 1. Not be `json.parse`-able (it should, but just in case...)
+    // 2. Not be an object - in which case the `in` check will error.
+    // If we hit either of these cases, we just ignore this mark and move on.
+    const detailObj = JSON.parse(timingDetail);
+    if (!(key in detailObj)) {
+      return null;
+    }
+    if (!Types.Extensions.isValidExtensionPayload(detailObj[key])) {
+      return null;
+    }
+    return detailObj[key];
+  } catch {
+    // No need to worry about this error, just discard this event and don't
+    // treat it as having any useful information for the purposes of extensions.
+    return null;
+  }
+}
+
 export function getNavigationForTraceEvent(
     event: Types.Events.Event,
     eventFrameId: string,
@@ -202,8 +233,8 @@ export function getNavigationForTraceEvent(
   return navigations[eventNavigationIndex];
 }
 
-export function extractId(event: Types.Events.PairableAsync|
-                          Types.Events.SyntheticEventPair<Types.Events.PairableAsync>): string|undefined {
+export function extractId(
+    event: Types.Events.PairableAsync|Types.Events.SyntheticEventPair<Types.Events.PairableAsync>): string|undefined {
   return event.id ?? event.id2?.global ?? event.id2?.local;
 }
 
@@ -263,7 +294,7 @@ export function makeProfileCall(
  * if provided, though currently only coming from Animations. Traces may contain multiple instant events so we need to
  * account for that.
  *
- * @returns {Map<string, MatchingPairableAsyncEvents>} Map of the animation's ID to it's matching events.
+ * @returns Map of the animation's ID to it's matching events.
  */
 export function matchEvents(unpairedEvents: Types.Events.PairableAsync[]): Map<string, MatchingPairableAsyncEvents> {
   // map to store begin and end of the event
@@ -524,16 +555,13 @@ export function frameIDForEvent(event: Types.Events.Event): string|null {
 
 const DevToolsTimelineEventCategory = 'disabled-by-default-devtools.timeline';
 export function isTopLevelEvent(event: Types.Events.Event): boolean {
-  if (event.name === 'JSRoot' && event.cat === 'toplevel') {
-    // This is used in createFakeTraceFromCpuProfile to insert a fake event prior to the
-    // CPU Profile in order to ensure the trace isn't truncated. So if we see
-    // this, we want to treat it as a top level event.
-    // TODO(crbug.com/341234884): do we need this?
-    return true;
-  }
   return event.cat.includes(DevToolsTimelineEventCategory) && event.name === Types.Events.Name.RUN_TASK;
 }
 
+export function isExtensionUrl(url: string): boolean {
+  return url.startsWith('extensions:') || url.startsWith('chrome-extension:');
+}
+
 function topLevelEventIndexEndingAfter(events: Types.Events.Event[], time: Types.Timing.Micro): number {
   let index = Platform.ArrayUtilities.upperBound(events, time, (time, event) => time - event.ts) - 1;
   while (index > 0 && !isTopLevelEvent(events[index])) {

package/front_end/models/trace/helpers/TreeHelpers.ts

@@ -56,7 +56,7 @@ export type TraceEntryNodeId = Platform.Brand.Brand<number, 'traceEntryNodeIdTag
  *
  * Complexity: O(n), where n = number of events
  */
-export function treify(entries: Types.Events.Event[], options?: {
+export function treify(entries: readonly Types.Events.Event[], options?: {
   filter: {has: (name: Types.Events.Name) => boolean},
 }): {tree: TraceEntryTree, entryToNode: Map<Types.Events.Event, TraceEntryNode>} {
   // As we construct the tree, store a map of each entry to its node. This