Fix private member access violations in profiler module

Source/devtools/front_end/profiler/heap_snapshot_worker/HeapSnapshot.js

 /*
  * Copyright (C) 2011 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 36 matching lines @@
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotItem}
  * @param {!WebInspector.HeapSnapshot} snapshot
  * @param {number=} edgeIndex
  */
 WebInspector.HeapSnapshotEdge = function(snapshot, edgeIndex)
 {
     this._snapshot = snapshot;
-    this._edges = snapshot._containmentEdges;
+    this._edges = snapshot.containmentEdges;
     this.edgeIndex = edgeIndex || 0;
 }
 
 WebInspector.HeapSnapshotEdge.prototype = {
     /**
      * @return {!WebInspector.HeapSnapshotEdge}
      */
     clone: function()
     {
         return new WebInspector.HeapSnapshotEdge(this._snapshot, this.edgeIndex);
@@ skipping 175 matching lines @@
 
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotItemIterator}
  * @param {!WebInspector.HeapSnapshotNode} node
  */
 WebInspector.HeapSnapshotEdgeIterator = function(node)
 {
     this._sourceNode = node;
-    this.edge = node._snapshot.createEdge(node._edgeIndexesStart());
+    this.edge = node._snapshot.createEdge(node.edgeIndexesStart());
 }
 
 WebInspector.HeapSnapshotEdgeIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
-        return this.edge.edgeIndex < this._sourceNode._edgeIndexesEnd();
+        return this.edge.edgeIndex < this._sourceNode.edgeIndexesEnd();
     },
 
     /**
      * @return {!WebInspector.HeapSnapshotEdge}
      */
     item: function()
     {
         return this.edge;
     },
 
@@ skipping 136 matching lines @@
 }
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotItemIterator}
  * @param {!WebInspector.HeapSnapshotNode} retainedNode
  */
 WebInspector.HeapSnapshotRetainerEdgeIterator = function(retainedNode)
 {
     var snapshot = retainedNode._snapshot;
-    var retainedNodeOrdinal = retainedNode._ordinal();
+    var retainedNodeOrdinal = retainedNode.ordinal();
     var retainerIndex = snapshot._firstRetainerIndex[retainedNodeOrdinal];
     this._retainersEnd = snapshot._firstRetainerIndex[retainedNodeOrdinal + 1];
     this.retainer = snapshot.createRetainingEdge(retainerIndex);
 }
 
 WebInspector.HeapSnapshotRetainerEdgeIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
