Revert of Remove WebInspector.HeapSnapshotArraySlice

Source/devtools/front_end/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 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @constructor
- * @param {!WebInspector.HeapSnapshot} snapshot
- * @param {!Uint32Array} edges
+ * @param {!Uint32Array} array
+ * @param {number} start
+ * @param {number} end
+ */
+WebInspector.HeapSnapshotArraySlice = function(array, start, end)
+{
+    this._array = array;
+    this._start = start;
+    this.length = end - start;
+}
+
+WebInspector.HeapSnapshotArraySlice.prototype = {
+    /**
+     * @param {number} index
+     * @return {number}
+     */
+    item: function(index)
+    {
+        return this._array[this._start + index];
+    },
+
+    /**
+     * @param {number} start
+     * @param {number=} end
+     * @return {!Uint32Array}
+     */
+    slice: function(start, end)
+    {
+        if (typeof end === "undefined")
+            end = this.length;
+        return this._array.subarray(this._start + start, this._start + end);
+    }
+}
+
+/**
+ * @constructor
  * @param {number=} edgeIndex
  */
 WebInspector.HeapSnapshotEdge = function(snapshot, edges, edgeIndex)
 {
     this._snapshot = snapshot;
     this._edges = edges;
     this.edgeIndex = edgeIndex || 0;
 }
 
 /**
@@ skipping 43 matching lines @@
     node: function()
     {
         return this._snapshot.createNode(this.nodeIndex());
     },
 
     /**
      * @return {number}
      */
     nodeIndex: function()
     {
-        return this._edges[this.edgeIndex + this._snapshot._edgeToNodeOffset];
+        return this._edges.item(this.edgeIndex + this._snapshot._edgeToNodeOffset);
     },
 
     /**
+     * @return {!Array.<number>}
+     */
+    rawEdges: function()
+    {
+        return this._edges;
+    },
+
+    /**
      * @return {string}
      */
     toString: function()
     {
         return "HeapSnapshotEdge: " + this.name();
     },
 
     /**
      * @return {string}
      */
     type: function()
     {
         return this._snapshot._edgeTypes[this._type()];
     },
 
     /**
      * @return {!WebInspector.HeapSnapshotEdge.Serialized}
      */
     serialize: function()
     {
         var node = this.node();
         return new WebInspector.HeapSnapshotEdge.Serialized(this.name(), node.serialize(), this.nodeIndex(), this.type(), node.distance());
     },
 
     _type: function()
     {
-        return this._edges[this.edgeIndex + this._snapshot._edgeTypeOffset];
+        return this._edges.item(this.edgeIndex + this._snapshot._edgeTypeOffset);
     }
 };
 
 /**
  * @constructor
  */
 WebInspector.HeapSnapshotEdgeIterator = function(edge)
 {
     this.edge = edge;
 }
@@ skipping 335 matching lines @@
 
     /**
      * @return {string}
      */
     name: function()
     {
         return this._snapshot._strings[this._name()];
     },
 
     /**
-     * @return {!Uint32Array}
+     * @return {!WebInspector.HeapSnapshotArraySlice}
      */
     rawEdges: function()
     {
-        return this._snapshot._containmentEdges.subarray(this._edgeIndexesStart(), this._edgeIndexesEnd());
+        return new WebInspector.HeapSnapshotArraySlice(this._snapshot._containmentEdges, this._edgeIndexesStart(), this._edgeIndexesEnd());
     },
 
     /**
      * @return {number}
      */
     retainedSize: function()
     {
         return this._snapshot._retainedSizes[this._ordinal()];
     },
 
@@ skipping 450 matching lines @@
         return this.rootNode().retainedSize();
     },
 
     _getDominatedIndex: function(nodeIndex)
     {
         if (nodeIndex % this._nodeFieldCount)
             throw new Error("Invalid nodeIndex: " + nodeIndex);
         return this._firstDominatedNodeIndex[nodeIndex / this._nodeFieldCount];
     },
 
