Introduce HeapSnapshotItem interface

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 11 matching lines @@
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * 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.
  */
 
 /**
+ * @interface
+ */
+WebInspector.HeapSnapshotItem = function() { }
+
+WebInspector.HeapSnapshotItem.prototype = {
+    /**
+     * @return {number}
+     */
+    itemIndex: function() { },
+
+    /**
+     * @return {!Object}
+     */
+    serialize: function() { }
+};
+
+/**
  * @constructor
+ * @implements {WebInspector.HeapSnapshotItem}
  * @param {!WebInspector.HeapSnapshot} snapshot
  * @param {number=} edgeIndex
  */
 WebInspector.HeapSnapshotEdge = function(snapshot, edgeIndex)
 {
     this._snapshot = snapshot;
     this._edges = snapshot._containmentEdges;
     this.edgeIndex = edgeIndex || 0;
 }
 
@@ skipping 64 matching lines @@
 
     /**
      * @return {string}
      */
     type: function()
     {
         return this._snapshot._edgeTypes[this._type()];
     },
 
     /**
+     * @override
+     * @return {number}
+     */
+    itemIndex: function()
+    {
+        return this.edgeIndex;
+    },
+
+    /**
+     * @override
      * @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];
     }
 };
 
 
-
 /**
  * @interface
  */
 WebInspector.HeapSnapshotItemIterator = function() { }
 
 WebInspector.HeapSnapshotItemIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function() { },
 
     /**
-     * @return {!WebInspector.HeapSnapshotEdge|!WebInspector.HeapSnapshotNode|!WebInspector.HeapSnapshotRetainerEdge}
+     * @return {!WebInspector.HeapSnapshotItem}
      */
     item: function() { },
 
     next: function() { }
 };
 
 
 /**
  * @interface
  */
 WebInspector.HeapSnapshotItemIndexProvider = function() { }
 
 WebInspector.HeapSnapshotItemIndexProvider.prototype = {
     /**
-     * @param {!WebInspector.HeapSnapshotEdge|!WebInspector.HeapSnapshotNode|!WebInspector.HeapSnapshotRetainerEdge} item
-     * @return {number}
-     */
-    indexForItem: function(item) { },
-
-    /**
      * @param {number} newIndex
-     * @return {!WebInspector.HeapSnapshotEdge|!WebInspector.HeapSnapshotNode|!WebInspector.HeapSnapshotRetainerEdge}
+     * @return {!WebInspector.HeapSnapshotItem}
      */
     itemForIndex: function(newIndex) { },
 };
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotItemIndexProvider}
  * @param {!WebInspector.HeapSnapshot} snapshot
  */
 WebInspector.HeapSnapshotNodeIndexProvider = function(snapshot)
 {
     this._node = snapshot.createNode();
 }
 
 WebInspector.HeapSnapshotNodeIndexProvider.prototype = {
     /**
-     * @param {!WebInspector.HeapSnapshotEdge|!WebInspector.HeapSnapshotNode|!WebInspector.HeapSnapshotRetainerEdge} item
-     * @return {number}
-     */
-    indexForItem: function(item)
-    {
-        var node = /** @type {!WebInspector.HeapSnapshotNode} */ (item);
-        return node.nodeIndex;
-    },
-
-    /**
      * @param {number} index
      * @return {!WebInspector.HeapSnapshotNode}
      */
     itemForIndex: function(index)
     {
         this._node.nodeIndex = index;
         return this._node;
     }
 };
 
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotItemIndexProvider}
  * @param {!WebInspector.HeapSnapshot} snapshot
  */
 WebInspector.HeapSnapshotEdgeIndexProvider = function(snapshot)
 {
     this._edge = snapshot.createEdge(0);
 }
 
 WebInspector.HeapSnapshotEdgeIndexProvider.prototype = {
     /**
-     * @param {!WebInspector.HeapSnapshotEdge|!WebInspector.HeapSnapshotNode|!WebInspector.HeapSnapshotRetainerEdge} item
-     * @return {number}
-     */
-    indexForItem: function(item)
-    {
-        var edge = /** @type {!WebInspector.HeapSnapshotEdge} */ (item);
-        return edge.edgeIndex;
-    },
-
-    /**
      * @param {number} index
      * @return {!WebInspector.HeapSnapshotEdge}
      */
     itemForIndex: function(index)
     {
         this._edge.edgeIndex = index;
         return this._edge;
     }
 };
 
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotItemIndexProvider}
  * @param {!WebInspector.HeapSnapshot} snapshot
  */
 WebInspector.HeapSnapshotRetainerEdgeIndexProvider = function(snapshot)
 {
     this._retainerEdge = snapshot.createRetainingEdge(0);
 }
 
 WebInspector.HeapSnapshotRetainerEdgeIndexProvider.prototype = {
     /**
-     * @param {!WebInspector.HeapSnapshotEdge|!WebInspector.HeapSnapshotNode|!WebInspector.HeapSnapshotRetainerEdge} item
-     * @return {number}
-     */
-    indexForItem: function(item)
-    {
-        var edge = /** @type {!WebInspector.HeapSnapshotRetainerEdge} */ (item);
-        return edge.retainerIndex();
-    },
-
-    /**
      * @param {number} index
      * @return {!WebInspector.HeapSnapshotRetainerEdge}
      */
     itemForIndex: function(index)
     {
         this._retainerEdge.setRetainerIndex(index);
         return this._retainerEdge;
     }
 };
 
