Extract item<->index conversion from iterator into a separate 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 124 matching lines @@
  */
 WebInspector.HeapSnapshotItemIterator = function() { }
 
 WebInspector.HeapSnapshotItemIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function() { },
 
     /**
-     * @return {number}
-     */
-    index: function() { },
-
-    /**
-     * @param {number} newIndex
-     */
-    setIndex: function(newIndex) { },
-
-    /**
      * @return {!WebInspector.HeapSnapshotEdge|!WebInspector.HeapSnapshotNode|!WebInspector.HeapSnapshotRetainerEdge}
      */
     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}
+     */
+    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;
+    }
+};
+
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotItemIterator}
  * @param {!WebInspector.HeapSnapshotNode} node
  */
 WebInspector.HeapSnapshotEdgeIterator = function(node)
 {
     this._sourceNode = node;
     this.edge = node._snapshot.createEdge(node._edgeIndexesStart());
 }
 
 WebInspector.HeapSnapshotEdgeIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
         return this.edge.edgeIndex < this._sourceNode._edgeIndexesEnd();
     },
 
     /**
-     * @return {number}
-     */
-    index: function()
-    {
-        return this.edge.edgeIndex;
-    },
-
-    /**
-     * @param {number} newIndex
-     */
-    setIndex: function(newIndex)
-    {
-        this.edge.edgeIndex = newIndex;
-    },
-
-    /**
      * @return {!WebInspector.HeapSnapshotEdge}
      */
     item: function()
     {
         return this.edge;
     },
 
     next: function()
     {
         this.edge.edgeIndex += this.edge._snapshot._edgeFieldsCount;
@@ skipping 155 matching lines @@
 WebInspector.HeapSnapshotRetainerEdgeIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
         return this.retainer.retainerIndex() < this._retainersEnd;
     },
 
     /**
-     * @return {number}
-     */
-    index: function()
-    {
-        return this.retainer.retainerIndex();
-    },
-
-    /**
-     * @param {number} newIndex
-     */
-    setIndex: function(newIndex)
-    {
-        this.retainer.setRetainerIndex(newIndex);
-    },
-
-    /**
      * @return {!WebInspector.HeapSnapshotRetainerEdge}
      */
     item: function()
     {
         return this.retainer;
     },
 
     next: function()
     {
         this.retainer.setRetainerIndex(this.retainer.retainerIndex() + 1);
     }
 };
 
 /**
  * @constructor
  * @param {number=} nodeIndex
  */
 WebInspector.HeapSnapshotNode = function(snapshot, nodeIndex)
 {
     this._snapshot = snapshot;
-    this._firstNodeIndex = nodeIndex;
     this.nodeIndex = nodeIndex;
 }
 
 /**
  * @constructor
  * @param {string} id
  * @param {string} name
  * @param {number} distance
  * @param {number|undefined} nodeIndex
  * @param {number} retainedSize
@@ skipping 206 matching lines @@
 WebInspector.HeapSnapshotNodeIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
         return this.node.nodeIndex < this._nodesLength;
     },
 
     /**
-     * @return {number}
-     */
-    index: function()
-    {
-        return /** @type{number} */ (this.node.nodeIndex);
-    },
-
-    /**
-     * @param {number} newIndex
-     */
-    setIndex: function(newIndex)
-    {
-        this.node.nodeIndex = newIndex;
-    },
-
-    /**
      * @return {!WebInspector.HeapSnapshotNode}
      */
     item: function()
     {
         return this.node;
     },
 
     next: function()
     {
         this.node.nodeIndex = this.node._nextNodeIndex();
     }
 }
 
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotItemIterator}
- * @param {!WebInspector.HeapSnapshotItemIterator} iterator
+ * @param {!WebInspector.HeapSnapshotItemIndexProvider} indexProvider
  * @param {!Array.<number>|!Uint32Array} indexes
  */
-WebInspector.HeapSnapshotIndexRangeIterator = function(iterator, indexes)
+WebInspector.HeapSnapshotIndexRangeIterator = function(indexProvider, indexes)

[alph, 2014/03/21 15:11:27]

itemProvider?

[yurys, 2014/03/24 06:10:18]