@@ skipping 67 matching lines @@
     edges: function()
     {
         return new WebInspector.HeapSnapshotEdgeIterator(this);
     },
 
     /**
      * @return {number}
      */
     edgesCount: function()
     {
-        return (this._edgeIndexesEnd() - this._edgeIndexesStart()) / this._snapshot._edgeFieldsCount;
+        return (this.edgeIndexesEnd() - this.edgeIndexesStart()) / this._snapshot._edgeFieldsCount;
     },
 
     /**
      * @return {number}
      */
     id: function()
     {
         throw new Error("Not implemented");
     },
 
     /**
      * @return {boolean}
      */
     isRoot: function()
     {
         return this.nodeIndex === this._snapshot._rootNodeIndex;
     },
 
     /**
      * @return {string}
      */
     name: function()
     {
-        return this._snapshot._strings[this._name()];
+        return this._snapshot.strings[this._name()];
     },
 
     /**
      * @return {number}
      */
     retainedSize: function()
     {
-        return this._snapshot._retainedSizes[this._ordinal()];
+        return this._snapshot._retainedSizes[this.ordinal()];
     },
 
     /**
      * @return {!WebInspector.HeapSnapshotRetainerEdgeIterator}
      */
     retainers: function()
     {
         return new WebInspector.HeapSnapshotRetainerEdgeIterator(this);
     },
 
     /**
      * @return {number}
      */
     retainersCount: function()
     {
         var snapshot = this._snapshot;
-        var ordinal = this._ordinal();
+        var ordinal = this.ordinal();
         return snapshot._firstRetainerIndex[ordinal + 1] - snapshot._firstRetainerIndex[ordinal];
     },
 
     /**
      * @return {number}
      */
     selfSize: function()
     {
         var snapshot = this._snapshot;
-        return snapshot._nodes[this.nodeIndex + snapshot._nodeSelfSizeOffset];
+        return snapshot.nodes[this.nodeIndex + snapshot._nodeSelfSizeOffset];
     },
 
     /**
      * @return {string}
      */
     type: function()
     {
         return this._snapshot._nodeTypes[this._type()];
     },
 
     /**
      * @return {number}
      */
     traceNodeId: function()
     {
         var snapshot = this._snapshot;
-        return snapshot._nodes[this.nodeIndex + snapshot._nodeTraceNodeIdOffset];
+        return snapshot.nodes[this.nodeIndex + snapshot._nodeTraceNodeIdOffset];
     },
 
     /**
      * @override
      * @return {number}
      */
     itemIndex: function()
     {
         return this.nodeIndex;
     },
 
     /**
      * @override
      * @return {!WebInspector.HeapSnapshotCommon.Node}
      */
     serialize: function()
     {
         return new WebInspector.HeapSnapshotCommon.Node(this.id(), this.name(), this.distance(), this.nodeIndex, this.retainedSize(), this.selfSize(), this.type());
     },
 
     /**
      * @return {number}
      */
     _name: function()
     {
         var snapshot = this._snapshot;
-        return snapshot._nodes[this.nodeIndex + snapshot._nodeNameOffset];
+        return snapshot.nodes[this.nodeIndex + snapshot._nodeNameOffset];
     },
 
     /**
      * @return {number}
      */
-    _edgeIndexesStart: function()
+    edgeIndexesStart: function()
     {
-        return this._snapshot._firstEdgeIndexes[this._ordinal()];
+        return this._snapshot._firstEdgeIndexes[this.ordinal()];
     },
 
     /**
      * @return {number}
      */
-    _edgeIndexesEnd: function()
+    edgeIndexesEnd: function()
     {
-        return this._snapshot._firstEdgeIndexes[this._ordinal() + 1];
+        return this._snapshot._firstEdgeIndexes[this.ordinal() + 1];
     },
 
     /**
      * @return {number}
      */
-    _ordinal: function()
+    ordinal: function()
     {
         return this.nodeIndex / this._snapshot._nodeFieldCount;
     },
 
     /**
      * @return {number}
      */
     _nextNodeIndex: function()
     {
         return this.nodeIndex + this._snapshot._nodeFieldCount;
     },
 
     /**
      * @return {number}
      */
     _type: function()
     {
         var snapshot = this._snapshot;
-        return snapshot._nodes[this.nodeIndex + snapshot._nodeTypeOffset];
+        return snapshot.nodes[this.nodeIndex + snapshot._nodeTypeOffset];
     }
 };
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotItemIterator}
  * @param {!WebInspector.HeapSnapshotNode} node
  */
 WebInspector.HeapSnapshotNodeIterator = function(node)
 {
     this.node = node;
-    this._nodesLength = node._snapshot._nodes.length;
+    this._nodesLength = node._snapshot.nodes.length;
 }
 
 WebInspector.HeapSnapshotNodeIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
         return this.node.nodeIndex < this._nodesLength;
     },
