@paulirish/trace_engine 0.0.9 → 0.0.10

package/models/trace/helpers/SamplesIntegrator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/helpers/SamplesIntegrator.ts"],
+  "sourcesContent": ["// Copyright 2023 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport type * as Protocol from '../../../generated/protocol.js';\nimport type * as CPUProfile from '../../cpu_profile/cpu_profile.js';\nimport * as Types from '../types/types.js';\n\nimport {millisecondsToMicroseconds} from './Timing.js';\nimport {makeProfileCall, mergeEventsInOrder} from './Trace.js';\n\n/**\n * This is a helper that integrates CPU profiling data coming in the\n * shape of samples, with trace events. Samples indicate what the JS\n * stack trace looked at a given point in time, but they don't have\n * duration. The SamplesIntegrator task is to make an approximation\n * of what the duration of each JS call was, given the sample data and\n * given the trace events profiled during that time. At the end of its\n * execution, the SamplesIntegrator returns an array of ProfileCalls\n * (under SamplesIntegrator::buildProfileCalls()), which\n * represent JS calls, with a call frame and duration. These calls have\n * the shape of a complete trace events and can be treated as flame\n * chart entries in the timeline.\n *\n * The approach to build the profile calls consists in tracking the\n * current stack as the following events happen (in order):\n * 1. A sample was done.\n * 2. A trace event started.\n * 3. A trace event ended.\n * Depending on the event and on the data that's coming with it the\n * stack is updated by adding or removing JS calls to it and updating\n * the duration of the calls in the tracking stack.\n *\n * note: Although this approach has been implemented since long ago, and\n * is relatively efficent (adds a complexity over the trace parsing of\n * O(n) where n is the number of samples) it has proven to be faulty.\n * It might be worthwhile experimenting with improvements or with a\n * completely different approach. Improving the approach is tracked in\n * crbug.com/1417439\n */\nexport class SamplesIntegrator {\n  /**\n   * The result of runing the samples integrator. Holds the JS calls\n   * with their approximated duration after integrating samples into the\n   * trace event tree.\n   */\n  #constructedProfileCalls: Types.TraceEvents.SyntheticProfileCall[] = [];\n  /**\n   * tracks the state of the JS stack at each point in time to update\n   * the profile call durations as new events arrive. This doesn't only\n   * happen with new profile calls (in which case we would compare the\n   * stack in them) but also with trace events (in which case we would\n   * update the duration of the events we are tracking at the moment).\n   */\n  #currentJSStack: Types.TraceEvents.SyntheticProfileCall[] = [];\n  /**\n   * Process holding the CPU profile and trace events.\n   */\n  #processId: Types.TraceEvents.ProcessID;\n  /**\n   * Thread holding the CPU profile and trace events.\n   */\n  #threadId: Types.TraceEvents.ThreadID;\n  /**\n   * Tracks the depth of the JS stack at the moment a trace event starts\n   * or ends. It is assumed that for the duration of a trace event, the\n   * JS stack's depth cannot decrease, since JS calls that started\n   * before a trace event cannot end during the trace event. So as trace\n   * events arrive, we store the \"locked\" amount of JS frames that were\n   * in the stack before the event came.\n   */\n  #lockedJsStackDepth: number[] = [];\n  /**\n   * Used to keep track when samples should be integrated even if they\n   * are not children of invocation trace events. This is useful in\n   * cases where we can be missing the start of JS invocation events if\n   * we start tracing half-way through.\n   */\n  #fakeJSInvocation = false;\n  /**\n   * The parsed CPU profile, holding the tree hierarchy of JS frames and\n   * the sample data.\n   */\n  #profileModel: CPUProfile.CPUProfileDataModel.CPUProfileDataModel;\n  /**\n   * Because GC nodes don't have a stack, we artificially add a stack to\n   * them which corresponds to that of the previous sample. This map\n   * tracks which node is used for the stack of a GC call.\n   * Note that GC samples are not shown in the flamechart, however they\n   * are used during the construction of for profile calls, as we can\n   * infer information about the duration of the executed code when a\n   * GC node is sampled.\n   */\n  #nodeForGC = new Map<Types.TraceEvents.SyntheticProfileCall, CPUProfile.ProfileTreeModel.ProfileNode>();\n\n  #engineConfig: Types.Configuration.Configuration;\n\n  constructor(\n      profileModel: CPUProfile.CPUProfileDataModel.CPUProfileDataModel, pid: Types.TraceEvents.ProcessID,\n      tid: Types.TraceEvents.ThreadID, configuration?: Types.Configuration.Configuration) {\n    this.#profileModel = profileModel;\n    this.#threadId = tid;\n    this.#processId = pid;\n    this.#engineConfig = configuration || Types.Configuration.DEFAULT;\n  }\n\n  buildProfileCalls(traceEvents: Types.TraceEvents.TraceEventData[]): Types.TraceEvents.SyntheticProfileCall[] {\n    const mergedEvents = mergeEventsInOrder(traceEvents, this.callsFromProfileSamples());\n    const stack = [];\n    for (let i = 0; i < mergedEvents.length; i++) {\n      const event = mergedEvents[i];\n      // Because instant trace events have no duration, they don't provide\n      // useful information for possible changes in the duration of calls\n      // in the JS stack.\n      if (event.ph === Types.TraceEvents.Phase.INSTANT) {\n        continue;\n      }\n      if (stack.length === 0) {\n        if (Types.TraceEvents.isProfileCall(event)) {\n          this.#onProfileCall(event);\n          continue;\n        }\n        stack.push(event);\n        this.#onTraceEventStart(event);\n        continue;\n      }\n\n      const parentEvent = stack.at(-1);\n      if (parentEvent === undefined) {\n        continue;\n      }\n      const begin = event.ts;\n      const parentBegin = parentEvent.ts;\n      const parentDuration = parentEvent.dur || 0;\n      const parentEnd = parentBegin + parentDuration;\n\n      const startsAfterParent = begin >= parentEnd;\n      if (startsAfterParent) {\n        this.#onTraceEventEnd(parentEvent);\n        stack.pop();\n        i--;\n        continue;\n      }\n      if (Types.TraceEvents.isProfileCall(event)) {\n        this.#onProfileCall(event, parentEvent);\n        continue;\n      }\n      this.#onTraceEventStart(event);\n      stack.push(event);\n    }\n    while (stack.length) {\n      const last = stack.pop();\n      if (last) {\n        this.#onTraceEventEnd(last);\n      }\n    }\n    return this.#constructedProfileCalls;\n  }\n\n  #onTraceEventStart(event: Types.TraceEvents.TraceEventData): void {\n    // Top level events cannot be nested into JS frames so we reset\n    // the stack when we find one.\n    if (event.name === Types.TraceEvents.KnownEventName.RunMicrotasks ||\n        event.name === Types.TraceEvents.KnownEventName.RunTask) {\n      this.#lockedJsStackDepth = [];\n      this.#truncateJSStack(0, event.ts);\n      this.#fakeJSInvocation = false;\n    }\n\n    if (this.#fakeJSInvocation) {\n      this.#truncateJSStack(this.#lockedJsStackDepth.pop() || 0, event.ts);\n      this.#fakeJSInvocation = false;\n    }\n    this.#extractStackTrace(event);\n    // Keep track of the call frames in the stack before the event\n    // happened. For the duration of this event, these frames cannot\n    // change (none can be terminated before this event finishes).\n    //\n    // Also, every frame that is opened after this event, is considered\n    // to be a descendant of the event. So once the event finishes, the\n    // frames that were opened after it, need to be closed (see\n    // onEndEvent).\n    //\n    // TODO(crbug.com/1417439):\n    // The assumption that every frame opened after an event is a\n    // descendant of the event is incorrect. For example, a JS call that\n    // parents a trace event might have been sampled after the event was\n    // dispatched. In this case the JS call would be discarded if this\n    // event isn't an invocation event, otherwise the call will be\n    // considered a child of the event. In both cases, the result would\n    // be incorrect.\n    this.#lockedJsStackDepth.push(this.#currentJSStack.length);\n  }\n\n  #onProfileCall(event: Types.TraceEvents.SyntheticProfileCall, parent?: Types.TraceEvents.TraceEventData): void {\n    if ((parent && Types.TraceEvents.isJSInvocationEvent(parent)) || this.#fakeJSInvocation) {\n      this.#extractStackTrace(event);\n    } else if (Types.TraceEvents.isProfileCall(event) && this.#currentJSStack.length === 0) {\n      // Force JS Samples to show up even if we are not inside a JS\n      // invocation event, because we can be missing the start of JS\n      // invocation events if we start tracing half-way through. Pretend\n      // we have a top-level JS invocation event.\n      this.#fakeJSInvocation = true;\n      const stackDepthBefore = this.#currentJSStack.length;\n      this.#extractStackTrace(event);\n      this.#lockedJsStackDepth.push(stackDepthBefore);\n    }\n  }\n\n  #onTraceEventEnd(event: Types.TraceEvents.TraceEventData): void {\n    // Because the event has ended, any frames that happened after\n    // this event are terminated. Frames that are ancestors to this\n    // event are extended to cover its ending.\n    const endTime = Types.Timing.MicroSeconds(event.ts + (event.dur || 0));\n    this.#truncateJSStack(this.#lockedJsStackDepth.pop() || 0, endTime);\n  }\n\n  /**\n   * Builds the initial calls with no duration from samples. Their\n   * purpose is to be merged with the trace event array being parsed so\n   * that they can be traversed in order with them and their duration\n   * can be updated as the SampleIntegrator callbacks are invoked.\n   */\n  callsFromProfileSamples(): Types.TraceEvents.SyntheticProfileCall[] {\n    const samples = this.#profileModel.samples;\n    const timestamps = this.#profileModel.timestamps;\n    if (!samples) {\n      return [];\n    }\n    const calls: Types.TraceEvents.SyntheticProfileCall[] = [];\n    let prevNode;\n    for (let i = 0; i < samples.length; i++) {\n      const node = this.#profileModel.nodeByIndex(i);\n      const timestamp = millisecondsToMicroseconds(Types.Timing.MilliSeconds(timestamps[i]));\n      if (!node) {\n        continue;\n      }\n      const call = makeProfileCall(node, timestamp, this.#processId, this.#threadId);\n      calls.push(call);\n      if (node.id === this.#profileModel.gcNode?.id && prevNode) {\n        // GC samples have no stack, so we just put GC node on top of the\n        // last recorded sample. Cache the previous sample for future\n        // reference.\n        this.#nodeForGC.set(call, prevNode);\n        continue;\n      }\n      prevNode = node;\n    }\n    return calls;\n  }\n\n  #getStackTraceFromProfileCall(profileCall: Types.TraceEvents.SyntheticProfileCall):\n      Types.TraceEvents.SyntheticProfileCall[] {\n    let node = this.#profileModel.nodeById(profileCall.nodeId);\n    const isGarbageCollection = node?.id === this.#profileModel.gcNode?.id;\n    if (isGarbageCollection) {\n      // Because GC don't have a stack, we use the stack of the previous\n      // sample.\n      node = this.#nodeForGC.get(profileCall) || null;\n    }\n    if (!node) {\n      return [];\n    }\n    // `node.depth` is 0 based, so to set the size of the array we need\n    // to add 1 to its value.\n    const callFrames = new Array<Types.TraceEvents.SyntheticProfileCall>(node.depth + 1 + Number(isGarbageCollection));\n    // Add the stack trace in reverse order (bottom first).\n    let i = callFrames.length - 1;\n    if (isGarbageCollection) {\n      // Place the garbage collection call frame on top of the stack.\n      callFrames[i--] = profileCall;\n    }\n    while (node) {\n      callFrames[i--] = makeProfileCall(node, profileCall.ts, this.#processId, this.#threadId);\n      node = node.parent;\n    }\n    return callFrames;\n  }\n\n  /**\n   * Update tracked stack using this event's call stack.\n   */\n  #extractStackTrace(event: Types.TraceEvents.TraceEventData): void {\n    const stackTrace =\n        Types.TraceEvents.isProfileCall(event) ? this.#getStackTraceFromProfileCall(event) : this.#currentJSStack;\n    SamplesIntegrator.filterStackFrames(stackTrace, this.#engineConfig);\n\n    const endTime = event.ts + (event.dur || 0);\n    const minFrames = Math.min(stackTrace.length, this.#currentJSStack.length);\n    let i;\n    // Merge a sample's stack frames with the stack frames we have\n    // so far if we detect they are equivalent.\n    // Graphically\n    // This:\n    // Current stack trace       Sample\n    // [-------A------]          [A]\n    // [-------B------]          [B]\n    // [-------C------]          [C]\n    //                ^ t = x1    ^ t = x2\n\n    // Becomes this:\n    // New stack trace after merge\n    // [--------A-------]\n    // [--------B-------]\n    // [--------C-------]\n    //                  ^ t = x2\n    for (i = this.#lockedJsStackDepth.at(-1) || 0; i < minFrames; ++i) {\n      const newFrame = stackTrace[i].callFrame;\n      const oldFrame = this.#currentJSStack[i].callFrame;\n      if (!SamplesIntegrator.framesAreEqual(newFrame, oldFrame)) {\n        break;\n      }\n      // Scoot the right edge of this callFrame to the right\n      this.#currentJSStack[i].dur =\n          Types.Timing.MicroSeconds(Math.max(this.#currentJSStack[i].dur || 0, endTime - this.#currentJSStack[i].ts));\n    }\n\n    // If there are call frames in the sample that differ with the stack\n    // we have, update the stack, but keeping the common frames in place\n    // Graphically\n    // This:\n    // Current stack trace       Sample\n    // [-------A------]          [A]\n    // [-------B------]          [B]\n    // [-------C------]          [C]\n    // [-------D------]          [E]\n    //                ^ t = x1    ^ t = x2\n    // Becomes this:\n    // New stack trace after merge\n    // [--------A-------]\n    // [--------B-------]\n    // [--------C-------]\n    //                [E]\n    //                  ^ t = x2\n    this.#truncateJSStack(i, event.ts);\n\n    for (; i < stackTrace.length; ++i) {\n      const call = stackTrace[i];\n      if (call.nodeId === this.#profileModel.programNode?.id || call.nodeId === this.#profileModel.root?.id ||\n          call.nodeId === this.#profileModel.idleNode?.id || call.nodeId === this.#profileModel.gcNode?.id) {\n        // Skip (root), (program) and (idle) frames, since this are not\n        // relevant for web profiling and we don't want to show them in\n        // the timeline.\n        continue;\n      }\n      this.#currentJSStack.push(call);\n      this.#constructedProfileCalls.push(call);\n    }\n  }\n\n  /**\n   * When a call stack that differs from the one we are tracking has\n   * been detected in the samples, the latter is \"truncated\" by\n   * setting the ending time of its call frames and removing the top\n   * call frames that aren't shared with the new call stack. This way,\n   * we can update the tracked stack with the new call frames on top.\n   * @param depth the amount of call frames from bottom to top that\n   * should be kept in the tracking stack trace. AKA amount of shared\n   * call frames between two stacks.\n   * @param time the new end of the call frames in the stack.\n   */\n  #truncateJSStack(depth: number, time: Types.Timing.MicroSeconds): void {\n    if (this.#lockedJsStackDepth.length) {\n      const lockedDepth = this.#lockedJsStackDepth.at(-1);\n      if (lockedDepth && depth < lockedDepth) {\n        console.error(`Child stack is shallower (${depth}) than the parent stack (${lockedDepth}) at ${time}`);\n        depth = lockedDepth;\n      }\n    }\n    if (this.#currentJSStack.length < depth) {\n      console.error(`Trying to truncate higher than the current stack size at ${time}`);\n      depth = this.#currentJSStack.length;\n    }\n    for (let k = 0; k < this.#currentJSStack.length; ++k) {\n      this.#currentJSStack[k].dur = Types.Timing.MicroSeconds(Math.max(time - this.#currentJSStack[k].ts, 0));\n    }\n    this.#currentJSStack.length = depth;\n  }\n\n  static framesAreEqual(frame1: Protocol.Runtime.CallFrame, frame2: Protocol.Runtime.CallFrame): boolean {\n    return frame1.scriptId === frame2.scriptId && frame1.functionName === frame2.functionName &&\n        frame1.lineNumber === frame2.lineNumber;\n  }\n\n  static showNativeName(name: string, runtimeCallStatsEnabled: boolean): boolean {\n    return runtimeCallStatsEnabled && Boolean(SamplesIntegrator.nativeGroup(name));\n  }\n\n  static nativeGroup(nativeName: string): 'Parse'|'Compile'|null {\n    if (nativeName.startsWith('Parse')) {\n      return 'Parse';\n    }\n    if (nativeName.startsWith('Compile') || nativeName.startsWith('Recompile')) {\n      return 'Compile';\n    }\n    return null;\n  }\n\n  static isNativeRuntimeFrame(frame: Protocol.Runtime.CallFrame): boolean {\n    return frame.url === 'native V8Runtime';\n  }\n\n  static filterStackFrames(\n      stack: Types.TraceEvents.SyntheticProfileCall[], engineConfig: Types.Configuration.Configuration): void {\n    const showAllEvents = engineConfig.experiments.timelineShowAllEvents;\n    if (showAllEvents) {\n      return;\n    }\n    let previousNativeFrameName: string|null = null;\n    let j = 0;\n    for (let i = 0; i < stack.length; ++i) {\n      const frame = stack[i].callFrame;\n      const nativeRuntimeFrame = SamplesIntegrator.isNativeRuntimeFrame(frame);\n      if (nativeRuntimeFrame &&\n          !SamplesIntegrator.showNativeName(frame.functionName, engineConfig.experiments.timelineV8RuntimeCallStats)) {\n        continue;\n      }\n      const nativeFrameName = nativeRuntimeFrame ? SamplesIntegrator.nativeGroup(frame.functionName) : null;\n      if (previousNativeFrameName && previousNativeFrameName === nativeFrameName) {\n        continue;\n      }\n      previousNativeFrameName = nativeFrameName;\n      stack[j++] = stack[i];\n    }\n    stack.length = j;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/models/trace/helpers/Timing.js

@@ -0,0 +1,141 @@
+import * as Platform from "../../../core/platform/platform.js";
+import * as Types from "../types/types.js";
+import { getNavigationForTraceEvent } from "./Trace.js";
+export const millisecondsToMicroseconds = (value) => Types.Timing.MicroSeconds(value * 1e3);
+export const secondsToMilliseconds = (value) => Types.Timing.MilliSeconds(value * 1e3);
+export const secondsToMicroseconds = (value) => millisecondsToMicroseconds(secondsToMilliseconds(value));
+export const microSecondsToMilliseconds = (value) => Types.Timing.MilliSeconds(value / 1e3);
+export const microSecondsToSeconds = (value) => Types.Timing.Seconds(value / 1e3 / 1e3);
+export function detectBestTimeUnit(timeInMicroseconds) {
+  if (timeInMicroseconds < 1e3) {
+    return Types.Timing.TimeUnit.MICROSECONDS;
+  }
+  const timeInMilliseconds = timeInMicroseconds / 1e3;
+  if (timeInMilliseconds < 1e3) {
+    return Types.Timing.TimeUnit.MILLISECONDS;
+  }
+  const timeInSeconds = timeInMilliseconds / 1e3;
+  if (timeInSeconds < 60) {
+    return Types.Timing.TimeUnit.SECONDS;
+  }
+  return Types.Timing.TimeUnit.MINUTES;
+}
+const defaultFormatOptions = {
+  style: "unit",
+  unit: "millisecond",
+  unitDisplay: "narrow"
+};
+const serialize = (value) => JSON.stringify(value);
+const formatterFactory = (key) => {
+  return new Intl.NumberFormat(void 0, key ? JSON.parse(key) : {});
+};
+const formatters = /* @__PURE__ */ new Map();
+Platform.MapUtilities.getWithDefault(formatters, serialize({ style: "decimal" }), formatterFactory);
+Platform.MapUtilities.getWithDefault(formatters, serialize(defaultFormatOptions), formatterFactory);
+Platform.MapUtilities.getWithDefault(formatters, serialize({ ...defaultFormatOptions, unit: "second" }), formatterFactory);
+Platform.MapUtilities.getWithDefault(formatters, serialize({ ...defaultFormatOptions, unit: "minute" }), formatterFactory);
+export function formatMicrosecondsTime(timeInMicroseconds, opts = {}) {
+  if (!opts.format) {
+    opts.format = detectBestTimeUnit(timeInMicroseconds);
+  }
+  const timeInMilliseconds = timeInMicroseconds / 1e3;
+  const timeInSeconds = timeInMilliseconds / 1e3;
+  const formatterOpts = { ...defaultFormatOptions, ...opts };
+  switch (opts.format) {
+    case Types.Timing.TimeUnit.MICROSECONDS: {
+      const formatter = Platform.MapUtilities.getWithDefault(formatters, serialize({ style: "decimal" }), formatterFactory);
+      return `${formatter.format(timeInMicroseconds)}\u03BCs`;
+    }
+    case Types.Timing.TimeUnit.MILLISECONDS: {
+      const formatter = Platform.MapUtilities.getWithDefault(formatters, serialize(formatterOpts), formatterFactory);
+      return formatter.format(timeInMilliseconds);
+    }
+    case Types.Timing.TimeUnit.SECONDS: {
+      const formatter = Platform.MapUtilities.getWithDefault(formatters, serialize({ ...formatterOpts, unit: "second" }), formatterFactory);
+      return formatter.format(timeInSeconds);
+    }
+    default: {
+      const minuteFormatter = Platform.MapUtilities.getWithDefault(formatters, serialize({ ...formatterOpts, unit: "minute" }), formatterFactory);
+      const secondFormatter = Platform.MapUtilities.getWithDefault(formatters, serialize({ ...formatterOpts, unit: "second" }), formatterFactory);
+      const timeInMinutes = timeInSeconds / 60;
+      const [mins, divider, fraction] = minuteFormatter.formatToParts(timeInMinutes);
+      let seconds = 0;
+      if (divider && fraction) {
+        seconds = Math.round(Number(`0.${fraction.value}`) * 60);
+      }
+      return `${minuteFormatter.format(Number(mins.value))} ${secondFormatter.format(seconds)}`;
+    }
+  }
+}
+export function timeStampForEventAdjustedByClosestNavigation(event, traceBounds, navigationsByNavigationId, navigationsByFrameId) {
+  let eventTimeStamp = event.ts - traceBounds.min;
+  if (event.args?.data?.navigationId) {
+    const navigationForEvent = navigationsByNavigationId.get(event.args.data.navigationId);
+    if (navigationForEvent) {
+      eventTimeStamp = event.ts - navigationForEvent.ts;
+    }
+  } else if (event.args?.data?.frame) {
+    const navigationForEvent = getNavigationForTraceEvent(event, event.args.data.frame, navigationsByFrameId);
+    if (navigationForEvent) {
+      eventTimeStamp = event.ts - navigationForEvent.ts;
+    }
+  }
+  return Types.Timing.MicroSeconds(eventTimeStamp);
+}
+export function eventTimingsMicroSeconds(event) {
+  return {
+    startTime: event.ts,
+    endTime: Types.Timing.MicroSeconds(event.ts + (event.dur || Types.Timing.MicroSeconds(0))),
+    duration: Types.Timing.MicroSeconds(event.dur || 0),
+    selfTime: Types.TraceEvents.isSyntheticTraceEntry(event) ? Types.Timing.MicroSeconds(event.selfTime || 0) : Types.Timing.MicroSeconds(event.dur || 0)
+  };
+}
+export function eventTimingsMilliSeconds(event) {
+  const microTimes = eventTimingsMicroSeconds(event);
+  return {
+    startTime: microSecondsToMilliseconds(microTimes.startTime),
+    endTime: microSecondsToMilliseconds(microTimes.endTime),
+    duration: microSecondsToMilliseconds(microTimes.duration),
+    selfTime: microSecondsToMilliseconds(microTimes.selfTime)
+  };
+}
+export function eventTimingsSeconds(event) {
+  const microTimes = eventTimingsMicroSeconds(event);
+  return {
+    startTime: microSecondsToSeconds(microTimes.startTime),
+    endTime: microSecondsToSeconds(microTimes.endTime),
+    duration: microSecondsToSeconds(microTimes.duration),
+    selfTime: microSecondsToSeconds(microTimes.selfTime)
+  };
+}
+export function traceWindowMilliSeconds(bounds) {
+  return {
+    min: microSecondsToMilliseconds(bounds.min),
+    max: microSecondsToMilliseconds(bounds.max),
+    range: microSecondsToMilliseconds(bounds.range)
+  };
+}
+export function traceWindowMillisecondsToMicroSeconds(bounds) {
+  return {
+    min: millisecondsToMicroseconds(bounds.min),
+    max: millisecondsToMicroseconds(bounds.max),
+    range: millisecondsToMicroseconds(bounds.range)
+  };
+}
+export function traceWindowFromMilliSeconds(min, max) {
+  const traceWindow = {
+    min: millisecondsToMicroseconds(min),
+    max: millisecondsToMicroseconds(max),
+    range: Types.Timing.MicroSeconds(millisecondsToMicroseconds(max) - millisecondsToMicroseconds(min))
+  };
+  return traceWindow;
+}
+export function traceWindowFromMicroSeconds(min, max) {
+  const traceWindow = {
+    min,
+    max,
+    range: Types.Timing.MicroSeconds(max - min)
+  };
+  return traceWindow;
+}
+//# sourceMappingURL=Timing.js.map

package/models/trace/helpers/Timing.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/helpers/Timing.ts"],
+  "sourcesContent": ["// Copyright 2022 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Platform from '../../../core/platform/platform.js';\nimport * as Types from '../types/types.js';\n\nimport {getNavigationForTraceEvent} from './Trace.js';\n\nexport const millisecondsToMicroseconds = (value: Types.Timing.MilliSeconds): Types.Timing.MicroSeconds =>\n    Types.Timing.MicroSeconds(value * 1000);\n\nexport const secondsToMilliseconds = (value: Types.Timing.Seconds): Types.Timing.MilliSeconds =>\n    Types.Timing.MilliSeconds(value * 1000);\n\nexport const secondsToMicroseconds = (value: Types.Timing.Seconds): Types.Timing.MicroSeconds =>\n    millisecondsToMicroseconds(secondsToMilliseconds(value));\n\nexport const microSecondsToMilliseconds = (value: Types.Timing.MicroSeconds): Types.Timing.MilliSeconds =>\n    Types.Timing.MilliSeconds(value / 1000);\n\nexport const microSecondsToSeconds = (value: Types.Timing.MicroSeconds): Types.Timing.Seconds =>\n    Types.Timing.Seconds(value / 1000 / 1000);\n\nexport function detectBestTimeUnit(timeInMicroseconds: Types.Timing.MicroSeconds): Types.Timing.TimeUnit {\n  if (timeInMicroseconds < 1000) {\n    return Types.Timing.TimeUnit.MICROSECONDS;\n  }\n\n  const timeInMilliseconds = timeInMicroseconds / 1000;\n  if (timeInMilliseconds < 1000) {\n    return Types.Timing.TimeUnit.MILLISECONDS;\n  }\n\n  const timeInSeconds = timeInMilliseconds / 1000;\n  if (timeInSeconds < 60) {\n    return Types.Timing.TimeUnit.SECONDS;\n  }\n\n  return Types.Timing.TimeUnit.MINUTES;\n}\n\ninterface FormatOptions extends Intl.NumberFormatOptions {\n  format?: Types.Timing.TimeUnit;\n}\n\nconst defaultFormatOptions = {\n  style: 'unit',\n  unit: 'millisecond',\n  unitDisplay: 'narrow',\n};\n\n// Create a bunch of common formatters up front, so that we're not creating\n// them repeatedly during rendering.\nconst serialize = (value: {}): string => JSON.stringify(value);\nconst formatterFactory = (key: string|undefined): Intl.NumberFormat => {\n  // If we pass undefined as the locale, that achieves two things:\n  // 1. Avoids us referencing window.navigatior to fetch the locale, which is\n  //    useful given long term we would like this engine to run in NodeJS\n  //    environments.\n  // 2. Will cause the formatter to fallback to the locale of the system, which\n  //    is likely going to be the most accurate one to use anyway.\n  return new Intl.NumberFormat(undefined, key ? JSON.parse(key) : {});\n};\nconst formatters = new Map<string, Intl.NumberFormat>();\n\n// Microsecond Formatter.\nPlatform.MapUtilities.getWithDefault(formatters, serialize({style: 'decimal'}), formatterFactory);\n\n// Millisecond Formatter\nPlatform.MapUtilities.getWithDefault(formatters, serialize(defaultFormatOptions), formatterFactory);\n\n// Second Formatter\nPlatform.MapUtilities.getWithDefault(\n    formatters, serialize({...defaultFormatOptions, unit: 'second'}), formatterFactory);\n\n// Minute Formatter\nPlatform.MapUtilities.getWithDefault(\n    formatters, serialize({...defaultFormatOptions, unit: 'minute'}), formatterFactory);\n\nexport function formatMicrosecondsTime(\n    timeInMicroseconds: Types.Timing.MicroSeconds, opts: FormatOptions = {}): string {\n  if (!opts.format) {\n    opts.format = detectBestTimeUnit(timeInMicroseconds);\n  }\n\n  const timeInMilliseconds = timeInMicroseconds / 1000;\n  const timeInSeconds = timeInMilliseconds / 1000;\n  const formatterOpts = {...defaultFormatOptions, ...opts};\n\n  switch (opts.format) {\n    case Types.Timing.TimeUnit.MICROSECONDS: {\n      const formatter =\n          Platform.MapUtilities.getWithDefault(formatters, serialize({style: 'decimal'}), formatterFactory);\n      return `${formatter.format(timeInMicroseconds)}\u03BCs`;\n    }\n\n    case Types.Timing.TimeUnit.MILLISECONDS: {\n      const formatter = Platform.MapUtilities.getWithDefault(formatters, serialize(formatterOpts), formatterFactory);\n      return formatter.format(timeInMilliseconds);\n    }\n\n    case Types.Timing.TimeUnit.SECONDS: {\n      const formatter = Platform.MapUtilities.getWithDefault(\n          formatters, serialize({...formatterOpts, unit: 'second'}), formatterFactory);\n      return formatter.format(timeInSeconds);\n    }\n\n    default: {\n      // Switch to mins & seconds.\n      const minuteFormatter = Platform.MapUtilities.getWithDefault(\n          formatters, serialize({...formatterOpts, unit: 'minute'}), formatterFactory);\n      const secondFormatter = Platform.MapUtilities.getWithDefault(\n          formatters, serialize({...formatterOpts, unit: 'second'}), formatterFactory);\n      const timeInMinutes = timeInSeconds / 60;\n      const [mins, divider, fraction] = minuteFormatter.formatToParts(timeInMinutes);\n\n      let seconds = 0;\n      if (divider && fraction) {\n        // Convert the fraction value (a string) to the nearest second.\n        seconds = Math.round(Number(`0.${fraction.value}`) * 60);\n      }\n      return `${minuteFormatter.format(Number(mins.value))} ${secondFormatter.format(seconds)}`;\n    }\n  }\n}\n\nexport function timeStampForEventAdjustedByClosestNavigation(\n    event: Types.TraceEvents.TraceEventData,\n    traceBounds: Types.Timing.TraceWindowMicroSeconds,\n    navigationsByNavigationId: Map<string, Types.TraceEvents.TraceEventNavigationStart>,\n    navigationsByFrameId: Map<string, Types.TraceEvents.TraceEventNavigationStart[]>,\n    ): Types.Timing.MicroSeconds {\n  let eventTimeStamp = event.ts - traceBounds.min;\n  if (event.args?.data?.navigationId) {\n    const navigationForEvent = navigationsByNavigationId.get(event.args.data.navigationId);\n    if (navigationForEvent) {\n      eventTimeStamp = event.ts - navigationForEvent.ts;\n    }\n  } else if (event.args?.data?.frame) {\n    const navigationForEvent = getNavigationForTraceEvent(event, event.args.data.frame, navigationsByFrameId);\n    if (navigationForEvent) {\n      eventTimeStamp = event.ts - navigationForEvent.ts;\n    }\n  }\n  return Types.Timing.MicroSeconds(eventTimeStamp);\n}\n\nexport interface EventTimingsData<\n  ValueType extends Types.Timing.MicroSeconds|Types.Timing.MilliSeconds|Types.Timing.Seconds,\n> {\n  startTime: ValueType;\n  endTime: ValueType;\n  duration: ValueType;\n  selfTime: ValueType;\n}\n\nexport function eventTimingsMicroSeconds(event: Types.TraceEvents.TraceEventData):\n    EventTimingsData<Types.Timing.MicroSeconds> {\n  return {\n    startTime: event.ts,\n    endTime: Types.Timing.MicroSeconds(event.ts + (event.dur || Types.Timing.MicroSeconds(0))),\n    duration: Types.Timing.MicroSeconds(event.dur || 0),\n    // TODO(crbug.com/1434599): Implement selfTime calculation for events\n    // from the new engine.\n    selfTime: Types.TraceEvents.isSyntheticTraceEntry(event) ? Types.Timing.MicroSeconds(event.selfTime || 0) :\n                                                               Types.Timing.MicroSeconds(event.dur || 0),\n  };\n}\nexport function eventTimingsMilliSeconds(event: Types.TraceEvents.TraceEventData):\n    EventTimingsData<Types.Timing.MilliSeconds> {\n  const microTimes = eventTimingsMicroSeconds(event);\n  return {\n    startTime: microSecondsToMilliseconds(microTimes.startTime),\n    endTime: microSecondsToMilliseconds(microTimes.endTime),\n    duration: microSecondsToMilliseconds(microTimes.duration),\n    selfTime: microSecondsToMilliseconds(microTimes.selfTime),\n  };\n}\nexport function eventTimingsSeconds(event: Types.TraceEvents.TraceEventData): EventTimingsData<Types.Timing.Seconds> {\n  const microTimes = eventTimingsMicroSeconds(event);\n  return {\n    startTime: microSecondsToSeconds(microTimes.startTime),\n    endTime: microSecondsToSeconds(microTimes.endTime),\n    duration: microSecondsToSeconds(microTimes.duration),\n    selfTime: microSecondsToSeconds(microTimes.selfTime),\n  };\n}\n\nexport function traceWindowMilliSeconds(bounds: Types.Timing.TraceWindowMicroSeconds):\n    Types.Timing.TraceWindowMilliSeconds {\n  return {\n    min: microSecondsToMilliseconds(bounds.min),\n    max: microSecondsToMilliseconds(bounds.max),\n    range: microSecondsToMilliseconds(bounds.range),\n  };\n}\n\nexport function traceWindowMillisecondsToMicroSeconds(bounds: Types.Timing.TraceWindowMilliSeconds):\n    Types.Timing.TraceWindowMicroSeconds {\n  return {\n    min: millisecondsToMicroseconds(bounds.min),\n    max: millisecondsToMicroseconds(bounds.max),\n    range: millisecondsToMicroseconds(bounds.range),\n  };\n}\n\nexport function traceWindowFromMilliSeconds(\n    min: Types.Timing.MilliSeconds, max: Types.Timing.MilliSeconds): Types.Timing.TraceWindowMicroSeconds {\n  const traceWindow: Types.Timing.TraceWindowMicroSeconds = {\n    min: millisecondsToMicroseconds(min),\n    max: millisecondsToMicroseconds(max),\n    range: Types.Timing.MicroSeconds(millisecondsToMicroseconds(max) - millisecondsToMicroseconds(min)),\n  };\n  return traceWindow;\n}\n\nexport function traceWindowFromMicroSeconds(\n    min: Types.Timing.MicroSeconds, max: Types.Timing.MicroSeconds): Types.Timing.TraceWindowMicroSeconds {\n  const traceWindow: Types.Timing.TraceWindowMicroSeconds = {\n    min,\n    max,\n    range: Types.Timing.MicroSeconds(max - min),\n  };\n  return traceWindow;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/models/trace/helpers/Trace.js

@@ -0,0 +1,196 @@
+import * as Platform from "../../../core/platform/platform.js";
+import * as Types from "../types/types.js";
+export function stackTraceForEvent(event) {
+  if (Types.TraceEvents.isSyntheticInvalidation(event)) {
+    return event.stackTrace || null;
+  }
+  if (event.args?.data?.stackTrace) {
+    return event.args.data.stackTrace;
+  }
+  if (Types.TraceEvents.isTraceEventUpdateLayoutTree(event)) {
+    return event.args.beginData?.stackTrace || null;
+  }
+  return null;
+}
+export function extractOriginFromTrace(firstNavigationURL) {
+  const url = new URL(firstNavigationURL);
+  if (url) {
+    if (url.host.startsWith("www.")) {
+      return url.host.slice(4);
+    }
+    return url.host;
+  }
+  return null;
+}
+export function addEventToProcessThread(event, eventsInProcessThread) {
+  const { tid, pid } = event;
+  let eventsInThread = eventsInProcessThread.get(pid);
+  if (!eventsInThread) {
+    eventsInThread = /* @__PURE__ */ new Map();
+  }
+  let events = eventsInThread.get(tid);
+  if (!events) {
+    events = [];
+  }
+  events.push(event);
+  eventsInThread.set(event.tid, events);
+  eventsInProcessThread.set(event.pid, eventsInThread);
+}
+function eventTimeComparator(a, b) {
+  const aBeginTime = a.ts;
+  const bBeginTime = b.ts;
+  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 sortTraceEventsInPlace(events) {
+  events.sort(eventTimeComparator);
+}
+export function mergeEventsInOrder(eventsArray1, eventsArray2) {
+  const result = [];
+  let i = 0;
+  let j = 0;
+  while (i < eventsArray1.length && j < eventsArray2.length) {
+    const event1 = eventsArray1[i];
+    const event2 = eventsArray2[j];
+    const compareValue = eventTimeComparator(event1, event2);
+    if (compareValue <= 0) {
+      result.push(event1);
+      i++;
+    }
+    if (compareValue === 1) {
+      result.push(event2);
+      j++;
+    }
+  }
+  while (i < eventsArray1.length) {
+    result.push(eventsArray1[i++]);
+  }
+  while (j < eventsArray2.length) {
+    result.push(eventsArray2[j++]);
+  }
+  return result;
+}
+export function getNavigationForTraceEvent(event, eventFrameId, navigationsByFrameId) {
+  const navigations = navigationsByFrameId.get(eventFrameId);
+  if (!navigations || eventFrameId === "") {
+    return null;
+  }
+  const eventNavigationIndex = Platform.ArrayUtilities.nearestIndexFromEnd(navigations, (navigation) => navigation.ts <= event.ts);
+  if (eventNavigationIndex === null) {
+    return null;
+  }
+  return navigations[eventNavigationIndex];
+}
+export function extractId(event) {
+  return event.id ?? event.id2?.global ?? event.id2?.local;
+}
+export function activeURLForFrameAtTime(frameId, time, rendererProcessesByFrame) {
+  const processData = rendererProcessesByFrame.get(frameId);
+  if (!processData) {
+    return null;
+  }
+  for (const processes of processData.values()) {
+    for (const processInfo of processes) {
+      if (processInfo.window.min > time || processInfo.window.max < time) {
+        continue;
+      }
+      return processInfo.frame.url;
+    }
+  }
+  return null;
+}
+export function makeProfileCall(node, ts, pid, tid) {
+  return {
+    cat: "",
+    name: "ProfileCall",
+    nodeId: node.id,
+    args: {},
+    ph: Types.TraceEvents.Phase.COMPLETE,
+    pid,
+    tid,
+    ts,
+    dur: Types.Timing.MicroSeconds(0),
+    selfTime: Types.Timing.MicroSeconds(0),
+    callFrame: node.callFrame
+  };
+}
+export function matchBeginningAndEndEvents(unpairedEvents) {
+  const matchedPairs = /* @__PURE__ */ new Map();
+  for (const event of unpairedEvents) {
+    const syntheticId = getSyntheticId(event);
+    if (syntheticId === void 0) {
+      continue;
+    }
+    const otherEventsWithID = Platform.MapUtilities.getWithDefault(matchedPairs, syntheticId, () => {
+      return { begin: null, end: null };
+    });
+    const isStartEvent = event.ph === Types.TraceEvents.Phase.ASYNC_NESTABLE_START;
+    const isEndEvent = event.ph === Types.TraceEvents.Phase.ASYNC_NESTABLE_END;
+    if (isStartEvent) {
+      otherEventsWithID.begin = event;
+    } else if (isEndEvent) {
+      otherEventsWithID.end = event;
+    }
+  }
+  return matchedPairs;
+}
+function getSyntheticId(event) {
+  const id = extractId(event);
+  return id && `${event.cat}:${id}:${event.name}`;
+}
+export function createSortedSyntheticEvents(matchedPairs) {
+  const syntheticEvents = [];
+  for (const [id, eventsPair] of matchedPairs.entries()) {
+    let eventsArePairable = function(data) {
+      return Boolean(getSyntheticId(data.beginEvent)) && getSyntheticId(data.beginEvent) === getSyntheticId(data.endEvent);
+    };
+    const beginEvent = eventsPair.begin;
+    const endEvent = eventsPair.end;
+    if (!beginEvent || !endEvent) {
+      continue;
+    }
+    const pair = { beginEvent, endEvent };
+    if (!eventsArePairable(pair)) {
+      continue;
+    }
+    const event = {
+      cat: endEvent.cat,
+      ph: endEvent.ph,
+      pid: endEvent.pid,
+      tid: endEvent.tid,
+      id,
+      name: beginEvent.name,
+      dur: Types.Timing.MicroSeconds(endEvent.ts - beginEvent.ts),
+      ts: beginEvent.ts,
+      args: {
+        data: pair
+      }
+    };
+    if (event.dur < 0) {
+      continue;
+    }
+    syntheticEvents.push(event);
+  }
+  return syntheticEvents.sort((a, b) => a.ts - b.ts);
+}
+export function createMatchedSortedSyntheticEvents(unpairedAsyncEvents) {
+  const matchedPairs = matchBeginningAndEndEvents(unpairedAsyncEvents);
+  const syntheticEvents = createSortedSyntheticEvents(matchedPairs);
+  return syntheticEvents;
+}
+//# sourceMappingURL=Trace.js.map

package/models/trace/helpers/Trace.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/helpers/Trace.ts"],
+  "sourcesContent": ["// Copyright 2022 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Platform from '../../../core/platform/platform.js';\nimport type * as CPUProfile from '../../cpu_profile/cpu_profile.js';\nimport * as Types from '../types/types.js';\n\ntype MatchedPairType<T extends Types.TraceEvents.TraceEventPairableAsync> = Types.TraceEvents.SyntheticEventPair<T>;\nexport function stackTraceForEvent(event: Types.TraceEvents.TraceEventData): Types.TraceEvents.TraceEventCallFrame[]|\n    null {\n  if (Types.TraceEvents.isSyntheticInvalidation(event)) {\n    return event.stackTrace || null;\n  }\n  if (event.args?.data?.stackTrace) {\n    return event.args.data.stackTrace;\n  }\n  if (Types.TraceEvents.isTraceEventUpdateLayoutTree(event)) {\n    return event.args.beginData?.stackTrace || null;\n  }\n  return null;\n}\n\nexport function extractOriginFromTrace(firstNavigationURL: string): string|null {\n  const url = new URL(firstNavigationURL);\n  if (url) {\n    // We do this to save some space in the toolbar - seeing the `www` is less\n    // useful than seeing `foo.com` if it's truncated at narrow widths\n    if (url.host.startsWith('www.')) {\n      return url.host.slice(4);\n    }\n    return url.host;\n  }\n  return null;\n}\n\nexport type EventsInThread<T extends Types.TraceEvents.TraceEventData> = Map<Types.TraceEvents.ThreadID, T[]>;\n// Each thread contains events. Events indicate the thread and process IDs, which are\n// used to store the event in the correct process thread entry below.\nexport function addEventToProcessThread<T extends Types.TraceEvents.TraceEventData>(\n    event: T,\n    eventsInProcessThread: Map<Types.TraceEvents.ProcessID, EventsInThread<T>>,\n    ): void {\n  const {tid, pid} = event;\n  let eventsInThread = eventsInProcessThread.get(pid);\n  if (!eventsInThread) {\n    eventsInThread = new Map<Types.TraceEvents.ThreadID, T[]>();\n  }\n\n  let events = eventsInThread.get(tid);\n  if (!events) {\n    events = [];\n  }\n\n  events.push(event);\n  eventsInThread.set(event.tid, events);\n  eventsInProcessThread.set(event.pid, eventsInThread);\n}\n\ntype TimeSpan = {\n  ts: Types.Timing.MicroSeconds,\n  dur?: Types.Timing.MicroSeconds,\n};\nfunction eventTimeComparator(a: TimeSpan, b: TimeSpan): -1|0|1 {\n  const aBeginTime = a.ts;\n  const bBeginTime = b.ts;\n  if (aBeginTime < bBeginTime) {\n    return -1;\n  }\n  if (aBeginTime > bBeginTime) {\n    return 1;\n  }\n  const aDuration = a.dur ?? 0;\n  const bDuration = b.dur ?? 0;\n  const aEndTime = aBeginTime + aDuration;\n  const bEndTime = bBeginTime + bDuration;\n  if (aEndTime > bEndTime) {\n    return -1;\n  }\n  if (aEndTime < bEndTime) {\n    return 1;\n  }\n  return 0;\n}\n/**\n * Sorts all the events in place, in order, by their start time. If they have\n * the same start time, orders them by longest first.\n */\nexport function sortTraceEventsInPlace(events: {ts: Types.Timing.MicroSeconds, dur?: Types.Timing.MicroSeconds}[]):\n    void {\n  events.sort(eventTimeComparator);\n}\n\n/**\n * Returns an array of ordered events that results after merging the two\n * ordered input arrays.\n */\nexport function\nmergeEventsInOrder<T1 extends Types.TraceEvents.TraceEventData, T2 extends Types.TraceEvents.TraceEventData>(\n    eventsArray1: T1[], eventsArray2: T2[]): (T1|T2)[] {\n  const result = [];\n  let i = 0;\n  let j = 0;\n  while (i < eventsArray1.length && j < eventsArray2.length) {\n    const event1 = eventsArray1[i];\n    const event2 = eventsArray2[j];\n    const compareValue = eventTimeComparator(event1, event2);\n    if (compareValue <= 0) {\n      result.push(event1);\n      i++;\n    }\n    if (compareValue === 1) {\n      result.push(event2);\n      j++;\n    }\n  }\n  while (i < eventsArray1.length) {\n    result.push(eventsArray1[i++]);\n  }\n  while (j < eventsArray2.length) {\n    result.push(eventsArray2[j++]);\n  }\n  return result;\n}\n\nexport function getNavigationForTraceEvent(\n    event: Types.TraceEvents.TraceEventData,\n    eventFrameId: string,\n    navigationsByFrameId: Map<string, Types.TraceEvents.TraceEventNavigationStart[]>,\n    ): Types.TraceEvents.TraceEventNavigationStart|null {\n  const navigations = navigationsByFrameId.get(eventFrameId);\n  if (!navigations || eventFrameId === '') {\n    // This event's navigation has been filtered out by the meta handler as a noise event\n    // or contains an empty frameId.\n    return null;\n  }\n\n  const eventNavigationIndex =\n      Platform.ArrayUtilities.nearestIndexFromEnd(navigations, navigation => navigation.ts <= event.ts);\n\n  if (eventNavigationIndex === null) {\n    // This event's navigation has been filtered out by the meta handler as a noise event.\n    return null;\n  }\n  return navigations[eventNavigationIndex];\n}\n\nexport function extractId(event: Types.TraceEvents.TraceEventPairableAsync|\n                          MatchedPairType<Types.TraceEvents.TraceEventPairableAsync>): string|undefined {\n  return event.id ?? event.id2?.global ?? event.id2?.local;\n}\n\nexport function activeURLForFrameAtTime(\n    frameId: string, time: Types.Timing.MicroSeconds,\n    rendererProcessesByFrame:\n        Map<string,\n            Map<Types.TraceEvents.ProcessID,\n                {frame: Types.TraceEvents.TraceFrame, window: Types.Timing.TraceWindowMicroSeconds}[]>>): string|null {\n  const processData = rendererProcessesByFrame.get(frameId);\n  if (!processData) {\n    return null;\n  }\n  for (const processes of processData.values()) {\n    for (const processInfo of processes) {\n      if (processInfo.window.min > time || processInfo.window.max < time) {\n        continue;\n      }\n      return processInfo.frame.url;\n    }\n  }\n  return null;\n}\n\nexport function makeProfileCall(\n    node: CPUProfile.ProfileTreeModel.ProfileNode, ts: Types.Timing.MicroSeconds, pid: Types.TraceEvents.ProcessID,\n    tid: Types.TraceEvents.ThreadID): Types.TraceEvents.SyntheticProfileCall {\n  return {\n    cat: '',\n    name: 'ProfileCall',\n    nodeId: node.id,\n    args: {},\n    ph: Types.TraceEvents.Phase.COMPLETE,\n    pid,\n    tid,\n    ts,\n    dur: Types.Timing.MicroSeconds(0),\n    selfTime: Types.Timing.MicroSeconds(0),\n    callFrame: node.callFrame,\n  };\n}\n\nexport function matchBeginningAndEndEvents(unpairedEvents: Types.TraceEvents.TraceEventPairableAsync[]): Map<string, {\n  begin: Types.TraceEvents.TraceEventPairableAsyncBegin | null,\n  end: Types.TraceEvents.TraceEventPairableAsyncEnd | null,\n}> {\n  // map to store begin and end of the event\n  const matchedPairs: Map<string, {\n    begin: Types.TraceEvents.TraceEventPairableAsyncBegin | null,\n    end: Types.TraceEvents.TraceEventPairableAsyncEnd | null,\n  }> = new Map();\n\n  // looking for start and end\n  for (const event of unpairedEvents) {\n    const syntheticId = getSyntheticId(event);\n    if (syntheticId === undefined) {\n      continue;\n    }\n    // Create a synthetic id to prevent collisions across categories.\n    // Console timings can be dispatched with the same id, so use the\n    // event name as well to generate unique ids.\n    const otherEventsWithID = Platform.MapUtilities.getWithDefault(matchedPairs, syntheticId, () => {\n      return {begin: null, end: null};\n    });\n\n    const isStartEvent = event.ph === Types.TraceEvents.Phase.ASYNC_NESTABLE_START;\n    const isEndEvent = event.ph === Types.TraceEvents.Phase.ASYNC_NESTABLE_END;\n\n    if (isStartEvent) {\n      otherEventsWithID.begin = event as Types.TraceEvents.TraceEventPairableAsyncBegin;\n    } else if (isEndEvent) {\n      otherEventsWithID.end = event as Types.TraceEvents.TraceEventPairableAsyncEnd;\n    }\n  }\n\n  return matchedPairs;\n}\n\nfunction getSyntheticId(event: Types.TraceEvents.TraceEventPairableAsync): string|undefined {\n  const id = extractId(event);\n  return id && `${event.cat}:${id}:${event.name}`;\n}\n\nexport function createSortedSyntheticEvents<T extends Types.TraceEvents.TraceEventPairableAsync>(\n    matchedPairs: Map<string, {\n      begin: Types.TraceEvents.TraceEventPairableAsyncBegin | null,\n      end: Types.TraceEvents.TraceEventPairableAsyncEnd | null,\n    }>): MatchedPairType<T>[] {\n  const syntheticEvents: MatchedPairType<T>[] = [];\n  for (const [id, eventsPair] of matchedPairs.entries()) {\n    const beginEvent = eventsPair.begin;\n    const endEvent = eventsPair.end;\n    if (!beginEvent || !endEvent) {\n      // This should never happen, the backend only creates the events once it\n      // has them both, so we should never get into this state.\n      // If we do, something is very wrong, so let's just drop that problematic event.\n      continue;\n    }\n    const pair = {beginEvent, endEvent};\n    function eventsArePairable(data: {\n      beginEvent: Types.TraceEvents.TraceEventPairableAsyncBegin,\n      endEvent: Types.TraceEvents.TraceEventPairableAsyncEnd,\n    }): data is MatchedPairType<T>['args']['data'] {\n      return Boolean(getSyntheticId(data.beginEvent)) &&\n          getSyntheticId(data.beginEvent) === getSyntheticId(data.endEvent);\n    }\n    if (!eventsArePairable(pair)) {\n      continue;\n    }\n    const event: MatchedPairType<T> = {\n      cat: endEvent.cat,\n      ph: endEvent.ph,\n      pid: endEvent.pid,\n      tid: endEvent.tid,\n      id,\n      // Both events have the same name, so it doesn't matter which we pick to\n      // use as the description\n      name: beginEvent.name,\n      dur: Types.Timing.MicroSeconds(endEvent.ts - beginEvent.ts),\n      ts: beginEvent.ts,\n      args: {\n        data: pair,\n      },\n    };\n\n    if (event.dur < 0) {\n      // We have seen in the backend that sometimes animation events get\n      // generated with multiple begin entries, or multiple end entries, and this\n      // can cause invalid data on the performance panel, so we drop them.\n      // crbug.com/1472375\n      continue;\n    }\n    syntheticEvents.push(event);\n  }\n  return syntheticEvents.sort((a, b) => a.ts - b.ts);\n}\n\nexport function createMatchedSortedSyntheticEvents<T extends Types.TraceEvents.TraceEventPairableAsync>(\n    unpairedAsyncEvents: T[]): MatchedPairType<T>[] {\n  const matchedPairs = matchBeginningAndEndEvents(unpairedAsyncEvents);\n  const syntheticEvents = createSortedSyntheticEvents<T>(matchedPairs);\n  return syntheticEvents;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/models/trace/helpers/TreeHelpers.js

@@ -0,0 +1,119 @@
+import * as Types from "../types/types.js";
+let nodeIdCount = 0;
+export const makeTraceEntryNodeId = () => ++nodeIdCount;
+export const makeEmptyTraceEntryTree = () => ({
+  roots: /* @__PURE__ */ new Set(),
+  maxDepth: 0
+});
+export const makeEmptyTraceEntryNode = (entry, id) => ({
+  entry,
+  id,
+  parent: null,
+  children: [],
+  depth: 0
+});
+class TraceEntryNodeIdTag {
+  #tag;
+}
+export function treify(entries, options) {
+  const entryToNode = /* @__PURE__ */ new Map();
+  const stack = [];
+  nodeIdCount = -1;
+  const tree = makeEmptyTraceEntryTree();
+  for (let i = 0; i < entries.length; i++) {
+    const event = entries[i];
+    if (options && !options.filter.has(event.name)) {
+      continue;
+    }
+    const duration = event.dur || 0;
+    const nodeId = makeTraceEntryNodeId();
+    const node = makeEmptyTraceEntryNode(event, nodeId);
+    if (stack.length === 0) {
+      tree.roots.add(node);
+      event.selfTime = Types.Timing.MicroSeconds(duration);
+      stack.push(node);
+      tree.maxDepth = Math.max(tree.maxDepth, stack.length);
+      entryToNode.set(event, node);
+      continue;
+    }
+    const parentNode = stack.at(-1);
+    if (parentNode === void 0) {
+      throw new Error("Impossible: no parent node found in the stack");
+    }
+    const parentEvent = parentNode.entry;
+    const begin = event.ts;
+    const parentBegin = parentEvent.ts;
+    const parentDuration = parentEvent.dur || 0;
+    const end = begin + duration;
+    const parentEnd = parentBegin + parentDuration;
+    const startsBeforeParent = begin < parentBegin;
+    if (startsBeforeParent) {
+      throw new Error("Impossible: current event starts before the parent event");
+    }
+    const startsAfterParent = begin >= parentEnd;
+    if (startsAfterParent) {
+      stack.pop();
+      i--;
+      nodeIdCount--;
+      continue;
+    }
+    const endsAfterParent = end > parentEnd;
+    if (endsAfterParent) {
+      continue;
+    }
+    node.depth = stack.length;
+    node.parent = parentNode;
+    parentNode.children.push(node);
+    event.selfTime = Types.Timing.MicroSeconds(duration);
+    if (parentEvent.selfTime !== void 0) {
+      parentEvent.selfTime = Types.Timing.MicroSeconds(parentEvent.selfTime - (event.dur || 0));
+    }
+    stack.push(node);
+    tree.maxDepth = Math.max(tree.maxDepth, stack.length);
+    entryToNode.set(event, node);
+  }
+  return { tree, entryToNode };
+}
+export function walkTreeFromEntry(entryToNode, rootEntry, onEntryStart, onEntryEnd) {
+  const startNode = entryToNode.get(rootEntry);
+  if (!startNode) {
+    return;
+  }
+  walkTreeByNode(entryToNode, startNode, onEntryStart, onEntryEnd);
+}
+export function walkEntireTree(entryToNode, tree, onEntryStart, onEntryEnd, traceWindowToInclude, minDuration) {
+  for (const rootNode of tree.roots) {
+    walkTreeByNode(entryToNode, rootNode, onEntryStart, onEntryEnd, traceWindowToInclude, minDuration);
+  }
+}
+function walkTreeByNode(entryToNode, rootNode, onEntryStart, onEntryEnd, traceWindowToInclude, minDuration) {
+  if (traceWindowToInclude && !treeNodeIsInWindow(rootNode, traceWindowToInclude)) {
+    return;
+  }
+  if (typeof minDuration !== "undefined") {
+    const duration = Types.Timing.MicroSeconds(rootNode.entry.ts + Types.Timing.MicroSeconds(rootNode.entry.dur || 0));
+    if (duration < minDuration) {
+      return;
+    }
+  }
+  onEntryStart(rootNode.entry);
+  for (const child of rootNode.children) {
+    walkTreeByNode(entryToNode, child, onEntryStart, onEntryEnd, traceWindowToInclude, minDuration);
+  }
+  onEntryEnd(rootNode.entry);
+}
+function treeNodeIsInWindow(node, traceWindow) {
+  const startTime = node.entry.ts;
+  const endTime = node.entry.ts + (node.entry.dur || 0);
+  if (startTime >= traceWindow.min && startTime < traceWindow.max) {
+    return true;
+  }
+  if (endTime > traceWindow.min && endTime <= traceWindow.max) {
+    return true;
+  }
+  if (startTime <= traceWindow.min && endTime >= traceWindow.max) {
+    return true;
+  }
+  return false;
+}
+//# sourceMappingURL=TreeHelpers.js.map

package/models/trace/helpers/TreeHelpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/helpers/TreeHelpers.ts"],
+  "sourcesContent": ["// Copyright 2023 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Types from '../types/types.js';\n\nlet nodeIdCount = 0;\nexport const makeTraceEntryNodeId = (): TraceEntryNodeId => (++nodeIdCount) as TraceEntryNodeId;\n\nexport const makeEmptyTraceEntryTree = (): TraceEntryTree => ({\n  roots: new Set(),\n  maxDepth: 0,\n});\n\nexport const makeEmptyTraceEntryNode =\n    (entry: Types.TraceEvents.SyntheticTraceEntry, id: TraceEntryNodeId): TraceEntryNode => ({\n      entry,\n      id,\n      parent: null,\n      children: [],\n      depth: 0,\n    });\n\nexport interface TraceEntryTree {\n  roots: Set<TraceEntryNode>;\n  maxDepth: number;\n}\n\nexport interface TraceEntryNode {\n  entry: Types.TraceEvents.SyntheticTraceEntry;\n  depth: number;\n  id: TraceEntryNodeId;\n  parent: TraceEntryNode|null;\n  children: TraceEntryNode[];\n}\n\nclass TraceEntryNodeIdTag {\n  /* eslint-disable-next-line no-unused-private-class-members */\n  readonly #tag: (symbol|undefined);\n}\nexport type TraceEntryNodeId = number&TraceEntryNodeIdTag;\n\n/**\n * Builds a hierarchy of the entries (trace events and profile calls) in\n * a particular thread of a particular process, assuming that they're\n * sorted, by iterating through all of the events in order.\n *\n * The approach is analogous to how a parser would be implemented. A\n * stack maintains local context. A scanner peeks and pops from the data\n * stream. Various \"tokens\" (events) are treated as \"whitespace\"\n * (ignored).\n *\n * The tree starts out empty and is populated as the hierarchy is built.\n * The nodes are also assumed to be created empty, with no known parent\n * or children.\n *\n * Complexity: O(n), where n = number of events\n */\nexport function treify(entries: Types.TraceEvents.SyntheticTraceEntry[], options?: {\n  filter: {has: (name: Types.TraceEvents.KnownEventName) => boolean},\n}): {tree: TraceEntryTree, entryToNode: Map<Types.TraceEvents.SyntheticTraceEntry, TraceEntryNode>} {\n  // As we construct the tree, store a map of each entry to its node. This\n  // means if you are iterating over a list of RendererEntry events you can\n  // easily look up that node in the tree.\n  const entryToNode = new Map<Types.TraceEvents.SyntheticTraceEntry, TraceEntryNode>();\n\n  const stack = [];\n  // Reset the node id counter for every new renderer.\n  nodeIdCount = -1;\n  const tree = makeEmptyTraceEntryTree();\n\n  for (let i = 0; i < entries.length; i++) {\n    const event = entries[i];\n    // If the current event should not be part of the tree, then simply proceed\n    // with the next event.\n    if (options && !options.filter.has(event.name as Types.TraceEvents.KnownEventName)) {\n      continue;\n    }\n\n    const duration = event.dur || 0;\n    const nodeId = makeTraceEntryNodeId();\n    const node = makeEmptyTraceEntryNode(event, nodeId);\n\n    // If the parent stack is empty, then the current event is a root. Create a\n    // node for it, mark it as a root, then proceed with the next event.\n    if (stack.length === 0) {\n      tree.roots.add(node);\n      event.selfTime = Types.Timing.MicroSeconds(duration);\n      stack.push(node);\n      tree.maxDepth = Math.max(tree.maxDepth, stack.length);\n      entryToNode.set(event, node);\n      continue;\n    }\n\n    const parentNode = stack.at(-1);\n    if (parentNode === undefined) {\n      throw new Error('Impossible: no parent node found in the stack');\n    }\n\n    const parentEvent = parentNode.entry;\n\n    const begin = event.ts;\n    const parentBegin = parentEvent.ts;\n    const parentDuration = parentEvent.dur || 0;\n    const end = begin + duration;\n    const parentEnd = parentBegin + parentDuration;\n    // Check the relationship between the parent event at the top of the stack,\n    // and the current event being processed. There are only 4 distinct\n    // possiblities, only 2 of them actually valid, given the assumed sorting:\n    // 1. Current event starts before the parent event, ends whenever. (invalid)\n    // 2. Current event starts after the parent event, ends whenever. (valid)\n    // 3. Current event starts during the parent event, ends after. (invalid)\n    // 4. Current event starts and ends during the parent event. (valid)\n\n    // 1. If the current event starts before the parent event, then the data is\n    //    not sorted properly, messed up some way, or this logic is incomplete.\n    const startsBeforeParent = begin < parentBegin;\n    if (startsBeforeParent) {\n      throw new Error('Impossible: current event starts before the parent event');\n    }\n\n    // 2. If the current event starts after the parent event, then it's a new\n    //    parent. Pop, then handle current event again.\n    const startsAfterParent = begin >= parentEnd;\n    if (startsAfterParent) {\n      stack.pop();\n      i--;\n      // The last created node has been discarded, so discard this id.\n      nodeIdCount--;\n      continue;\n    }\n    // 3. If the current event starts during the parent event, but ends\n    //    after it, then the data is messed up some way, for example a\n    //    profile call was sampled too late after its start, ignore the\n    //    problematic event.\n    const endsAfterParent = end > parentEnd;\n    if (endsAfterParent) {\n      continue;\n    }\n\n    // 4. The only remaining case is the common case, where the current event is\n    //    contained within the parent event. Create a node for the current\n    //    event, establish the parent/child relationship, then proceed with the\n    //    next event.\n    node.depth = stack.length;\n    node.parent = parentNode;\n    parentNode.children.push(node);\n    event.selfTime = Types.Timing.MicroSeconds(duration);\n    if (parentEvent.selfTime !== undefined) {\n      parentEvent.selfTime = Types.Timing.MicroSeconds(parentEvent.selfTime - (event.dur || 0));\n    }\n    stack.push(node);\n    tree.maxDepth = Math.max(tree.maxDepth, stack.length);\n    entryToNode.set(event, node);\n  }\n  return {tree, entryToNode};\n}\n\n/**\n * Iterates events in a tree hierarchically, from top to bottom,\n * calling back on every event's start and end in the order\n * as it traverses down and then up the tree.\n *\n * For example, given this tree, the following callbacks\n * are expected to be made in the following order\n * |---------------A---------------|\n *  |------B------||-------D------|\n *    |---C---|\n *\n * 1. Start A\n * 3. Start B\n * 4. Start C\n * 5. End C\n * 6. End B\n * 7. Start D\n * 8. End D\n * 9. End A\n *\n */\nexport function walkTreeFromEntry(\n    entryToNode: Map<Types.TraceEvents.SyntheticTraceEntry, TraceEntryNode>,\n    rootEntry: Types.TraceEvents.SyntheticTraceEntry,\n    onEntryStart: (entry: Types.TraceEvents.SyntheticTraceEntry) => void,\n    onEntryEnd: (entry: Types.TraceEvents.SyntheticTraceEntry) => void,\n    ): void {\n  const startNode = entryToNode.get(rootEntry);\n  if (!startNode) {\n    return;\n  }\n  walkTreeByNode(entryToNode, startNode, onEntryStart, onEntryEnd);\n}\n\n/**\n * Given a Helpers.TreeHelpers.RendererTree, this will iterates events in hierarchically, visiting\n * each root node and working from top to bottom, calling back on every event's\n * start and end in the order as it traverses down and then up the tree.\n *\n * For example, given this tree, the following callbacks\n * are expected to be made in the following order\n * |------------- Task A -------------||-- Task E --|\n *  |-- Task B --||-- Task D --|\n *   |- Task C -|\n *\n * 1. Start A\n * 3. Start B\n * 4. Start C\n * 5. End C\n * 6. End B\n * 7. Start D\n * 8. End D\n * 9. End A\n * 10. Start E\n * 11. End E\n *\n */\n\nexport function walkEntireTree(\n    entryToNode: Map<Types.TraceEvents.SyntheticTraceEntry, TraceEntryNode>,\n    tree: TraceEntryTree,\n    onEntryStart: (entry: Types.TraceEvents.SyntheticTraceEntry) => void,\n    onEntryEnd: (entry: Types.TraceEvents.SyntheticTraceEntry) => void,\n    traceWindowToInclude?: Types.Timing.TraceWindowMicroSeconds,\n    minDuration?: Types.Timing.MicroSeconds,\n    ): void {\n  for (const rootNode of tree.roots) {\n    walkTreeByNode(entryToNode, rootNode, onEntryStart, onEntryEnd, traceWindowToInclude, minDuration);\n  }\n}\n\nfunction walkTreeByNode(\n    entryToNode: Map<Types.TraceEvents.SyntheticTraceEntry, TraceEntryNode>,\n    rootNode: TraceEntryNode,\n    onEntryStart: (entry: Types.TraceEvents.SyntheticTraceEntry) => void,\n    onEntryEnd: (entry: Types.TraceEvents.SyntheticTraceEntry) => void,\n    traceWindowToInclude?: Types.Timing.TraceWindowMicroSeconds,\n    minDuration?: Types.Timing.MicroSeconds,\n    ): void {\n  if (traceWindowToInclude && !treeNodeIsInWindow(rootNode, traceWindowToInclude)) {\n    // If this node is not within the provided window, we can skip it. We also\n    // can skip all its children too, as we know they won't be in the window if\n    // their parent is not.\n    return;\n  }\n\n  if (typeof minDuration !== 'undefined') {\n    const duration = Types.Timing.MicroSeconds(\n        rootNode.entry.ts + Types.Timing.MicroSeconds(rootNode.entry.dur || 0),\n    );\n    if (duration < minDuration) {\n      return;\n    }\n  }\n\n  onEntryStart(rootNode.entry);\n  for (const child of rootNode.children) {\n    walkTreeByNode(entryToNode, child, onEntryStart, onEntryEnd, traceWindowToInclude, minDuration);\n  }\n  onEntryEnd(rootNode.entry);\n}\n\n/**\n * Returns true if the provided node is partially or fully within the trace\n * window. The entire node does not have to fit inside the window, but it does\n * have to partially intersect it.\n */\nfunction treeNodeIsInWindow(node: TraceEntryNode, traceWindow: Types.Timing.TraceWindowMicroSeconds): boolean {\n  const startTime = node.entry.ts;\n  const endTime = node.entry.ts + (node.entry.dur || 0);\n\n  // Min ======= startTime ========= Max => node is within window\n  if (startTime >= traceWindow.min && startTime < traceWindow.max) {\n    return true;\n  }\n\n  // Min ======= endTime ========= Max => node is within window\n  if (endTime > traceWindow.min && endTime <= traceWindow.max) {\n    return true;\n  }\n\n  // startTime ==== Min ======== Max === endTime => node spans greater than the window so is in it.\n  if (startTime <= traceWindow.min && endTime >= traceWindow.max) {\n    return true;\n  }\n\n  return false;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/models/trace/helpers/bundle-tsconfig.json

@@ -0,0 +1 @@
+{"compilerOptions":{"composite":true,"outDir":".","baseUrl":".","rootDir":"../../../../../../../front_end/models/trace/helpers"},"files":["../../../../../../../front_end/models/trace/helpers/helpers.ts"],"references":[{"path":"./helpers-tsconfig.json"}]}