[stack_trace] Implement insertion into fragment trie

[email protected]

Bug: 433162438
Change-Id: I8b292f6ac1a3d71f49aabdd8ed34a347c202263c
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6839778
Reviewed-by: Philip Pfaffe <[email protected]>
Commit-Queue: Simon Zünd <[email protected]>

Author: szuend

front_end/models/stack_trace/BUILD.gn

@@ -55,5 +55,6 @@ ts_library("unittests") {
   deps = [
     ":bundle",
     ":impl",
+    "../../testing",
   ]
 }

front_end/models/stack_trace/Trie.test.ts

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import {protocolCallFrame} from '../../testing/StackTraceHelpers.js';
+
 import * as StackTraceImpl from './stack_trace_impl.js';
 
 describe('Trie', () => {
@@ -11,5 +13,47 @@ describe('Trie', () => {
 
       assert.throws(() => trie.insert([]));
     });
+
+    it('returns the same node when inserting the same frame twice', () => {
+      const trie = new StackTraceImpl.Trie.Trie();
+      const frame = protocolCallFrame('foo.js:1:foo:1:10');
+
+      const node1 = trie.insert([frame]);
+      const node2 = trie.insert([frame]);
+
+      assert.strictEqual(node1, node2);
+      assert.strictEqual(StackTraceImpl.Trie.compareRawFrames(frame, node1.rawFrame), 0);
+    });
+
+    it('returns different nodes when inserting different frames', () => {
+      const trie = new StackTraceImpl.Trie.Trie();
+      const frame1 = protocolCallFrame('foo.js:1:foo:1:10');
+      const frame2 = protocolCallFrame('foo.js:1:bar:2:20');
+
+      const node1 = trie.insert([frame1]);
+      const node2 = trie.insert([frame2]);
+
+      assert.notStrictEqual(node1, node2);
+      assert.strictEqual(StackTraceImpl.Trie.compareRawFrames(frame1, node1.rawFrame), 0);
+      assert.strictEqual(StackTraceImpl.Trie.compareRawFrames(frame2, node2.rawFrame), 0);
+    });
+
+    it('creates 3 nodes for 2 stack traces with 1 shared parent call frame', () => {
+      const trie = new StackTraceImpl.Trie.Trie();
+
+      const node1 = trie.insert([
+        'foo.js::x:1:10',
+        'foo.js::y:2:20',
+      ].map(protocolCallFrame));
+      const node2 = trie.insert([
+        'foo.js::x:1:15',
+        'foo.js::y:2:20',
+      ].map(protocolCallFrame));
+
+      assert.strictEqual(node1.rawFrame.columnNumber, 10);
+      assert.strictEqual(node2.rawFrame.columnNumber, 15);
+
+      assert.strictEqual(node1.parent, node2.parent);
+    });
   });
 });

front_end/models/stack_trace/Trie.ts

@@ -34,15 +34,85 @@ export interface FrameNode extends FrameNodeBase<FrameNode, AnyFrameNode> {
  * Stores stack trace fragments in a trie, but does not own them/keep them alive.
  */
 export class Trie {
-  // eslint-disable-next-line no-unused-private-class-members
   readonly #root: RootFrameNode = {parent: null, children: []};
 
+  /**
+   * Most sources produce stack traces in "top-to-bottom" order, so that is what this method expects.
+   *
+   * @returns The {@link FrameNode} corresponding to the top-most stack frame.
+   */
   insert(frames: RawFrame[]): FrameNode {
     if (frames.length === 0) {
       throw new Error('Trie.insert called with an empty frames array.');
     }
 
-    // TODO(crbug.com/433162438): Implement it.
-    throw new Error('Not implemented');
+    let currentNode: AnyFrameNode = this.#root;
+    for (let i = frames.length - 1; i >= 0; --i) {
+      currentNode = this.#insert(currentNode, frames[i]);
+    }
+    return currentNode as FrameNode;
+  }
+
+  /**
+   * Inserts `rawFrame` into the children of the provided node if not already there.
+   *
+   * @returns the child node corresponding to `rawFrame`.
+   */
+  #insert(node: AnyFrameNode, rawFrame: RawFrame): FrameNode {
+    let i = 0;
+    for (; i < node.children.length; ++i) {
+      const maybeChild = node.children[i];
+      const child = maybeChild instanceof WeakRef ? maybeChild.deref() : maybeChild;
+      if (!child) {
+        continue;
+      }
+
+      const compareResult = compareRawFrames(child.rawFrame, rawFrame);
+      if (compareResult === 0) {
+        return child;
+      }
+      if (compareResult > 0) {
+        break;
+      }
+    }
+
+    const newNode: FrameNode = {
+      parent: node,
+      children: [],
+      rawFrame,
+      frames: [],
+    };
+    if (node.parent) {
+      node.children.splice(i, 0, newNode);
+    } else {
+      node.children.splice(i, 0, new WeakRef(newNode));
+    }
+    return newNode;
   }
 }
+
+/**
+ * @returns a number < 0, 0 or > 0, if the `a` is smaller then, equal or greater then `b`.
+ */
+export function compareRawFrames(a: RawFrame, b: RawFrame): number {
+  const scriptIdCompare = (a.scriptId ?? '').localeCompare(b.scriptId ?? '');
+  if (scriptIdCompare !== 0) {
+    return scriptIdCompare;
+  }
+
+  const urlCompare = (a.url ?? '').localeCompare(b.url ?? '');
+  if (urlCompare !== 0) {
+    return urlCompare;
+  }
+
+  const nameCompare = (a.functionName ?? '').localeCompare(b.functionName ?? '');
+  if (nameCompare !== 0) {
+    return nameCompare;
+  }
+
+  if (a.lineNumber !== b.lineNumber) {
+    return a.lineNumber - b.lineNumber;
+  }
+
+  return a.columnNumber - b.columnNumber;
+}

front_end/testing/BUILD.gn

@@ -41,6 +41,7 @@ ts_library("testing") {
     "SourceMapEncoder.test.ts",
     "SourceMapEncoder.ts",
     "SourceMapHelpers.ts",
+    "StackTraceHelpers.ts",
     "StorageItemsViewHelpers.ts",
     "StubIssue.ts",
     "StyleHelpers.ts",

front_end/testing/StackTraceHelpers.ts

@@ -0,0 +1,19 @@
+// Copyright 2025 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 type * as Protocol from '../generated/protocol.js';
+
+/**
+ * Easily create `Protocol.Runtime.CallFrame`s by passing a string of the format: `<url>:<scriptId>:<name>:<line>:<column>`
+ */
+export function protocolCallFrame(descriptor: string): Protocol.Runtime.CallFrame {
+  const parts = descriptor.split(':', 5);
+  return {
+    url: parts[0],
+    scriptId: parts[1] as Protocol.Runtime.ScriptId,
+    functionName: parts[2],
+    lineNumber: parts[3] ? Number.parseInt(parts[3], 10) : -1,
+    columnNumber: parts[4] ? Number.parseInt(parts[4], 10) : -1,
+  };
+}