chrome-devtools-mcp 1.1.1 → 1.3.0

package/build/src/third_party/devtools-heap-snapshot-worker.js

@@ -642,10 +642,14 @@ class Diff {
     removedCount = 0;
     addedSize = 0;
     removedSize = 0;
-    deletedIndexes = [];
-    addedIndexes = [];
     countDelta;
     sizeDelta;
+    addedIndexes = [];
+    addedIds = [];
+    addedSelfSizes = [];
+    deletedIndexes = [];
+    deletedIds = [];
+    deletedSelfSizes = [];
     constructor(name) {
         this.name = name;
     }
@@ -2840,9 +2844,9 @@ var ExperimentName;
     ExperimentName["ALL"] = "*";
     ExperimentName["PROTOCOL_MONITOR"] = "protocol-monitor";
     ExperimentName["INSTRUMENTATION_BREAKPOINTS"] = "instrumentation-breakpoints";
-    ExperimentName["USE_SOURCE_MAP_SCOPES"] = "use-source-map-scopes";
     ExperimentName["DURABLE_MESSAGES"] = "durable-messages";
     ExperimentName["JPEG_XL"] = "jpeg-xl";
+    ExperimentName["PLUS_BUTTON"] = "plus-button";
 })(ExperimentName || (ExperimentName = {}));
 
 // Copyright 2021 The Chromium Authors
@@ -5935,6 +5939,9 @@ class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     nodeClassKey(snapshotObjectId) {
         return this.callMethodPromise('nodeClassKey', snapshotObjectId);
     }
+    nodeIndexForId(nodeId) {
+        return this.callMethodPromise('nodeIndexForId', nodeId);
+    }
     createEdgesProvider(nodeIndex) {
         return this.callFactoryMethod('createEdgesProvider', HeapSnapshotProviderProxy, nodeIndex);
     }
@@ -5992,6 +5999,12 @@ class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     ignoreNodeInRetainersView(nodeIndex) {
         return this.callMethodPromise('ignoreNodeInRetainersView', nodeIndex);
     }
+    getRetainingPaths(nodeIndex, maxDepth, maxNodes, maxSiblings) {
+        return this.callMethodPromise('getRetainingPaths', nodeIndex, maxDepth, maxNodes, maxSiblings);
+    }
+    getDominatorsOf(nodeIndex) {
+        return this.callMethodPromise('getDominatorsOf', nodeIndex);
+    }
     unignoreNodeInRetainersView(nodeIndex) {
         return this.callMethodPromise('unignoreNodeInRetainersView', nodeIndex);
     }
@@ -7060,6 +7073,16 @@ class HeapSnapshot {
         }
         this.#progress.updateStatus('Finished processing.');
     }
