@paulirish/trace_engine 0.0.10 → 0.0.12

package/models/trace/helpers/TreeHelpers.js

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

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

@@ -1,7 +1 @@
-{
-  "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": []
-}
+{"version":3,"file":"TreeHelpers.js","sourceRoot":"","sources":["../../../../../../../front_end/models/trace/helpers/TreeHelpers.ts"],"names":[],"mappings":"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","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"]}

package/models/trace/helpers/helpers.d.ts

@@ -0,0 +1,4 @@
+export * as SamplesIntegrator from './SamplesIntegrator.js';
+export * as Timing from './Timing.js';
+export * as Trace from './Trace.js';
+export * as TreeHelpers from './TreeHelpers.js';

package/models/trace/helpers/helpers.js

@@ -1,5 +1,8 @@
-export * as SamplesIntegrator from "./SamplesIntegrator.js";
-export * as Timing from "./Timing.js";
-export * as Trace from "./Trace.js";
-export * as TreeHelpers from "./TreeHelpers.js";
-//# sourceMappingURL=helpers.js.map
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export * as SamplesIntegrator from './SamplesIntegrator.js';
+export * as Timing from './Timing.js';
+export * as Trace from './Trace.js';
+export * as TreeHelpers from './TreeHelpers.js';
+//# sourceMappingURL=helpers.js.map

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

@@ -1,7 +1 @@
-{
-  "version": 3,
-  "sources": ["../../../../../../../front_end/models/trace/helpers/helpers.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\nexport * as SamplesIntegrator from './SamplesIntegrator.js';\nexport * as Timing from './Timing.js';\nexport * as Trace from './Trace.js';\nexport * as TreeHelpers from './TreeHelpers.js';\n"],
-  "mappings": "AAIA;AACA;AACA;AACA;",
-  "names": []
-}
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../../../../../front_end/models/trace/helpers/helpers.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,yEAAyE;AACzE,6BAA6B;AAE7B,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC","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\nexport * as SamplesIntegrator from './SamplesIntegrator.js';\nexport * as Timing from './Timing.js';\nexport * as Trace from './Trace.js';\nexport * as TreeHelpers from './TreeHelpers.js';\n"]}

package/models/trace/root-causes/LayoutShift.d.ts