Done.

 {
-    this._iterator = iterator;
+    this._indexProvider = indexProvider;
     this._indexes = indexes;
     this._position = 0;
-    this._forcedIndex = -1;
 }
 
 WebInspector.HeapSnapshotIndexRangeIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
         return this._position < this._indexes.length
     },
 
     /**
-     * @return {number}
-     */
-    index: function()
-    {
-        if (this._forcedIndex !== -1)
-            return this._forcedIndex;
-        return this._indexes[this._position];
-    },
-
-    /**
-     * @param {number} newIndex
-     */
-    setIndex: function(newIndex)
-    {
-        this._forcedIndex = newIndex;
-    },
-
-    /**
      * @return {!WebInspector.HeapSnapshotEdge|!WebInspector.HeapSnapshotNode|!WebInspector.HeapSnapshotRetainerEdge}
      */
     item: function()
     {
-        this._iterator.setIndex(this.index());
-        return this._iterator.item();
+        var index = this._indexes[this._position];
+        return this._indexProvider.itemForIndex(index);
     },
 
     next: function()
     {
         ++this._position;
     }
 }
 
 
 /**
@@ skipping 11 matching lines @@
 WebInspector.HeapSnapshotFilteredIterator.prototype = {
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
         return this._iterator.hasNext();
     },
 
     /**
-     * @return {number}
-     */
-    index: function()
-    {
-        return this._iterator.index();
-    },
-
-    /**
-     * @param {number} newIndex
-     */
-    setIndex: function(newIndex)
-    {
-        this._iterator.setIndex(newIndex);
-    },
-
-    /**
      * @return {!WebInspector.HeapSnapshotEdge|!WebInspector.HeapSnapshotNode|!WebInspector.HeapSnapshotRetainerEdge}
      */
     item: function()
     {
         return this._iterator.item();
     },
 
     next: function()
     {
         this._iterator.next();
@@ skipping 1119 matching lines @@
 
     /**
      * @param {number} nodeIndex
      * @param {boolean} showHiddenData
      * @return {!WebInspector.HeapSnapshotEdgesProvider}
      */
     createEdgesProvider: function(nodeIndex, showHiddenData)
     {
         var node = this.createNode(nodeIndex);
         var filter = this.containmentEdgesFilter(showHiddenData);
-        return new WebInspector.HeapSnapshotEdgesProvider(this, filter, node.edges());
+        var indexProvider = new WebInspector.HeapSnapshotEdgeIndexProvider(this);
+        return new WebInspector.HeapSnapshotEdgesProvider(this, filter, node.edges(), indexProvider);
     },
 
     /**
      * @param {number} nodeIndex
      * @return {!WebInspector.HeapSnapshotEdgesProvider}
      */
     createEdgesProviderForTest: function(nodeIndex, filter)
     {
         var node = this.createNode(nodeIndex);
-        return new WebInspector.HeapSnapshotEdgesProvider(this, filter, node.edges());
+        var indexProvider = new WebInspector.HeapSnapshotEdgeIndexProvider(this);
+        return new WebInspector.HeapSnapshotEdgesProvider(this, filter, node.edges(), indexProvider);
     },
 
     /**
      * @param {boolean} showHiddenData
      * @return {?function(!WebInspector.HeapSnapshotEdge):boolean}
      */
     retainingEdgesFilter: function(showHiddenData)
     {
         return null;
     },
 
     /**
      * @param {boolean} showHiddenData
      * @return {?function(!WebInspector.HeapSnapshotEdge):boolean}
      */
     containmentEdgesFilter: function(showHiddenData)
     {
         return null;
     },
 
     /**
      * @param {number} nodeIndex
      * @param {boolean} showHiddenData
      * @return {!WebInspector.HeapSnapshotEdgesProvider}
      */
     createRetainingEdgesProvider: function(nodeIndex, showHiddenData)
     {
         var node = this.createNode(nodeIndex);
         var filter = this.retainingEdgesFilter(showHiddenData);
-        return new WebInspector.HeapSnapshotEdgesProvider(this, filter, node.retainers());
+        var indexProvider = new WebInspector.HeapSnapshotRetainerEdgeIndexProvider(this);
+        return new WebInspector.HeapSnapshotEdgesProvider(this, filter, node.retainers(), indexProvider);
     },
 
     /**
      * @param {string} baseSnapshotId
      * @param {string} className
      * @return {!WebInspector.HeapSnapshotNodesProvider}
      */
     createAddedNodesProvider: function(baseSnapshotId, className)
     {
         var snapshotDiff = this._snapshotDiffs[baseSnapshotId];
@@ skipping 63 matching lines @@
      */
     updateStaticData: function()
     {
         return new WebInspector.HeapSnapshotCommon.StaticData(this.nodeCount, this._rootNodeIndex, this.totalSize, this._maxJsNodeId());
     }
 };
 
 /**
  * @constructor
  * @param {!WebInspector.HeapSnapshotItemIterator} iterator
+ * @param {!WebInspector.HeapSnapshotItemIndexProvider} indexProvider
  */
-WebInspector.HeapSnapshotItemProvider = function(iterator)
+WebInspector.HeapSnapshotItemProvider = function(iterator, indexProvider)
 {
     this._iterator = iterator;
+    this._indexProvider = indexProvider;
     this._isEmpty = !iterator.hasNext();
     /** @type {?Array.<number>} */
     this._iterationOrder = null;
     this._currentComparator = null;
     this._sortedPrefixLength = 0;
     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(iterator.index());
+            this._iterationOrder.push(this._indexProvider.indexForItem(iterator.item()));
     },
 
     /**
      * @return {boolean}
      */
     isEmpty: function()
     {
         return this._isEmpty;
     },
 
@@ skipping 14 matching lines @@
             if (begin <= this._sortedPrefixLength)
                 this._sortedPrefixLength = end;
             if (end >= this._iterationOrder.length - this._sortedSuffixLength)
                 this._sortedSuffixLength = this._iterationOrder.length - begin;
         }
         var position = begin;
         var count = end - begin;
         var result = new Array(count);
         var iterator = this._iterator;
         for (var i = 0 ; i < count; ++i) {
-            iterator.setIndex(this._iterationOrder[position++]);
-            result[i] = iterator.item().serialize();
+            var itemIndex = this._iterationOrder[position++];
+            var item = this._indexProvider.itemForIndex(itemIndex);
+            result[i] = item.serialize();
         }
         return new WebInspector.HeapSnapshotCommon.ItemsRange(begin, end, this._iterationOrder.length, result);
     },
 
     sortAndRewind: function(comparator)
     {
         this._currentComparator = comparator;
         this._sortedPrefixLength = 0;
         this._sortedSuffixLength = 0;
     }
 }
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotItemProvider}
+ * @param {!WebInspector.HeapSnapshotItemIndexProvider} indexProvider
  */
