DevTools: Show preview in console of ES6 Map, Set, WeakMap and WeakSet entries.

Source/core/inspector/InjectedScriptSource.js

 /*
  * Copyright (C) 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2013 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 1073 matching lines @@
 var injectedScript = new InjectedScript();
 
 /**
  * @constructor
  * @param {*} object
  * @param {string=} objectGroupName
  * @param {boolean=} forceValueType
  * @param {boolean=} generatePreview
  * @param {?Array.<string>=} columnNames
  * @param {boolean=} isTable
+ * @param {boolean=} skipEntriesPreview
  */
-InjectedScript.RemoteObject = function(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable)
+InjectedScript.RemoteObject = function(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable, skipEntriesPreview)
 {
     this.type = typeof object;
     if (injectedScript.isPrimitiveValue(object) || object === null || forceValueType) {
         // We don't send undefined values over JSON.
         if (this.type !== "undefined")
             this.value = object;
 
         // Null object is object with 'null' subtype.
         if (object === null)
             this.subtype = "null";
@@ skipping 20 matching lines @@
     this.objectId = injectedScript._bind(object, objectGroupName);
     var subtype = injectedScript._subtype(object);
     if (subtype)
         this.subtype = subtype;
     var className = InjectedScriptHost.internalConstructorName(object);
     if (className)
         this.className = className;
     this.description = injectedScript._describe(object);
 
     if (generatePreview && (this.type === "object" || injectedScript._isHTMLAllCollection(object)))
-        this.preview = this._generatePreview(object, undefined, columnNames, isTable);
+        this.preview = this._generatePreview(object, undefined, columnNames, isTable, skipEntriesPreview);
 }
 
 InjectedScript.RemoteObject.prototype = {
     /**
      * @param {!Object} object
      * @param {?Array.<string>=} firstLevelKeys
      * @param {?Array.<string>=} secondLevelKeys
      * @param {boolean=} isTable
+     * @param {boolean=} skipEntriesPreview
      * @return {!RuntimeAgent.ObjectPreview} preview
      */
-    _generatePreview: function(object, firstLevelKeys, secondLevelKeys, isTable)
+    _generatePreview: function(object, firstLevelKeys, secondLevelKeys, isTable, skipEntriesPreview)
     {
-        var preview = { __proto__: null };
-        preview.lossless = true;
-        preview.overflow = false;
-        preview.properties = [];
+        var preview = {
+            type: /** @type {!RuntimeAgent.ObjectPreviewType.<string>} */ (this.type),
+            description: this.description || toStringDescription(this.value),
+            lossless: true,
+            overflow: false,
+            properties: [],
+            __proto__: null
+        };
+        if (this.subtype)
+            preview.subtype = /** @type {!RuntimeAgent.ObjectPreviewSubtype.<string>} */ (this.subtype);
 
         var firstLevelKeysCount = firstLevelKeys ? firstLevelKeys.length : 0;
 
         var propertiesThreshold = {
             properties: isTable ? 1000 : max(5, firstLevelKeysCount),
-            indexes: isTable ? 1000 : max(100, firstLevelKeysCount)
+            indexes: isTable ? 1000 : max(100, firstLevelKeysCount),
+            __proto__: null
         };
 
         try {
             var descriptors = injectedScript._propertyDescriptors(object);
 
             if (firstLevelKeys) {
                 var nameToDescriptors = { __proto__: null };
                 for (var i = 0; i < descriptors.length; ++i) {
                     var descriptor = descriptors[i];
                     nameToDescriptors["#" + descriptor.name] = descriptor;
                 }
                 descriptors = [];
                 for (var i = 0; i < firstLevelKeys.length; ++i)
                     descriptors[i] = nameToDescriptors["#" + firstLevelKeys[i]];
             }
 
             this._appendPropertyDescriptors(preview, descriptors, propertiesThreshold, secondLevelKeys, isTable);
             if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0)
                 return preview;
 
             // Add internal properties to preview.
             var internalProperties = InjectedScriptHost.getInternalProperties(object) || [];
             for (var i = 0; i < internalProperties.length; ++i) {
                 internalProperties[i] = nullifyObjectProto(internalProperties[i]);
                 internalProperties[i].enumerable = true;
             }
             this._appendPropertyDescriptors(preview, internalProperties, propertiesThreshold, secondLevelKeys, isTable);
 
+            if (this.subtype === "map" || this.subtype === "set")
+                this._appendEntriesPreview(object, preview, skipEntriesPreview);
+
         } catch (e) {
             preview.lossless = false;
         }
 
         return preview;
     },
 
     /**
      * @param {!RuntimeAgent.ObjectPreview} preview
      * @param {!Array.<!Object>} descriptors
@@ skipping 87 matching lines @@
             propertiesThreshold.properties--;
         if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0) {
             preview.overflow = true;
             preview.lossless = false;
         } else {
             push(preview.properties, property);
         }
     },
 
     /**
+     * @param {!Object} object
+     * @param {!RuntimeAgent.ObjectPreview} preview
+     * @param {boolean=} skipEntriesPreview
+     */
+    _appendEntriesPreview: function(object, preview, skipEntriesPreview)
+    {
+        var entries = InjectedScriptHost.collectionEntries(object);
+        if (!entries)
+            return;
+        if (skipEntriesPreview) {
+            if (entries.length) {
+                preview.overflow = true;
+                preview.lossless = false;
+            }
+            return;
+        }
+        preview.entries = [];
+        var entriesThreshold = 5;
+        for (var i = 0; i < entries.length; ++i) {
+            if (preview.entries.length >= entriesThreshold) {
+                preview.overflow = true;
+                preview.lossless = false;
+                break;
+            }
+            var entry = nullifyObjectProto(entries[i]);
+            var previewEntry = {
+                value: generateValuePreview(entry.value),
+                __proto__: null
+            };
+            if ("key" in entry)
+                previewEntry.key = generateValuePreview(entry.key);
+            push(preview.entries, previewEntry);

[yurys, 2014/09/14 12:42:03]

Is it to avoid calling overwritten Array.prototype.push?

[aandrey, 2014/09/15 06:51:57]

Yep. We also have a presubmit check to catch this.

+        }
+
+        /**
+         * @param {*} value
+         * @return {!RuntimeAgent.ObjectPreview}
+         */
+        function generateValuePreview(value)
+        {
+            var remoteObject = new InjectedScript.RemoteObject(value, undefined, undefined, true, undefined, undefined, true);
+            var valuePreview = remoteObject.preview || {
+                type: remoteObject.type,
+                subtype: remoteObject.subtype,
+                description: remoteObject.description || toStringDescription(remoteObject.value),
+                lossless: true,
+                overflow: false,
+                properties: [],
+                __proto__: null
+            };
+            if (remoteObject.objectId)
+                injectedScript.releaseObject(remoteObject.objectId);
+            if (!valuePreview.lossless)
+                preview.lossless = false;
+            return valuePreview;
+        }
+    },
+
+    /**
      * @param {string} string
      * @param {number} maxLength
      * @param {boolean=} middle
      * @return {string}
      */
     _abbreviateString: function(string, maxLength, middle)
     {
         if (string.length <= maxLength)
             return string;
         if (middle) {
@@ skipping 418 matching lines @@
      */
     _logEvent: function(event)
     {
         inspectedWindow.console.log(event.type, event);
     }
 }
 
 injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
 return injectedScript;
 })