Show live objects with given allocation call stack

Source/devtools/front_end/AllocationProfile.js

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 133 matching lines @@
         });
         return result;
     },
 
     /**
      * @param {string} nodeId
      * @return {!WebInspector.HeapSnapshotCommon.AllocationNodeCallers}
      */
     serializeCallers: function(nodeId)
     {
-        var node = this._idToNode[nodeId];
-        if (!node) {
-            var functionInfo = this._collapsedTopNodeIdToFunctionInfo[nodeId];
-            node = functionInfo.bottomUpRoot();
-            delete this._collapsedTopNodeIdToFunctionInfo[nodeId];
-            this._idToNode[nodeId] = node;
-        }
-
+        var node = this._ensureBottomUpNode(nodeId);
         var nodesWithSingleCaller = [];
         while (node.callers().length === 1) {
             node = node.callers()[0];
             nodesWithSingleCaller.push(this._serializeCaller(node));
         }
 
         var branchingCallers = [];
         var callers = node.callers();
         for (var i = 0; i < callers.length; i++) {
             branchingCallers.push(this._serializeCaller(callers[i]));
         }
         return new WebInspector.HeapSnapshotCommon.AllocationNodeCallers(nodesWithSingleCaller, branchingCallers);
     },
 
+    /**
+     * @param {number} allocationNodeId
+     * @return {!Array.<number>}
+     */
+    traceIds: function(allocationNodeId)
+    {
+        return this._ensureBottomUpNode(allocationNodeId).traceTopIds;
+    },
+
+    _ensureBottomUpNode: function(nodeId)

[alph, 2014/03/18 12:28:22]

annotate?

[yurys, 2014/03/18 12:30:47]

Done.

+    {
+        var node = this._idToNode[nodeId];
+        if (!node) {
+            var functionInfo = this._collapsedTopNodeIdToFunctionInfo[nodeId];
+            node = functionInfo.bottomUpRoot();
+            delete this._collapsedTopNodeIdToFunctionInfo[nodeId];
+            this._idToNode[nodeId] = node;
+        }
+        return node;
+    },
+
     _serializeCaller: function(node)
     {
         var callerId = this._nextNodeId++;
         this._idToNode[callerId] = node;
         return this._serializeNode(
             callerId,
             node.functionInfo,
             node.allocationCount,
             node.allocationSize,
             node.liveCount,
@@ skipping 56 matching lines @@
  * @constructor
  * @param {!WebInspector.FunctionAllocationInfo} functionInfo
  */
 WebInspector.BottomUpAllocationNode = function(functionInfo)
 {
     this.functionInfo = functionInfo;
     this.allocationCount = 0;
     this.allocationSize = 0;
     this.liveCount = 0;
     this.liveSize = 0;
+    this.traceTopIds = [];
     this._callers = [];
 }
 
 
 WebInspector.BottomUpAllocationNode.prototype = {
     /**
      * @param {!WebInspector.TopDownAllocationNode} traceNode
-     * @return {!WebInspector.TopDownAllocationNode}
+     * @return {!WebInspector.BottomUpAllocationNode}
      */
     addCaller: function(traceNode)
     {
         var functionInfo = traceNode.functionInfo;
         var result;
         for (var i = 0; i < this._callers.length; i++) {
             var caller = this._callers[i];
             if (caller.functionInfo === functionInfo) {
                 result = caller;
                 break;
@@ skipping 77 matching lines @@
     {
         this._bottomUpTree = new WebInspector.BottomUpAllocationNode(this);
 
         for (var i = 0; i < this._traceTops.length; i++) {
             var node = this._traceTops[i];
             var bottomUpNode = this._bottomUpTree;
             var count = node.allocationCount;
             var size = node.allocationSize;
             var liveCount = node.liveCount;
             var liveSize = node.liveSize;
+            var traceId = node.id;
             while (true) {
                 bottomUpNode.allocationCount += count;
                 bottomUpNode.allocationSize += size;
                 bottomUpNode.liveCount += liveCount;
                 bottomUpNode.liveSize += liveSize;
+                bottomUpNode.traceTopIds.push(traceId);
                 node = node.parent;
                 if (node === null) {
                     break;
                 }
                 bottomUpNode = bottomUpNode.addCaller(node);
             }
         }
     }
 }