DevTools: Show all objects in class view in advanced heap snapshot mode.

Source/devtools/front_end/JSHeapSnapshot.js

 /*
  * Copyright (C) 2012 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 13 matching lines @@
  * 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.HeapSnapshotProgress} progress
+ * @param {boolean} showHiddenData
  * @extends {WebInspector.HeapSnapshot}
  */
-WebInspector.JSHeapSnapshot = function(profile, progress)
+WebInspector.JSHeapSnapshot = function(profile, progress, showHiddenData)
 {
     this._nodeFlags = { // bit flags
         canBeQueried: 1,
         detachedDOMTreeNode: 2,
         pageObject: 4, // The idea is to track separately the objects owned by the page and the objects owned by debugger.
 
         visitedMarkerMask: 0x0ffff, // bits: 0,1111,1111,1111,1111
         visitedMarker:     0x10000  // bits: 1,0000,0000,0000,0000
     };
     this._lazyStringCache = { };
-    WebInspector.HeapSnapshot.call(this, profile, progress);
+    WebInspector.HeapSnapshot.call(this, profile, progress, showHiddenData);
 }
 
 WebInspector.JSHeapSnapshot.prototype = {
     /**
      * @param {number} nodeIndex
      * @return {!WebInspector.JSHeapSnapshotNode}
      */
     createNode: function(nodeIndex)
     {
         return new WebInspector.JSHeapSnapshotNode(this, nodeIndex);
@@ skipping 13 matching lines @@
      * @override
      * @param {number} retainerIndex
      * @return {!WebInspector.JSHeapSnapshotRetainerEdge}
      */
     createRetainingEdge: function(retainerIndex)
     {
         return new WebInspector.JSHeapSnapshotRetainerEdge(this, retainerIndex);
     },
 
     /**
-     * @return {function(!WebInspector.JSHeapSnapshotNode):boolean}
+     * @override
+     * @return {?function(!WebInspector.JSHeapSnapshotNode):boolean}
      */
     classNodesFilter: function()
     {
+        /**
+         * @param {!WebInspector.JSHeapSnapshotNode} node
+         * @return {boolean}
+         */
         function filter(node)
         {
             return node.isUserObject();
         }
-        return filter;
+        return this._showHiddenData ? null : filter;
     },
 
     /**
-     * @param {boolean} showHiddenData
      * @return {function(!WebInspector.HeapSnapshotEdge):boolean}
      */
-    containmentEdgesFilter: function(showHiddenData)
+    containmentEdgesFilter: function()
     {
+        var showHiddenData = this._showHiddenData;
         function filter(edge) {
             if (edge.isInvisible())
                 return false;
             if (showHiddenData)
                 return true;
             return !edge.isHidden() && !edge.node().isHidden();
         }
         return filter;
     },
 
     /**
-     * @param {boolean} showHiddenData
      * @return {function(!WebInspector.HeapSnapshotEdge):boolean}
      */
-    retainingEdgesFilter: function(showHiddenData)
+    retainingEdgesFilter: function()
     {
-        var containmentEdgesFilter = this.containmentEdgesFilter(showHiddenData);
+        var containmentEdgesFilter = this.containmentEdgesFilter();
         function filter(edge)
         {
             return containmentEdgesFilter(edge) && !edge.node().isRoot() && !edge.isWeak();
         }
         return filter;
     },
 
     dispose: function()
     {
         WebInspector.HeapSnapshot.prototype.dispose.call(this);
@@ skipping 89 matching lines @@
                 for (var iter2 = subRoot.edges(); iter2.hasNext(); iter2.next())
                     doAction(iter2.edge.node());
                 doAction(subRoot);
             }
             for (var iter = this.rootNode().edges(); iter.hasNext(); iter.next())
                 doAction(iter.edge.node())
         }
     },
 
     /**
-     * @return {!{map: !Uint32Array, flag: number}}
+     * @return {?{map: !Uint32Array, flag: number}}
      */
     userObjectsMapAndFlag: function()
     {
-        return {
+        return this._showHiddenData ? null : {
             map: this._flags,
             flag: this._nodeFlags.pageObject
         };
     },
 
     _flagsOfNode: function(node)
     {
         return this._flags[node.nodeIndex / this._nodeFieldCount];
     },
 
@@ skipping 592 matching lines @@
      * @return {boolean}
      */
     isWeak: function()
     {
         return this._edge().isWeak();
     },
 
     __proto__: WebInspector.HeapSnapshotRetainerEdge.prototype
 }