Simplify HeapSnapshotFilteredOrderedIterator implementation

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 111 matching lines @@
         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 = {
+    rewind: function() { },
+
+    /**
+     * @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() { }
+};
+
+
+
 /**
  * @constructor
+ * @implements {WebInspector.HeapSnapshotItemIterator}
+ * @param {!WebInspector.HeapSnapshotEdge} edge
  */
 WebInspector.HeapSnapshotEdgeIterator = function(edge)
 {
     this.edge = edge;
 }
 
 WebInspector.HeapSnapshotEdgeIterator.prototype = {
     rewind: function()
     {
         this.edge.edgeIndex = 0;
@@ skipping 177 matching lines @@
      * @return {string}
      */
     type: function()
     {
         return this._edge().type();
     }
 }
 
 /**
  * @constructor
+ * @implements {WebInspector.HeapSnapshotItemIterator}
+ * @param {!WebInspector.HeapSnapshotRetainerEdge} retainer
  */
 WebInspector.HeapSnapshotRetainerEdgeIterator = function(retainer)
 {
     this.retainer = retainer;
 }
 
 WebInspector.HeapSnapshotRetainerEdgeIterator.prototype = {
     rewind: function()
     {
         this.retainer.setRetainerIndex(0);
@@ skipping 253 matching lines @@
      */
     _type: function()
     {
         var snapshot = this._snapshot;
         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;
 }
 
 WebInspector.HeapSnapshotNodeIterator.prototype = {
     rewind: function()
     {
         this.node.nodeIndex = this.node._firstNodeIndex;
     },
 
     /**
      * @return {boolean}
      */
     hasNext: function()
     {
         return this.node.nodeIndex < this._nodesLength;
     },
 
     /**
      * @return {number}
      */
     index: function()
     {
-        return this.node.nodeIndex;
+        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 {!Array.<number>|!Uint32Array} indexes
+ */
+WebInspector.HeapSnapshotIndexRangeIterator = function(iterator, indexes)
+{
+    this._iterator = iterator;
+    this._indexes = indexes;
+    this._position = 0;
+    this._forcedIndex = -1;
+}
+
+WebInspector.HeapSnapshotIndexRangeIterator.prototype = {
+    rewind: function() { },
+
+    /**
+     * @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();
+    },
+
+    next: function()
+    {
+        ++this._position;
+    }
+}
+
+
+/**
+ * @constructor
+ * @implements {WebInspector.HeapSnapshotItemIterator}
+ * @param {!WebInspector.HeapSnapshotItemIterator} iterator
+ */
+WebInspector.HeapSnapshotFilteredIterator = function(iterator, filter)
+{
+    this._iterator = iterator;
+    this._filter = filter;
+    this._skipFilteredItems();
+}
+
+WebInspector.HeapSnapshotFilteredIterator.prototype = {
+    rewind: function() { },
+
+    /**
+     * @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();
+        this._skipFilteredItems();
+    },
+
+    _skipFilteredItems: function()
+    {
+        while (this._iterator.hasNext() && !this._filter(this._iterator.item())) {
+            this._iterator.next();
+        }
+    }
+}
+
+
+/**
  * @param {!WebInspector.HeapSnapshotWorkerDispatcher=} dispatcher
  * @constructor
  */
 WebInspector.HeapSnapshotProgress = function(dispatcher)
 {
     this._dispatcher = dispatcher;
 }
 
 WebInspector.HeapSnapshotProgress.prototype = {
     /**
@@ skipping 1218 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 {!WebInspector.HeapSnapshotItemIterator} iterator
  */
-WebInspector.HeapSnapshotFilteredOrderedIterator = function(iterator, filter, unfilteredIterationOrder)
+WebInspector.HeapSnapshotItemProvider = function(iterator)
 {
-    this._filter = filter;
     this._iterator = iterator;
-    this._unfilteredIterationOrder = unfilteredIterationOrder;
-    /** @type {?Array.<number>|?Uint32Array} */
+    this._isEmpty = !iterator.hasNext();
+    /** @type {?Array.<number>} */
     this._iterationOrder = null;
-    this._position = 0;
     this._currentComparator = null;
     this._sortedPrefixLength = 0;
     this._sortedSuffixLength = 0;
 }
 
-WebInspector.HeapSnapshotFilteredOrderedIterator.prototype = {
+WebInspector.HeapSnapshotItemProvider.prototype = {
     _createIterationOrder: function()
     {
         if (this._iterationOrder)
             return;
-        if (this._unfilteredIterationOrder && !this._filter) {
-            this._iterationOrder = this._unfilteredIterationOrder;
-            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;
-            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()
-    {
-        this._position = 0;
+        for (var iterator = this._iterator; iterator.hasNext(); iterator.next())
+            this._iterationOrder.push(iterator.index());
     },
 
     /**
-     * @return {boolean}
-     */
-    hasNext: function()
-    {
-        return this._position < this._iterationOrder.length;
-    },
-
-    /**
      * @return {boolean}
      */
     isEmpty: function()
     {
-        if (this._iterationOrder)
-            return !this._iterationOrder.length;
-        if (this._unfilteredIterationOrder && !this._filter)
-            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;
-            for (var i = 0, l = order.length; i < l; ++i) {
-                iterator.setIndex(order[i]);
-                if (this._filter(iterator.item()))
-                    return false;
-            }
-        }
-        return true;
+        return this._isEmpty;
     },
 
     /**
-     * @return {*}
-     */
-    item: function()
-    {
-        this._iterator.setIndex(this._iterationOrder[this._position]);
-        return this._iterator.item();
-    },
-
-    /**
-     * @type {number}
-     */
-    get length()
-    {
-        this._createIterationOrder();
-        return this._iterationOrder.length;
-    },
-
-    next: function()
-    {
-        ++this._position;
-    },
-
-    /**
      * @param {number} begin
      * @param {number} end
      * @return {!WebInspector.HeapSnapshotCommon.ItemsRange}
      */
     serializeItemsRange: function(begin, end)
     {
         this._createIterationOrder();
         if (begin > end)
             throw new Error("Start position > end position: " + begin + " > " + end);
         if (end > this._iterationOrder.length)
             end = this._iterationOrder.length;
         if (this._sortedPrefixLength < end && begin < this._iterationOrder.length - this._sortedSuffixLength) {
             this.sort(this._currentComparator, this._sortedPrefixLength, this._iterationOrder.length - 1 - this._sortedSuffixLength, begin, end - 1);
             if (begin <= this._sortedPrefixLength)
                 this._sortedPrefixLength = end;
             if (end >= this._iterationOrder.length - this._sortedSuffixLength)
                 this._sortedSuffixLength = this._iterationOrder.length - begin;
         }
-
-        this._position = begin;
-        var startPosition = this._position;
+        var position = begin;
         var count = end - begin;
         var result = new Array(count);
-        for (var i = 0 ; i < count && this.hasNext(); ++i, this.next())
-            result[i] = this.item().serialize();
-        return new WebInspector.HeapSnapshotCommon.ItemsRange(startPosition, this._position, this._iterationOrder.length, result);
+        var iterator = this._iterator;
+        for (var i = 0 ; i < count; ++i) {
+            iterator.setIndex(this._iterationOrder[position++]);
+            result[i] = iterator.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;
-        this.rewind();
     }
 }
 
 /**
  * @constructor
- * @extends {WebInspector.HeapSnapshotFilteredOrderedIterator}
+ * @extends {WebInspector.HeapSnapshotItemProvider}
  */
 WebInspector.HeapSnapshotEdgesProvider = function(snapshot, filter, edgesIter)
 {
     this.snapshot = snapshot;
-    WebInspector.HeapSnapshotFilteredOrderedIterator.call(this, edgesIter, filter);
+    if (filter)
+        edgesIter = new WebInspector.HeapSnapshotFilteredIterator(edgesIter, filter);
+    WebInspector.HeapSnapshotItemProvider.call(this, edgesIter);
 }
 
 WebInspector.HeapSnapshotEdgesProvider.prototype = {
     /**
      * @param {!WebInspector.HeapSnapshotCommon.ComparatorConfig} comparator
      * @param {number} leftBound
      * @param {number} rightBound
      * @param {number} windowLeft
      * @param {number} windowRight
      */
@@ skipping 64 matching lines @@
         }
 
         if (fieldName1 === "!edgeName")
             this._iterationOrder.sortRange(compareEdgeAndNode, leftBound, rightBound, windowLeft, windowRight);
         else if (fieldName2 === "!edgeName")
             this._iterationOrder.sortRange(compareNodeAndEdge, leftBound, rightBound, windowLeft, windowRight);
         else
             this._iterationOrder.sortRange(compareNodeAndNode, leftBound, rightBound, windowLeft, windowRight);
     },
 
-    __proto__: WebInspector.HeapSnapshotFilteredOrderedIterator.prototype
+    __proto__: WebInspector.HeapSnapshotItemProvider.prototype
 }
 
 
 /**
  * @constructor
- * @extends {WebInspector.HeapSnapshotFilteredOrderedIterator}
- * @param {(!Array.<number>|!Uint32Array)=} nodeIndexes
+ * @extends {WebInspector.HeapSnapshotItemProvider}
+ * @param {?function(!WebInspector.HeapSnapshotNode):boolean} filter
+ * @param {(!Array.<number>|!Uint32Array)} nodeIndexes
  */
 WebInspector.HeapSnapshotNodesProvider = function(snapshot, filter, nodeIndexes)
 {
     this.snapshot = snapshot;
-    WebInspector.HeapSnapshotFilteredOrderedIterator.call(this, snapshot._allNodes(), filter, nodeIndexes);
+    var it = new WebInspector.HeapSnapshotIndexRangeIterator(snapshot._allNodes(), nodeIndexes);
+    if (filter)
+        it = new WebInspector.HeapSnapshotFilteredIterator(it, filter);
+    WebInspector.HeapSnapshotItemProvider.call(this, it);
 }
 
 WebInspector.HeapSnapshotNodesProvider.prototype = {
     /**
      * @param {string} snapshotObjectId
      * @return {number}
      */
     nodePosition: function(snapshotObjectId)
     {
         this._createIterationOrder();
@@ skipping 61 matching lines @@
      * @param {number} leftBound
      * @param {number} rightBound
      * @param {number} windowLeft
      * @param {number} windowRight
      */
     sort: function(comparator, leftBound, rightBound, windowLeft, windowRight)
     {
         this._iterationOrder.sortRange(this._buildCompareFunction(comparator), leftBound, rightBound, windowLeft, windowRight);
     },
 
-    __proto__: WebInspector.HeapSnapshotFilteredOrderedIterator.prototype
+    __proto__: WebInspector.HeapSnapshotItemProvider.prototype
 }