@@ skipping 27 matching lines @@
     },
 
     next: function()
     {
         this.edge.edgeIndex += this.edge._snapshot._edgeFieldsCount;
     }
 };
 
 /**
  * @constructor
+ * @implements {WebInspector.HeapSnapshotItem}
  * @param {!WebInspector.HeapSnapshot} snapshot
  * @param {number} retainerIndex
  */
 WebInspector.HeapSnapshotRetainerEdge = function(snapshot, retainerIndex)
 {
     this._snapshot = snapshot;
     this.setRetainerIndex(retainerIndex);
 }
 
 /**
@@ skipping 99 matching lines @@
 
     /**
      * @return {string}
      */
     toString: function()
     {
         return this._edge().toString();
     },
 
     /**
+     * @override
+     * @return {number}
+     */
+    itemIndex: function()
+    {
+        return this._retainerIndex;
+    },
+
+    /**
+     * @override
      * @return {!WebInspector.HeapSnapshotRetainerEdge.Serialized}
      */
     serialize: function()
     {
         var node = this.node();
         return new WebInspector.HeapSnapshotRetainerEdge.Serialized(this.name(), node.serialize(), this.nodeIndex(), this.type(), node.distance());
     },
 
     /**
      * @return {string}
@@ skipping 36 matching lines @@
     },
 
     next: function()
     {
         this.retainer.setRetainerIndex(this.retainer.retainerIndex() + 1);
     }
 };
 
 /**
  * @constructor
+ * @implements {WebInspector.HeapSnapshotItem}
+ * @param {!WebInspector.HeapSnapshot} snapshot
  * @param {number=} nodeIndex
  */
 WebInspector.HeapSnapshotNode = function(snapshot, nodeIndex)
 {
     this._snapshot = snapshot;
-    this.nodeIndex = nodeIndex;
+    this.nodeIndex = nodeIndex || 0;
 }
 
 /**
  * @constructor
  * @param {string} id
  * @param {string} name
  * @param {number} distance
  * @param {number|undefined} nodeIndex
  * @param {number} retainedSize
  * @param {number} selfSize
@@ skipping 126 matching lines @@
     /**
      * @return {number}
      */
     traceNodeId: function()
     {
         var snapshot = this._snapshot;
         return snapshot._nodes[this.nodeIndex + snapshot._nodeTraceNodeIdOffset];
     },
 
     /**
+     * @override
+     * @return {number}
+     */
+    itemIndex: function()
+    {
+        return this.nodeIndex;
+    },
+
+    /**
+     * @override
      * @return {!WebInspector.HeapSnapshotNode.Serialized}
      */
     serialize: function()
     {
         return new WebInspector.HeapSnapshotNode.Serialized(this.id(), this.name(), this.distance(), this.nodeIndex, this.retainedSize(), this.selfSize(), this.type());
     },
 
     /**
      * @return {number}
      */
@@ skipping 96 matching lines @@
 WebInspector.HeapSnapshotIndexRangeIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
         return this._position < this._indexes.length
     },
 
     /**
-     * @return {!WebInspector.HeapSnapshotEdge|!WebInspector.HeapSnapshotNode|!WebInspector.HeapSnapshotRetainerEdge}
+     * @return {!WebInspector.HeapSnapshotItem}
      */
     item: function()
     {
         var index = this._indexes[this._position];
         return this._itemProvider.itemForIndex(index);
     },
 
     next: function()
     {
         ++this._position;
@@ skipping 16 matching lines @@
 WebInspector.HeapSnapshotFilteredIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
         return this._iterator.hasNext();
     },
 
     /**
-     * @return {!WebInspector.HeapSnapshotEdge|!WebInspector.HeapSnapshotNode|!WebInspector.HeapSnapshotRetainerEdge}
+     * @return {!WebInspector.HeapSnapshotItem}
      */
     item: function()
     {
         return this._iterator.item();
     },
 
     next: function()
     {
         this._iterator.next();
         this._skipFilteredItems();
@@ skipping 1266 matching lines @@
     this._sortedSuffixLength = 0;
 }
 
 WebInspector.HeapSnapshotItemProvider.prototype = {
     _createIterationOrder: function()
     {
         if (this._iterationOrder)
             return;
         this._iterationOrder = [];
         for (var iterator = this._iterator; iterator.hasNext(); iterator.next())
-            this._iterationOrder.push(this._indexProvider.indexForItem(iterator.item()));
+            this._iterationOrder.push(iterator.item().itemIndex());
     },
 
     /**
      * @return {boolean}
      */
     isEmpty: function()
     {
         return this._isEmpty;
     },
 
@@ skipping 226 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
 }