Add nodeIndexForId to HeapSnapshotProxy

The MCP server needs to look up the node index for an object id.
Currently this reuses the getAggregates() call, which iterates
through the objects on the main isolate.

This CL adds a new method nodeIndexForId() such that this work can
be performed on the worker isolate. This should avoid any
serialization except for the final node index result value.

There may even be cases where getAggregates() does not find the
given object id because e.g. objects with self_size == 0 do not show
up in the summary view.

Bug: 497855658
Change-Id: I78396a269bf285b5dbb76b3e9405b56f73e1b61a
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/7899812
Commit-Queue: Dominik Inführ <dinfuehr@chromium.org>
Reviewed-by: Nikolay Vitkov <nvitkov@chromium.org>
Reviewed-by: Simon Zünd <szuend@chromium.org>

Author: Dominik Inführ

front_end/entrypoints/heap_snapshot_worker/HeapSnapshot.test.ts

@@ -1027,4 +1027,32 @@ describe('HeapSnapshot', () => {
 
     assert.strictEqual(JSON.stringify(referenceToCompare), JSON.stringify(resultToCompare));
   });
+
+  it('heapSnapshotNodeIndexForId', async () => {
+    const builder = new HeapSnapshotBuilder();
+    const root = builder.rootNode;
+
+    const zeroSizeNode = new HeapNode('ZeroSizeNode', 0, 'object', 42);
+    root.linkNode(zeroSizeNode, 'element');
+
+    const normalNode = new HeapNode('NormalNode', 100, 'object', 99);
+    root.linkNode(normalNode, 'element');
+
+    const snapshot = await builder.createJSHeapSnapshot();
+
+    const zeroSizeIndex = snapshot.nodeIndexForId(42);
+    assert.isDefined(zeroSizeIndex);
+    const resolvedZeroSizeNode = snapshot.createNode(zeroSizeIndex!);
+    assert.strictEqual(resolvedZeroSizeNode.name(), 'ZeroSizeNode');
+    assert.strictEqual(resolvedZeroSizeNode.id(), 42);
+
+    const normalIndex = snapshot.nodeIndexForId(99);
+    assert.isDefined(normalIndex);
+    const resolvedNormalNode = snapshot.createNode(normalIndex!);
+    assert.strictEqual(resolvedNormalNode.name(), 'NormalNode');
+    assert.strictEqual(resolvedNormalNode.id(), 99);
+
+    const nonExistentIndex = snapshot.nodeIndexForId(999);
+    assert.isUndefined(nonExistentIndex);
+  });
 });

front_end/entrypoints/heap_snapshot_worker/HeapSnapshot.ts

@@ -1068,6 +1068,17 @@ export abstract class HeapSnapshot {
     this.#progress.updateStatus('Finished processing.');
   }
 
+  nodeIndexForId(nodeId: number): number|undefined {
+    const nodesLength = this.nodes.length;
+    const {nodes, nodeFieldCount, nodeIdOffset} = this;
+    for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
+      if (nodes.getValue(nodeIndex + nodeIdOffset) === nodeId) {
+        return nodeIndex;
+      }
+    }
+    return undefined;
+  }
+
   private startInitStep1InSecondThread(secondWorker: PlatformApi.HostRuntime.WorkerMessagePort):
       Promise<ResultsFromSecondWorker> {
     const resultsFromSecondWorker = new Promise<ResultsFromSecondWorker>((resolve, reject) => {

front_end/models/heap_snapshot/HeapSnapshotProxy.ts

@@ -289,6 +289,10 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callMethodPromise('nodeClassKey', snapshotObjectId);
   }
 
+  nodeIndexForId(nodeId: number): Promise<number|undefined> {
+    return this.callMethodPromise('nodeIndexForId', nodeId);
+  }
+
   createEdgesProvider(nodeIndex: number): HeapSnapshotProviderProxy {
     return this.callFactoryMethod('createEdgesProvider', HeapSnapshotProviderProxy, nodeIndex);
   }