@@ skipping 137 matching lines @@
 }
 
 
 /**
  * @param {!Object} profile
  * @param {!WebInspector.HeapSnapshotProgress} progress
  * @constructor
  */
 WebInspector.HeapSnapshot = function(profile, progress)
 {
-    this._nodes = profile.nodes;
-    this._containmentEdges = profile.edges;
+    /** @type {!Uint32Array} */
+    this.nodes = profile.nodes;
+    /** @type {!Uint32Array} */
+    this.containmentEdges = profile.edges;
     /** @type {!HeapSnapshotMetainfo} */
     this._metaNode = profile.snapshot.meta;
-    this._strings = profile.strings;
+    /** @type {!Array.<string>} */
+    this.strings = profile.strings;
     this._progress = progress;
 
     this._noDistance = -5;
     this._rootNodeIndex = 0;
     if (profile.snapshot.root_index)
         this._rootNodeIndex = profile.snapshot.root_index;
 
     this._snapshotDiffs = {};
     this._aggregatesForDiff = null;
     this._aggregates = {};
     this._aggregatesSortedFlags = {};
 
     this._init();
 
     if (profile.snapshot.trace_function_count) {
         this._progress.updateStatus("Buiding allocation statistics\u2026");
-        var nodes = this._nodes;
+        var nodes = this.nodes;
         var nodesLength = nodes.length;
         var nodeFieldCount = this._nodeFieldCount;
         var node = this.rootNode();
         var liveObjects = {};
         for (var nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
             node.nodeIndex = nodeIndex;
             var traceNodeId = node.traceNodeId();
             var stats = liveObjects[traceNodeId];
             if (!stats) {
                 liveObjects[traceNodeId] = stats = { count: 0, size: 0, ids: []};
@@ skipping 63 matching lines @@
 
         this._edgeTypes = meta.edge_types[this._edgeTypeOffset];
         this._edgeTypes.push("invisible");
         this._edgeElementType = this._edgeTypes.indexOf("element");
         this._edgeHiddenType = this._edgeTypes.indexOf("hidden");
         this._edgeInternalType = this._edgeTypes.indexOf("internal");
         this._edgeShortcutType = this._edgeTypes.indexOf("shortcut");
         this._edgeWeakType = this._edgeTypes.indexOf("weak");
         this._edgeInvisibleType = this._edgeTypes.indexOf("invisible");
 
-        this.nodeCount = this._nodes.length / this._nodeFieldCount;
-        this._edgeCount = this._containmentEdges.length / this._edgeFieldsCount;
+        this.nodeCount = this.nodes.length / this._nodeFieldCount;
+        this._edgeCount = this.containmentEdges.length / this._edgeFieldsCount;
 
         this._progress.updateStatus("Building edge indexes\u2026");
         this._buildEdgeIndexes();
         this._progress.updateStatus("Building retainers\u2026");
         this._buildRetainers();
         this._progress.updateStatus("Calculating node flags\u2026");
         this._calculateFlags();
         this._progress.updateStatus("Calculating distances\u2026");
         this._calculateDistances();
         this._progress.updateStatus("Building postorder index\u2026");
         var result = this._buildPostOrderIndex();
         // Actually it is array that maps node ordinal number to dominator node ordinal number.
         this._progress.updateStatus("Building dominator tree\u2026");
         this._dominatorsTree = this._buildDominatorTree(result.postOrderIndex2NodeOrdinal, result.nodeOrdinal2PostOrderIndex);
         this._progress.updateStatus("Calculating retained sizes\u2026");
         this._calculateRetainedSizes(result.postOrderIndex2NodeOrdinal);
         this._progress.updateStatus("Buiding dominated nodes\u2026");
         this._buildDominatedNodes();
         this._progress.updateStatus("Calculating statistics\u2026");
         this._calculateStatistics();
         this._progress.updateStatus("Finished processing.");
     },
 
     _buildEdgeIndexes: function()
     {
-        var nodes = this._nodes;
+        var nodes = this.nodes;
         var nodeCount = this.nodeCount;
         var firstEdgeIndexes = this._firstEdgeIndexes = new Uint32Array(nodeCount + 1);
         var nodeFieldCount = this._nodeFieldCount;
         var edgeFieldsCount = this._edgeFieldsCount;
         var nodeEdgeCountOffset = this._nodeEdgeCountOffset;
-        firstEdgeIndexes[nodeCount] = this._containmentEdges.length;
+        firstEdgeIndexes[nodeCount] = this.containmentEdges.length;
         for (var nodeOrdinal = 0, edgeIndex = 0; nodeOrdinal < nodeCount; ++nodeOrdinal) {
             firstEdgeIndexes[nodeOrdinal] = edgeIndex;
             edgeIndex += nodes[nodeOrdinal * nodeFieldCount + nodeEdgeCountOffset] * edgeFieldsCount;
         }
     },
 
     _buildRetainers: function()
     {
         var retainingNodes = this._retainingNodes = new Uint32Array(this._edgeCount);
         var retainingEdges = this._retainingEdges = new Uint32Array(this._edgeCount);
         // Index of the first retainer in the _retainingNodes and _retainingEdges
         // arrays. Addressed by retained node index.
         var firstRetainerIndex = this._firstRetainerIndex = new Uint32Array(this.nodeCount + 1);
 
-        var containmentEdges = this._containmentEdges;
+        var containmentEdges = this.containmentEdges;
         var edgeFieldsCount = this._edgeFieldsCount;
         var nodeFieldCount = this._nodeFieldCount;
         var edgeToNodeOffset = this._edgeToNodeOffset;
         var firstEdgeIndexes = this._firstEdgeIndexes;
         var nodeCount = this.nodeCount;
 
         for (var toNodeFieldIndex = edgeToNodeOffset, l = containmentEdges.length; toNodeFieldIndex < l; toNodeFieldIndex += edgeFieldsCount) {
             var toNodeIndex = containmentEdges[toNodeFieldIndex];
             if (toNodeIndex % nodeFieldCount)
                 throw new Error("Invalid toNodeIndex " + toNodeIndex);
@@ skipping 264 matching lines @@
 
         var nodesToVisit = new Uint32Array(this.nodeCount);
         var nodesToVisitLength = 0;
 
         /**
          * @param {number} distance
          * @param {!WebInspector.HeapSnapshotNode} node
          */
         function enqueueNode(distance, node)
         {
-            var ordinal = node._ordinal();
+            var ordinal = node.ordinal();
             if (distances[ordinal] !== noDistance)
                 return;
             distances[ordinal] = distance;
             nodesToVisit[nodesToVisitLength++] = node.nodeIndex;
         }
 
         this.forEachRoot(enqueueNode.bind(null, 1), true);
         this._bfs(nodesToVisit, nodesToVisitLength, distances);
 
         // bfs for the rest of objects
         nodesToVisitLength = 0;
         this.forEachRoot(enqueueNode.bind(null, WebInspector.HeapSnapshotCommon.baseSystemDistance), false);
         this._bfs(nodesToVisit, nodesToVisitLength, distances);
     },
 
     /**
      * @param {!Uint32Array} nodesToVisit
      * @param {!number} nodesToVisitLength
      * @param {!Int32Array} distances
      */
     _bfs: function(nodesToVisit, nodesToVisitLength, distances)
     {
         // Preload fields into local variables for better performance.
         var edgeFieldsCount = this._edgeFieldsCount;
         var nodeFieldCount = this._nodeFieldCount;
-        var containmentEdges = this._containmentEdges;
+        var containmentEdges = this.containmentEdges;
         var firstEdgeIndexes = this._firstEdgeIndexes;
         var edgeToNodeOffset = this._edgeToNodeOffset;
         var edgeTypeOffset = this._edgeTypeOffset;
         var nodeCount = this.nodeCount;
         var containmentEdgesLength = containmentEdges.length;
         var edgeWeakType = this._edgeWeakType;
         var noDistance = this._noDistance;
 
         var index = 0;
         while (index < nodesToVisitLength) {
@@ skipping 16 matching lines @@
         }
         if (nodesToVisitLength > nodeCount)
             throw new Error("BFS failed. Nodes to visit (" + nodesToVisitLength + ") is more than nodes count (" + nodeCount + ")");
     },
 
     _buildAggregates: function(filter)
     {
         var aggregates = {};
         var aggregatesByClassName = {};
         var classIndexes = [];
-        var nodes = this._nodes;
+        var nodes = this.nodes;
         var mapAndFlag = this.userObjectsMapAndFlag();
         var flags = mapAndFlag ? mapAndFlag.map : null;
         var flag = mapAndFlag ? mapAndFlag.flag : 0;
         var nodesLength = nodes.length;
         var nodeNativeType = this._nodeNativeType;
         var nodeFieldCount = this._nodeFieldCount;
         var selfSizeOffset = this._nodeSelfSizeOffset;
         var nodeTypeOffset = this._nodeTypeOffset;
         var node = this.rootNode();
         var nodeDistances = this._nodeDistances;
@@ skipping 46 matching lines @@
         var rootNodeIndex = this._rootNodeIndex;
         var node = this.createNode(rootNodeIndex);
         var list = [rootNodeIndex];
         var sizes = [-1];
         var classes = [];
         var seenClassNameIndexes = {};
         var nodeFieldCount = this._nodeFieldCount;
         var nodeTypeOffset = this._nodeTypeOffset;
         var nodeNativeType = this._nodeNativeType;
         var dominatedNodes = this._dominatedNodes;
-        var nodes = this._nodes;
+        var nodes = this.nodes;
         var mapAndFlag = this.userObjectsMapAndFlag();
         var flags = mapAndFlag ? mapAndFlag.map : null;
         var flag = mapAndFlag ? mapAndFlag.flag : 0;
         var firstDominatedNodeIndex = this._firstDominatedNodeIndex;
 
         while (list.length) {
             var nodeIndex = list.pop();
             node.nodeIndex = nodeIndex;
             var classIndex = node.classIndex();
             var seen = !!seenClassNameIndexes[classIndex];
@@ skipping 34 matching lines @@
                 function(idxA, idxB) {
                     nodeA.nodeIndex = idxA;
                     nodeB.nodeIndex = idxB;
                     return nodeA.id() < nodeB.id() ? -1 : 1;
                 });
     },
 
     _buildPostOrderIndex: function()
     {
         var nodeFieldCount = this._nodeFieldCount;
-        var nodes = this._nodes;
+        var nodes = this.nodes;
         var nodeCount = this.nodeCount;
         var rootNodeOrdinal = this._rootNodeIndex / nodeFieldCount;
 
         var edgeFieldsCount = this._edgeFieldsCount;
         var edgeTypeOffset = this._edgeTypeOffset;
         var edgeToNodeOffset = this._edgeToNodeOffset;
         var edgeShortcutType = this._edgeShortcutType;
         var firstEdgeIndexes = this._firstEdgeIndexes;
-        var containmentEdges = this._containmentEdges;
+        var containmentEdges = this.containmentEdges;
 
         var mapAndFlag = this.userObjectsMapAndFlag();
         var flags = mapAndFlag ? mapAndFlag.map : null;
         var flag = mapAndFlag ? mapAndFlag.flag : 0;
 
         var stackNodes = new Uint32Array(nodeCount);
         var stackCurrentEdge = new Uint32Array(nodeCount);
         var postOrderIndex2NodeOrdinal = new Uint32Array(nodeCount);
         var nodeOrdinal2PostOrderIndex = new Uint32Array(nodeCount);
         var visited = new Uint8Array(nodeCount);
@@ skipping 57 matching lines @@
     // The algorithm is based on the article:
     // K. Cooper, T. Harvey and K. Kennedy "A Simple, Fast Dominance Algorithm"
     // Softw. Pract. Exper. 4 (2001), pp. 1-10.
     /**
      * @param {!Array.<number>} postOrderIndex2NodeOrdinal
      * @param {!Array.<number>} nodeOrdinal2PostOrderIndex
      */
     _buildDominatorTree: function(postOrderIndex2NodeOrdinal, nodeOrdinal2PostOrderIndex)
     {
         var nodeFieldCount = this._nodeFieldCount;
-        var nodes = this._nodes;
+        var nodes = this.nodes;
         var firstRetainerIndex = this._firstRetainerIndex;
         var retainingNodes = this._retainingNodes;
         var retainingEdges = this._retainingEdges;
         var edgeFieldsCount = this._edgeFieldsCount;
         var edgeTypeOffset = this._edgeTypeOffset;
         var edgeToNodeOffset = this._edgeToNodeOffset;
         var edgeShortcutType = this._edgeShortcutType;
         var firstEdgeIndexes = this._firstEdgeIndexes;
-        var containmentEdges = this._containmentEdges;
-        var containmentEdgesLength = this._containmentEdges.length;
+        var containmentEdges = this.containmentEdges;
+        var containmentEdgesLength = this.containmentEdges.length;
         var rootNodeIndex = this._rootNodeIndex;
 
         var mapAndFlag = this.userObjectsMapAndFlag();
         var flags = mapAndFlag ? mapAndFlag.map : null;
         var flag = mapAndFlag ? mapAndFlag.flag : 0;
 
         var nodesCount = postOrderIndex2NodeOrdinal.length;
         var rootPostOrderedIndex = nodesCount - 1;
         var noEntry = nodesCount;
         var dominators = new Uint32Array(nodesCount);
@@ skipping 84 matching lines @@
         for (var postOrderIndex = 0, l = dominators.length; postOrderIndex < l; ++postOrderIndex) {
             nodeOrdinal = postOrderIndex2NodeOrdinal[postOrderIndex];
             dominatorsTree[nodeOrdinal] = postOrderIndex2NodeOrdinal[dominators[postOrderIndex]];
         }
         return dominatorsTree;
     },
 
     _calculateRetainedSizes: function(postOrderIndex2NodeOrdinal)
     {
         var nodeCount = this.nodeCount;
-        var nodes = this._nodes;
+        var nodes = this.nodes;
         var nodeSelfSizeOffset = this._nodeSelfSizeOffset;
         var nodeFieldCount = this._nodeFieldCount;
         var dominatorsTree = this._dominatorsTree;
         var retainedSizes = this._retainedSizes = new Float64Array(nodeCount);
 
         for (var nodeOrdinal = 0; nodeOrdinal < nodeCount; ++nodeOrdinal)
             retainedSizes[nodeOrdinal] = nodes[nodeOrdinal * nodeFieldCount + nodeSelfSizeOffset];
 
         // Propagate retained sizes for each node excluding root.
         for (var postOrderIndex = 0; postOrderIndex < nodeCount - 1; ++postOrderIndex) {
@@ skipping 273 matching lines @@
     {
         return new WebInspector.HeapSnapshotNodesProvider(this, this.classNodesFilter(), this.aggregatesWithFilter(nodeFilter)[className].idxs);
     },
 
     /**
      * @return {number}
      */
     _maxJsNodeId: function()
     {
         var nodeFieldCount = this._nodeFieldCount;
-        var nodes = this._nodes;
+        var nodes = this.nodes;
         var nodesLength = nodes.length;
         var id = 0;
         for (var nodeIndex = this._nodeIdOffset; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
             var nextId = nodes[nodeIndex];
             // JS objects have odd ids, skip native objects.
             if (nextId % 2 === 0)
                 continue;
             if (id < nextId)
                 id = nextId;
         }
@@ skipping 278 matching lines @@
      * @param {number} windowRight
      */
     sort: function(comparator, leftBound, rightBound, windowLeft, windowRight)
     {
         this._iterationOrder.sortRange(this._buildCompareFunction(comparator), leftBound, rightBound, windowLeft, windowRight);
     },
 
     __proto__: WebInspector.HeapSnapshotItemProvider.prototype
 }