@@ -0,0 +1,119 @@
+import type * as Protocol from '../../../generated/protocol.js';
+import { type TraceParseData } from '../handlers/types.js';
+import * as Types from '../types/types.js';
+import { type RootCauseProtocolInterface } from './RootCauses.js';
+export type CSSDimensions = {
+    width?: string;
+    height?: string;
+    aspectRatio?: string;
+};
+export interface UnsizedMedia {
+    node: Protocol.DOM.Node;
+    authoredDimensions?: CSSDimensions;
+    computedDimensions: CSSDimensions;
+}
+export interface InjectedIframe {
+    iframe: Protocol.DOM.Node;
+}
+export interface RootCauseRequest {
+    request: Types.TraceEvents.SyntheticNetworkRequest;
+    initiator?: Protocol.Network.Initiator;
+}
+export interface FontChange extends RootCauseRequest {
+    fontFace: Protocol.CSS.FontFace;
+}
+export interface RenderBlockingRequest extends RootCauseRequest {
+}
+export interface LayoutShiftRootCausesData {
+    unsizedMedia: UnsizedMedia[];
+    iframes: InjectedIframe[];
+    fontChanges: FontChange[];
+    renderBlockingRequests: RenderBlockingRequest[];
+    scriptStackTrace: Types.TraceEvents.TraceEventCallFrame[];
+}
+export declare class LayoutShiftRootCauses {
+    #private;
+    constructor(protocolInterface: RootCauseProtocolInterface);
+    /**
+     * Calculates the potential root causes for a given layout shift event. Once
+     * calculated, this data is cached.
+     * Note: because you need all layout shift data at once to calculate these
+     * correctly, this function will parse the root causes for _all_ layout shift
+     * events the first time that it's called. That then populates the cache for
+     * each shift, so any subsequent calls are just a constant lookup.
+     */
+    rootCausesForEvent(modelData: TraceParseData, event: Types.TraceEvents.TraceEventLayoutShift): Promise<Readonly<LayoutShiftRootCausesData> | null>;
+    /**
+     * Determines potential root causes for shifts
+     */
+    blameShifts(layoutShifts: Types.TraceEvents.TraceEventLayoutShift[], modelData: TraceParseData): Promise<void>;
+    /**
+     * "LayoutInvalidations" are a set of trace events dispatched in Blink under the name
+     * "layoutInvalidationTracking", which track invalidations on the "Layout"stage of the
+     * rendering pipeline. This function utilizes this event to flag potential root causes
+     * to layout shifts.
+     */
+    linkShiftsToLayoutInvalidations(layoutShifts: Types.TraceEvents.TraceEventLayoutShift[], modelData: TraceParseData): Promise<void>;
+    /**
+     * For every shift looks up the initiator of its corresponding Layout event. This initiator
+     * is assigned by the RendererHandler and contains the stack trace of the point in a script
+     * that caused a style recalculation or a relayout. This stack trace is added to the shift's
+     * potential root causes.
+     * Note that a Layout cannot always be linked to a script, in that case, we cannot add a
+     * "script causing reflow" as a potential root cause to the corresponding shift.
+     */
+    linkShiftsToLayoutEvents(layoutShifts: Types.TraceEvents.TraceEventLayoutShift[], modelData: TraceParseData): void;
+    /**
+     * Given a LayoutInvalidation trace event, determines if it was dispatched
+     * because a media element without dimensions was resized.
+     */
+    getUnsizedMediaRootCause(reason: Types.TraceEvents.LayoutInvalidationReason, layoutInvalidationNode: Protocol.DOM.Node): Promise<UnsizedMedia | null>;
+    /**
+     * Given a LayoutInvalidation trace event, determines if it was dispatched
+     * because a node, which is an ancestor to an iframe, was injected.
+     */
+    getIframeRootCause(reason: Types.TraceEvents.LayoutInvalidationReason, layoutInvalidationDOMNode: Protocol.DOM.Node): InjectedIframe | null;
+    /**
+     * Given a layout invalidation event and a sorted array, returns the subset of requests that arrived within a
+     * 500ms window before the layout invalidation.
+     */
+    requestsInInvalidationWindow(layoutInvalidation: Types.TraceEvents.TraceEventLayoutInvalidationTracking | Types.TraceEvents.TraceEventScheduleStyleInvalidationTracking, modelData: TraceParseData): RootCauseRequest[];
+    /**
+     * Given a LayoutInvalidation trace event, determines if it was dispatched
+     * because fonts were changed and if so returns the information of all network
+     * request with which the fonts were possibly fetched, if any. The computed
+     * network requests are cached for the corresponding prepaint event, meaning
+     * that other LayoutInvalidation events that correspond to the same prepaint
+     * are not processed and the cached network requests for the prepaint is
+     * returned instead.
+     */
+    getFontChangeRootCause(layoutInvalidation: Types.TraceEvents.TraceEventLayoutInvalidationTracking | Types.TraceEvents.TraceEventScheduleStyleInvalidationTracking, nextPrePaint: Types.TraceEvents.TraceEventPrePaint, modelData: TraceParseData): FontChange[] | null;
+    /**
+     * Given the requests that arrived within a 500ms window before the layout invalidation, returns the font
+     * requests of them.
+     */
+    getFontRequestsInInvalidationWindow(requestsInInvalidationWindow: RootCauseRequest[]): FontChange[];
+    /**
+     * Given a LayoutInvalidation trace event, determines if it arrived within a 500ms window before the layout
+     * invalidation and if so returns the information of all network request, if any. The computed network
+     * requests are cached for the corresponding prepaint event, meaning that other LayoutInvalidation events
+     * that correspond to the same prepaint are not processed and the cached network requests for the prepaint is
+     *  returned instead.
+     */
+    getRenderBlockRootCause(layoutInvalidation: Types.TraceEvents.TraceEventLayoutInvalidationTracking | Types.TraceEvents.TraceEventScheduleStyleInvalidationTracking, nextPrePaint: Types.TraceEvents.TraceEventPrePaint, modelData: TraceParseData): RenderBlockingRequest[] | null;
+    /**
+     * Returns a function that retrieves the active value of a given
+     * CSS property within the matched styles of the param node.
+     * The first occurence within the matched styles is returned and the
+     * value is looked up in the following order, which follows CSS
+     * specificity:
+     * 1. Inline styles.
+     * 2. CSS rules matching this node, from all applicable stylesheets.
+     * 3. Attribute defined styles.
+     */
+    nodeMatchedStylesPropertyGetter(node: Protocol.DOM.Node): Promise<((property: string) => string | null)>;
+    /**
+     * Returns the CSS dimensions set to the node from its matched styles.
+     */
+    getNodeAuthoredDimensions(node: Protocol.DOM.Node): Promise<CSSDimensions>;
+}