-WebInspector.HeapSnapshotEdgesProvider = function(snapshot, filter, edgesIter)
+WebInspector.HeapSnapshotEdgesProvider = function(snapshot, filter, edgesIter, indexProvider)
 {
     this.snapshot = snapshot;
     if (filter)
         edgesIter = new WebInspector.HeapSnapshotFilteredIterator(edgesIter, filter);
-    WebInspector.HeapSnapshotItemProvider.call(this, edgesIter);
+    WebInspector.HeapSnapshotItemProvider.call(this, edgesIter, indexProvider);
 }
 
 WebInspector.HeapSnapshotEdgesProvider.prototype = {
     /**
      * @param {!WebInspector.HeapSnapshotCommon.ComparatorConfig} comparator
      * @param {number} leftBound
      * @param {number} rightBound
      * @param {number} windowLeft
      * @param {number} windowRight
      */
@@ skipping 77 matching lines @@
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotItemProvider}
  * @param {?function(!WebInspector.HeapSnapshotNode):boolean} filter
  * @param {(!Array.<number>|!Uint32Array)} nodeIndexes
  */
 WebInspector.HeapSnapshotNodesProvider = function(snapshot, filter, nodeIndexes)
 {
     this.snapshot = snapshot;
-    var it = new WebInspector.HeapSnapshotIndexRangeIterator(snapshot._allNodes(), nodeIndexes);
+    var indexProvider = new WebInspector.HeapSnapshotNodeIndexProvider(snapshot);
+    var it = new WebInspector.HeapSnapshotIndexRangeIterator(indexProvider, nodeIndexes);
     if (filter)
         it = new WebInspector.HeapSnapshotFilteredIterator(it, filter);
-    WebInspector.HeapSnapshotItemProvider.call(this, it);
+    WebInspector.HeapSnapshotItemProvider.call(this, it, indexProvider);
 }
 
 WebInspector.HeapSnapshotNodesProvider.prototype = {
     /**
      * @param {string} snapshotObjectId
      * @return {number}
      */
     nodePosition: function(snapshotObjectId)
     {
         this._createIterationOrder();
@@ skipping 64 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
 }