+    nodeIndexForId(nodeId) {
+        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;
+    }
     startInitStep1InSecondThread(secondWorker) {
         const resultsFromSecondWorker = new Promise((resolve, reject) => {
             const listener = (e) => {
@@ -8283,6 +8306,8 @@ class HeapSnapshot {
             const nodeAId = baseIds[i];
             if (nodeAId < nodeB.id()) {
                 diff.deletedIndexes.push(baseIndexes[i]);
+                diff.deletedIds.push(nodeAId);
+                diff.deletedSelfSizes.push(baseSelfSizes[i]);
                 diff.removedCount++;
                 diff.removedSize += baseSelfSizes[i];
                 ++i;
@@ -8290,6 +8315,8 @@ class HeapSnapshot {
             else if (nodeAId >
                 nodeB.id()) {
                 diff.addedIndexes.push(indexes[j]);
+                diff.addedIds.push(nodeB.id());
+                diff.addedSelfSizes.push(nodeB.selfSize());
                 diff.addedCount++;
                 diff.addedSize += nodeB.selfSize();
                 nodeB.nodeIndex = indexes[++j];
@@ -8301,12 +8328,16 @@ class HeapSnapshot {
         }
         while (i < l) {
             diff.deletedIndexes.push(baseIndexes[i]);
+            diff.deletedIds.push(baseIds[i]);
+            diff.deletedSelfSizes.push(baseSelfSizes[i]);
             diff.removedCount++;
             diff.removedSize += baseSelfSizes[i];
             ++i;
         }
         while (j < m) {
             diff.addedIndexes.push(indexes[j]);
+            diff.addedIds.push(nodeB.id());
+            diff.addedSelfSizes.push(nodeB.selfSize());
             diff.addedCount++;
             diff.addedSize += nodeB.selfSize();
             nodeB.nodeIndex = indexes[++j];
@@ -8359,6 +8390,133 @@ class HeapSnapshot {
         const indexProvider = new HeapSnapshotRetainerEdgeIndexProvider(this);
         return new HeapSnapshotEdgesProvider(this, filter, node.retainers(), indexProvider);
     }
+    getRetainingPaths(nodeIndex, maxDepth = 30, maxNodes = 5000, maxSiblings = 100) {
+        const { nodeFieldCount, firstRetainerIndex, retainingNodes, retainingEdges, edgeTypeOffset, edgeWeakType, containmentEdges } = this;
+        const distances = this.#nodeDistancesForRetainersView ?? this.nodeDistances;
+        let traversedNodesCount = 0;
+        const visiting = new Set();
+        const visited = new Map();
+        const rootDistance = 2;
+        const limitsReached = {};
+        const buildForest = (currentIndex, currentDepth) => {
+            traversedNodesCount++;
+            if (traversedNodesCount > maxNodes) {
+                limitsReached.nodes = true;
+                return [];
+            }
+            if (currentDepth >= maxDepth) {
+                limitsReached.depth = true;
+                return [];
+            }
+            const ordinal = currentIndex / nodeFieldCount;
+            const currentDistance = distances[ordinal];
+            if (currentDistance <= rootDistance) {
+                return [];
+            }
+            if (visiting.has(currentIndex)) {
+                return [];
+            }
+            const cachedDepth = visited.get(currentIndex);
+            if (cachedDepth !== undefined) {
+                if (currentDepth >= cachedDepth) {
+                    return [];
+                }
+            }
+            visiting.add(currentIndex);
+            const beginRetainerIndex = firstRetainerIndex[ordinal];
+            const endRetainerIndex = firstRetainerIndex[ordinal + 1];
+            const retainers = [];
+            for (let retainerIndex = beginRetainerIndex; retainerIndex < endRetainerIndex; ++retainerIndex) {
+                const retainerNodeIndex = retainingNodes[retainerIndex];
+                const retainerNodeOrdinal = retainerNodeIndex / nodeFieldCount;
+                const dist = distances[retainerNodeOrdinal];
+                const globalEdgeIndex = retainingEdges[retainerIndex];
+                if (this.isEdgeIgnoredInRetainersView(globalEdgeIndex)) {
+                    continue;
+                }
+                const edgeType = containmentEdges.getValue(globalEdgeIndex + edgeTypeOffset);
+                if (edgeType === edgeWeakType) {
+                    continue;
+                }
+                if (dist >= 0) {
+                    const remainingDepth = maxDepth - currentDepth;
+                    const neededDepth = dist - rootDistance;
+                    if (neededDepth < remainingDepth) {
+                        retainers.push({ retainerIndex, dist, nodeIndex: retainerNodeIndex });
+                    }
+                    else {
+                        limitsReached.depth = true;
+                    }
+                }
+            }
+            retainers.sort((a, b) => a.dist - b.dist);
+            const length = Math.min(retainers.length, maxSiblings);
+            if (retainers.length > maxSiblings) {
+                limitsReached.siblings = true;
+            }
+            const forest = [];
+            for (let i = 0; i < length; i++) {
+                const retainer = retainers[i];
+                const edge = this.createRetainingEdge(retainer.retainerIndex);
+                const globalEdgeIndex = retainingEdges[retainer.retainerIndex];
+                const isRoot = retainer.dist === rootDistance;
+                let children = [];
+                if (isRoot) {
+                    traversedNodesCount++;
+                    if (traversedNodesCount > maxNodes) {
+                        limitsReached.nodes = true;
+                        break;
+                    }
+                }
+                else {
+                    children = buildForest(retainer.nodeIndex, currentDepth + 1);
+                    if (children.length === 0) {
+                        continue;
+                    }
+                }
+                const retainerNode = this.createNode(retainer.nodeIndex);
+                forest.push({
+                    edgeIndex: globalEdgeIndex,
+                    edgeName: edge.name(),
+                    edgeType: edge.type(),
+                    nodeId: retainerNode.id(),
+                    nodeIndex: retainer.nodeIndex,
+                    nodeName: retainerNode.name(),
+                    distance: retainer.dist,
+                    children,
+                });
+            }
+            visiting.delete(currentIndex);
+            visited.set(currentIndex, currentDepth);
+            return forest;
+        };
+        const paths = buildForest(nodeIndex, 0);
+        return { paths, limitsReached };
+    }
+    getDominatorsOf(nodeIndex) {
+        const chain = [];
+        let currentIndex = nodeIndex;
+        const rootIndex = this.rootNodeIndex;
+        while (currentIndex !== undefined) {
+            const node = this.createNode(currentIndex);
+            chain.push({
+                nodeId: node.id(),
+                nodeIndex: currentIndex,
+                nodeName: node.name(),
+                retainedSize: node.retainedSize(),
+                selfSize: node.selfSize(),
+            });
+            if (currentIndex === rootIndex) {
+                break;
+            }
+            const nextIndex = node.dominatorIndex();
+            if (nextIndex === currentIndex) {
+                break;
+            }
+            currentIndex = nextIndex;
+        }
+        return chain;
+    }
     createAddedNodesProvider(baseSnapshotId, classKey) {
         const snapshotDiff = this.#snapshotDiffs[baseSnapshotId];
         const diffForClass = snapshotDiff[classKey];