-    /**
-     * @param {!WebInspector.HeapSnapshotNode} node
-     * @return {!Uint32Array}
-     */
     _dominatedNodesOfNode: function(node)
     {
         var dominatedIndexFrom = this._getDominatedIndex(node.nodeIndex);
         var dominatedIndexTo = this._getDominatedIndex(node._nextNodeIndex());
-        return this._dominatedNodes.subarray(dominatedIndexFrom, dominatedIndexTo);
+        return new WebInspector.HeapSnapshotArraySlice(this._dominatedNodes, dominatedIndexFrom, dominatedIndexTo);
     },
 
     /**
      * @param {!WebInspector.HeapSnapshotCommon.NodeFilter} nodeFilter
      * @return {!Object.<string, !WebInspector.HeapSnapshotCommon.Aggregate>}
      */
     aggregatesWithFilter: function(nodeFilter)
     {
         var minNodeId = nodeFilter.minNodeId;
         var maxNodeId = nodeFilter.maxNodeId;
@@ skipping 907 matching lines @@
      * @return {!WebInspector.HeapSnapshotCommon.StaticData}
      */
     updateStaticData: function()
     {
         return new WebInspector.HeapSnapshotCommon.StaticData(this.nodeCount, this._rootNodeIndex, this.totalSize, this._maxJsNodeId());
     }
 };
 
 /**
  * @constructor
- * @param {(!Array.<number>|!Uint32Array)=} unfilteredIterationOrder
+ * @param {!Array.<number>=} unfilteredIterationOrder
  */
 WebInspector.HeapSnapshotFilteredOrderedIterator = function(iterator, filter, unfilteredIterationOrder)
 {
     this._filter = filter;
     this._iterator = iterator;
     this._unfilteredIterationOrder = unfilteredIterationOrder;
-    /** @type {?Array.<number>|?Uint32Array} */
     this._iterationOrder = null;
     this._position = 0;
     this._currentComparator = null;
     this._sortedPrefixLength = 0;
     this._sortedSuffixLength = 0;
 }
 
 WebInspector.HeapSnapshotFilteredOrderedIterator.prototype = {
     _createIterationOrder: function()
     {
         if (this._iterationOrder)
             return;
         if (this._unfilteredIterationOrder && !this._filter) {
-            this._iterationOrder = this._unfilteredIterationOrder;
+            this._iterationOrder = this._unfilteredIterationOrder.slice(0);
             this._unfilteredIterationOrder = null;
             return;
         }
         this._iterationOrder = [];
         var iterator = this._iterator;
         if (!this._unfilteredIterationOrder && !this._filter) {
             for (iterator.rewind(); iterator.hasNext(); iterator.next())
                 this._iterationOrder.push(iterator.index());
         } else if (!this._unfilteredIterationOrder) {
             for (iterator.rewind(); iterator.hasNext(); iterator.next()) {
                 if (this._filter(iterator.item()))
                     this._iterationOrder.push(iterator.index());
             }
         } else {
-            var order = this._unfilteredIterationOrder;
+            var order = this._unfilteredIterationOrder.constructor === Array ?
+                this._unfilteredIterationOrder : this._unfilteredIterationOrder.slice(0);
             for (var i = 0, l = order.length; i < l; ++i) {
                 iterator.setIndex(order[i]);
                 if (this._filter(iterator.item()))
                     this._iterationOrder.push(iterator.index());
             }
             this._unfilteredIterationOrder = null;
         }
     },
 
     rewind: function()
@@ skipping 20 matching lines @@
             return !this._unfilteredIterationOrder.length;
         var iterator = this._iterator;
         if (!this._unfilteredIterationOrder && !this._filter) {
             iterator.rewind();
             return !iterator.hasNext();
         } else if (!this._unfilteredIterationOrder) {
             for (iterator.rewind(); iterator.hasNext(); iterator.next())
                 if (this._filter(iterator.item()))
                     return false;
         } else {
-            var order = this._unfilteredIterationOrder;
+            var order = this._unfilteredIterationOrder.constructor === Array ?
+                this._unfilteredIterationOrder : this._unfilteredIterationOrder.slice(0);
             for (var i = 0, l = order.length; i < l; ++i) {
                 iterator.setIndex(order[i]);
                 if (this._filter(iterator.item()))
                     return false;
             }
         }
         return true;
     },
 
     /**
@@ skipping 149 matching lines @@
             this._iterationOrder.sortRange(compareNodeAndNode, leftBound, rightBound, windowLeft, windowRight);
     },
 
     __proto__: WebInspector.HeapSnapshotFilteredOrderedIterator.prototype
 }
 
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotFilteredOrderedIterator}
- * @param {(!Array.<number>|!Uint32Array)=} nodeIndexes
+ * @param {!Array.<number>=} nodeIndexes
  */
 WebInspector.HeapSnapshotNodesProvider = function(snapshot, filter, nodeIndexes)
 {
     this.snapshot = snapshot;
     WebInspector.HeapSnapshotFilteredOrderedIterator.call(this, snapshot._allNodes(), filter, nodeIndexes);
 }
 
 WebInspector.HeapSnapshotNodesProvider.prototype = {
     /**
      * @param {string} snapshotObjectId
@@ skipping 69 matching lines @@
      * @param {number} windowRight
      */
     sort: function(comparator, leftBound, rightBound, windowLeft, windowRight)
     {
         this._iterationOrder.sortRange(this._buildCompareFunction(comparator), leftBound, rightBound, windowLeft, windowRight);
     },
 
     __proto__: WebInspector.HeapSnapshotFilteredOrderedIterator.prototype
 }