[DevTools] Move suspended generator location to internal properties

third_party/WebKit/Source/devtools/front_end/components/ObjectPropertiesSection.js

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 11 matching lines @@
  * 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
  * @extends {TreeOutlineInShadow}
  * @param {!WebInspector.RemoteObject} object
  * @param {?string|!Element=} title
+ * @param {?WebInspector.Linkifier=} linkifier

[dgozman, 2016/07/07 19:34:25]

Let's make it !WebInspector.Linkifier= and pass undefined instead of null. Two
types of nullability don't really make sense.

[kozy, 2016/07/07 21:33:28]

Done.

  * @param {?string=} emptyPlaceholder
  * @param {boolean=} ignoreHasOwnProperty
  * @param {!Array.<!WebInspector.RemoteObjectProperty>=} extraProperties
  */
-WebInspector.ObjectPropertiesSection = function(object, title, emptyPlaceholder, ignoreHasOwnProperty, extraProperties)
+WebInspector.ObjectPropertiesSection = function(object, title, linkifier, emptyPlaceholder, ignoreHasOwnProperty, extraProperties)

[dgozman, 2016/07/07 19:34:25]

Unfortunately I cannot check that you updated all the calls to this method, and
it's quite dangerous due to all the optional parameters. Can you please
double-check?

[kozy, 2016/07/07 21:33:28]

I checked it with search over code base while adding and I think that closure
compiler will catch me if I miss something.

 {
     this._object = object;
     this._editable = true;
     TreeOutlineInShadow.call(this);
     this.hideOverflow();
     this.setFocusable(false);
-    this._objectTreeElement = new WebInspector.ObjectPropertiesSection.RootElement(object, emptyPlaceholder, ignoreHasOwnProperty, extraProperties);
+    this._objectTreeElement = new WebInspector.ObjectPropertiesSection.RootElement(object, linkifier, emptyPlaceholder, ignoreHasOwnProperty, extraProperties);
     this.appendChild(this._objectTreeElement);
     if (typeof title === "string" || !title)
         this.element.createChild("span").textContent = title || "";
     else
         this.element.appendChild(title);
 
     this.element._section = this;
     this.registerRequiredCSS("components/objectValue.css");
     this.registerRequiredCSS("components/objectPropertiesSection.css");
     this.rootElement().childrenListElement.classList.add("source-code", "object-properties-section");
 }
 
 /** @const */
 WebInspector.ObjectPropertiesSection._arrayLoadThreshold = 100;
 
 /**
  * @param {!WebInspector.RemoteObject} object
+ * @param {?WebInspector.Linkifier=} linkifier
  * @param {boolean=} skipProto
  * @return {!Element}
  */
-WebInspector.ObjectPropertiesSection.defaultObjectPresentation = function(object, skipProto)
+WebInspector.ObjectPropertiesSection.defaultObjectPresentation = function(object, linkifier, skipProto)
 {
     var componentRoot = createElementWithClass("span", "source-code");
     var shadowRoot = WebInspector.createShadowRootWithCoreStyles(componentRoot, "components/objectValue.css");
     shadowRoot.appendChild(WebInspector.ObjectPropertiesSection.createValueElement(object, false));
     if (!object.hasChildren)
         return componentRoot;
 
-    var objectPropertiesSection = new WebInspector.ObjectPropertiesSection(object, componentRoot);
+    var objectPropertiesSection = new WebInspector.ObjectPropertiesSection(object, componentRoot, linkifier);
     objectPropertiesSection.editable = false;
     if (skipProto)
         objectPropertiesSection.skipProto();
 
     return objectPropertiesSection.element;
 }
 
 WebInspector.ObjectPropertiesSection.prototype = {
     skipProto: function()
     {
@@ skipping 60 matching lines @@
         return 1;
     if (propertyB.symbol && !propertyA.symbol)
         return -1;
     return String.naturalOrderComparator(a, b);
 }
 
 /**
  * @constructor
  * @extends {TreeElement}
  * @param {!WebInspector.RemoteObject} object
+ * @param {?WebInspector.Linkifier=} linkifier
  * @param {?string=} emptyPlaceholder
  * @param {boolean=} ignoreHasOwnProperty
  * @param {!Array.<!WebInspector.RemoteObjectProperty>=} extraProperties
  */
-WebInspector.ObjectPropertiesSection.RootElement = function(object, emptyPlaceholder, ignoreHasOwnProperty, extraProperties)
+WebInspector.ObjectPropertiesSection.RootElement = function(object, linkifier, emptyPlaceholder, ignoreHasOwnProperty, extraProperties)
 {
     this._object = object;
     this._extraProperties = extraProperties || [];
     this._ignoreHasOwnProperty = !!ignoreHasOwnProperty;
     this._emptyPlaceholder = emptyPlaceholder;
     var contentElement = createElement("content");
     TreeElement.call(this, contentElement);
     this.setExpandable(true);
     this.selectable = false;
     this.toggleOnClick = true;
     this.listItemElement.classList.add("object-properties-section-root-element");
+    this._linkifier = linkifier;
 }
 
 WebInspector.ObjectPropertiesSection.RootElement.prototype = {
 
     onexpand: function()
     {
         if (this.treeOutline)
             this.treeOutline.element.classList.add("expanded");
     },
 
     oncollapse: function()
     {
         if (this.treeOutline)
             this.treeOutline.element.classList.remove("expanded");
     },
 
     /**
      * @override
      * @param {!Event} e
      * @return {boolean}
      */
     ondblclick: function(e)
     {
         return true;
     },
 
     onpopulate: function()
     {
-        WebInspector.ObjectPropertyTreeElement._populate(this, this._object, !!this.treeOutline._skipProto, this._emptyPlaceholder, this._ignoreHasOwnProperty, this._extraProperties);
+        WebInspector.ObjectPropertyTreeElement._populate(this, this._object, !!this.treeOutline._skipProto, this._linkifier, this._emptyPlaceholder, this._ignoreHasOwnProperty, this._extraProperties);
     },
 
     __proto__: TreeElement.prototype
 }
 
 /**
  * @constructor
  * @extends {TreeElement}
  * @param {!WebInspector.RemoteObjectProperty} property
+ * @param {?WebInspector.Linkifier=} linkifier
  */
-WebInspector.ObjectPropertyTreeElement = function(property)
+WebInspector.ObjectPropertyTreeElement = function(property, linkifier)
 {
     this.property = property;
 
     // Pass an empty title, the title gets made later in onattach.
     TreeElement.call(this);
     this.toggleOnClick = true;
     this.selectable = false;
     /** @type {!Array.<!Object>} */
     this._highlightChanges = [];
+    this._linkifier = linkifier;
 }
 
 WebInspector.ObjectPropertyTreeElement.prototype = {
     /**
      * @param {!RegExp} regex
      * @param {string=} additionalCssClassName
      * @return {boolean}
      */
     setSearchRegex: function(regex, additionalCssClassName) {
         var cssClasses = WebInspector.highlightedSearchResultClassName;
@@ skipping 33 matching lines @@
         WebInspector.revertDomChanges(this._highlightChanges);
         this._highlightChanges = [];
     },
 
     onpopulate: function()
     {
         var propertyValue = /** @type {!WebInspector.RemoteObject} */ (this.property.value);
         console.assert(propertyValue);
         var skipProto = this.treeOutline ? this.treeOutline._skipProto : true;
         var targetValue = this.property.name !== "__proto__" ? propertyValue : this.property.parentObject;
-        WebInspector.ObjectPropertyTreeElement._populate(this, propertyValue, skipProto, undefined, undefined, undefined, targetValue);
+        WebInspector.ObjectPropertyTreeElement._populate(this, propertyValue, skipProto, this._linkifier, undefined, undefined, undefined, targetValue);
     },
 
     /**
      * @override
      * @return {boolean}
      */
     ondblclick: function(event)
     {
         var editableElement = this.valueElement;
         if (!this.property.value.customPreview() && (this.property.writable || this.property.setter) && event.target.isSelfOrDescendant(editableElement))
@@ skipping 20 matching lines @@
         if (this.property.synthetic)
             this.nameElement.classList.add("synthetic-property");
 
         this._updatePropertyPath();
         this.nameElement.addEventListener("contextmenu", this._contextMenuFired.bind(this, this.property), false);
 
         var separatorElement = createElementWithClass("span", "object-properties-section-separator");
         separatorElement.textContent = ": ";
 
         if (this.property.value) {
-            this.valueElement = WebInspector.ObjectPropertiesSection.createValueElementWithCustomSupport(this.property.value, this.property.wasThrown, this.listItemElement);
+            this.valueElement = WebInspector.ObjectPropertiesSection.createValueElementWithCustomSupport(this.property.value, this.property.wasThrown, this.listItemElement, this._linkifier);
             this.valueElement.addEventListener("contextmenu", this._contextMenuFired.bind(this, this.property), false);
         } else if (this.property.getter) {
             this.valueElement = WebInspector.ObjectPropertyTreeElement.createRemoteObjectAccessorPropertySpan(this.property.parentObject, [this.property.name], this._onInvokeGetterClick.bind(this));
         } else {
             this.valueElement = createElementWithClass("span", "object-value-undefined");
             this.valueElement.textContent = WebInspector.UIString("<unreadable>");
             this.valueElement.title = WebInspector.UIString("No property getter");
         }
 
         this.listItemElement.removeChildren();
@@ skipping 168 matching lines @@
             this.setExpandable(false);
     },
 
     __proto__: TreeElement.prototype
 }
 
 /**
  * @param {!TreeElement} treeElement
  * @param {!WebInspector.RemoteObject} value
  * @param {boolean} skipProto
+ * @param {?WebInspector.Linkifier=} linkifier
  * @param {?string=} emptyPlaceholder
  * @param {boolean=} flattenProtoChain
  * @param {!Array.<!WebInspector.RemoteObjectProperty>=} extraProperties
  * @param {!WebInspector.RemoteObject=} targetValue
  */
-WebInspector.ObjectPropertyTreeElement._populate = function(treeElement, value, skipProto, emptyPlaceholder, flattenProtoChain, extraProperties, targetValue)
+WebInspector.ObjectPropertyTreeElement._populate = function(treeElement, value, skipProto, linkifier, emptyPlaceholder, flattenProtoChain, extraProperties, targetValue)
 {
     if (value.arrayLength() > WebInspector.ObjectPropertiesSection._arrayLoadThreshold) {
         treeElement.removeChildren();
-        WebInspector.ArrayGroupingTreeElement._populateArray(treeElement, value, 0, value.arrayLength() - 1);
+        WebInspector.ArrayGroupingTreeElement._populateArray(treeElement, value, 0, value.arrayLength() - 1, linkifier);
         return;
     }
 
     /**
      * @param {?Array.<!WebInspector.RemoteObjectProperty>} properties
      * @param {?Array.<!WebInspector.RemoteObjectProperty>} internalProperties
      */
     function callback(properties, internalProperties)
     {
         treeElement.removeChildren();
         if (!properties)
             return;
 
         extraProperties = extraProperties || [];
         for (var i = 0; i < extraProperties.length; ++i)
             properties.push(extraProperties[i]);
 
         WebInspector.ObjectPropertyTreeElement.populateWithProperties(treeElement, properties, internalProperties,
-            skipProto, targetValue || value, emptyPlaceholder);
+            skipProto, targetValue || value, linkifier, emptyPlaceholder);
     }
 
     if (flattenProtoChain)
         value.getAllProperties(false, callback);
     else
         WebInspector.RemoteObject.loadFromObjectPerProto(value, callback);
 }
 
 /**
  * @param {!TreeElement} treeNode
  * @param {!Array.<!WebInspector.RemoteObjectProperty>} properties
  * @param {?Array.<!WebInspector.RemoteObjectProperty>} internalProperties
  * @param {boolean} skipProto
  * @param {?WebInspector.RemoteObject} value
+ * @param {?WebInspector.Linkifier=} linkifier
  * @param {?string=} emptyPlaceholder
  */
-WebInspector.ObjectPropertyTreeElement.populateWithProperties = function(treeNode, properties, internalProperties, skipProto, value, emptyPlaceholder) {
+WebInspector.ObjectPropertyTreeElement.populateWithProperties = function(treeNode, properties, internalProperties, skipProto, value, linkifier, emptyPlaceholder) {
     properties.sort(WebInspector.ObjectPropertiesSection.CompareProperties);
 
     for (var i = 0; i < properties.length; ++i) {
         var property = properties[i];
         if (skipProto && property.name === "__proto__")
             continue;
         if (property.isAccessorProperty()) {
             if (property.name !== "__proto__" && property.getter) {
                 property.parentObject = value;
-                treeNode.appendChild(new WebInspector.ObjectPropertyTreeElement(property));
+                treeNode.appendChild(new WebInspector.ObjectPropertyTreeElement(property, linkifier));
             }
             if (property.isOwn) {
                 if (property.getter) {
                     var getterProperty = new WebInspector.RemoteObjectProperty("get " + property.name, property.getter);
                     getterProperty.parentObject = value;
-                    treeNode.appendChild(new WebInspector.ObjectPropertyTreeElement(getterProperty));
+                    treeNode.appendChild(new WebInspector.ObjectPropertyTreeElement(getterProperty, linkifier));
                 }
                 if (property.setter) {
                     var setterProperty = new WebInspector.RemoteObjectProperty("set " + property.name, property.setter);
                     setterProperty.parentObject = value;
-                    treeNode.appendChild(new WebInspector.ObjectPropertyTreeElement(setterProperty));
+                    treeNode.appendChild(new WebInspector.ObjectPropertyTreeElement(setterProperty, linkifier));
                 }
             }
         } else {
             property.parentObject = value;
-            treeNode.appendChild(new WebInspector.ObjectPropertyTreeElement(property));
+            treeNode.appendChild(new WebInspector.ObjectPropertyTreeElement(property, linkifier));
         }
     }
     if (internalProperties) {
         for (var i = 0; i < internalProperties.length; i++) {
             internalProperties[i].parentObject = value;
-            var treeElement = new WebInspector.ObjectPropertyTreeElement(internalProperties[i]);
+            var treeElement = new WebInspector.ObjectPropertyTreeElement(internalProperties[i], linkifier);
             if (internalProperties[i].name === "[[Entries]]") {
                 treeElement.setExpandable(true);
                 treeElement.expand();
             }
             treeNode.appendChild(treeElement);
         }
     }
     if (value && value.type === "function") {
         // Whether function has TargetFunction internal property.
         // This is a simple way to tell that the function is actually a bound function (we are not told).
         // Bound function never has inner scope and doesn't need corresponding UI node.
         var hasTargetFunction = false;
 
         if (internalProperties) {
             for (var i = 0; i < internalProperties.length; i++) {
                 if (internalProperties[i].name === "[[TargetFunction]]") {
                     hasTargetFunction = true;
                     break;
                 }
             }
         }
         if (!hasTargetFunction)
-            treeNode.appendChild(new WebInspector.FunctionScopeMainTreeElement(value));
+            treeNode.appendChild(new WebInspector.FunctionScopeMainTreeElement(value, linkifier));
     }
     WebInspector.ObjectPropertyTreeElement._appendEmptyPlaceholderIfNeeded(treeNode, emptyPlaceholder);
 }
 
 /**
  * @param {!TreeElement} treeNode
  * @param {?string=} emptyPlaceholder
  */
 WebInspector.ObjectPropertyTreeElement._appendEmptyPlaceholderIfNeeded = function(treeNode, emptyPlaceholder)
 {
@@ skipping 28 matching lines @@
         object.getProperty(propertyPath, callback);
     }
 
     return rootElement;
 }
 
 /**
  * @constructor
  * @extends {TreeElement}
  * @param {!WebInspector.RemoteObject} remoteObject
+ * @param {?WebInspector.Linkifier=} linkifier
  */
-WebInspector.FunctionScopeMainTreeElement = function(remoteObject)
+WebInspector.FunctionScopeMainTreeElement = function(remoteObject, linkifier)
 {
     TreeElement.call(this, "<function scope>", true);
     this.toggleOnClick = true;
     this.selectable = false;
     this._remoteObject = remoteObject;
+    this._linkifier = linkifier;
 }
 
 WebInspector.FunctionScopeMainTreeElement.prototype = {
     onpopulate: function()
     {
         /**
          * @param {?WebInspector.DebuggerModel.FunctionDetails} response
          * @this {WebInspector.FunctionScopeMainTreeElement}
          */
         function didGetDetails(response)
@@ skipping 37 matching lines @@
                     console.error("Unknown scope type: " + scope.type);
                     continue;
                 }
 
                 var runtimeModel = this._remoteObject.target().runtimeModel;
                 if (isTrueObject) {
                     var remoteObject = runtimeModel.createRemoteObject(scope.object);
                     var property = new WebInspector.RemoteObjectProperty(title, remoteObject);
                     property.writable = false;
                     property.parentObject = null;
-                    this.appendChild(new WebInspector.ObjectPropertyTreeElement(property));
+                    this.appendChild(new WebInspector.ObjectPropertyTreeElement(property, this._linkifier));
                 } else {
                     var scopeRef = new WebInspector.ScopeRef(i, undefined);
                     var remoteObject = runtimeModel.createScopeRemoteObject(scope.object, scopeRef);
                     var scopeTreeElement = new WebInspector.ScopeTreeElement(title, remoteObject);
                     this.appendChild(scopeTreeElement);
                 }
             }
 
             WebInspector.ObjectPropertyTreeElement._appendEmptyPlaceholderIfNeeded(this, WebInspector.UIString("No Scopes"));
         }
@@ skipping 14 matching lines @@
 {
     TreeElement.call(this, title, true);
     this.toggleOnClick = true;
     this.selectable = false;
     this._remoteObject = remoteObject;
 }
 
 WebInspector.ScopeTreeElement.prototype = {
     onpopulate: function()
     {
-        WebInspector.ObjectPropertyTreeElement._populate(this, this._remoteObject, false);
+        WebInspector.ObjectPropertyTreeElement._populate(this, this._remoteObject, false, null);
     },
 
     __proto__: TreeElement.prototype
 }
 
 /**
  * @constructor
  * @extends {TreeElement}
  * @param {!WebInspector.RemoteObject} object
  * @param {number} fromIndex
  * @param {number} toIndex
  * @param {number} propertyCount
+ * @param {?WebInspector.Linkifier=} linkifier
  */
-WebInspector.ArrayGroupingTreeElement = function(object, fromIndex, toIndex, propertyCount)
+WebInspector.ArrayGroupingTreeElement = function(object, fromIndex, toIndex, propertyCount, linkifier)
 {
     TreeElement.call(this, String.sprintf("[%d \u2026 %d]", fromIndex, toIndex), true);
     this.toggleOnClick = true;
     this.selectable = false;
     this._fromIndex = fromIndex;
     this._toIndex = toIndex;
     this._object = object;
     this._readOnly = true;
     this._propertyCount = propertyCount;
+    this._linkifier = linkifier;
 }
 
 WebInspector.ArrayGroupingTreeElement._bucketThreshold = 100;
 WebInspector.ArrayGroupingTreeElement._sparseIterationThreshold = 250000;
 WebInspector.ArrayGroupingTreeElement._getOwnPropertyNamesThreshold = 500000;
 
 /**
  * @param {!TreeElement} treeNode
  * @param {!WebInspector.RemoteObject} object
  * @param {number} fromIndex
  * @param {number} toIndex
+ * @param {?WebInspector.Linkifier=} linkifier
  */
-WebInspector.ArrayGroupingTreeElement._populateArray = function(treeNode, object, fromIndex, toIndex)
+WebInspector.ArrayGroupingTreeElement._populateArray = function(treeNode, object, fromIndex, toIndex, linkifier)
 {
-    WebInspector.ArrayGroupingTreeElement._populateRanges(treeNode, object, fromIndex, toIndex, true);
+    WebInspector.ArrayGroupingTreeElement._populateRanges(treeNode, object, fromIndex, toIndex, true, linkifier);
 }
 
 /**
  * @param {!TreeElement} treeNode
  * @param {!WebInspector.RemoteObject} object
  * @param {number} fromIndex
  * @param {number} toIndex
  * @param {boolean} topLevel
+ * @param {?WebInspector.Linkifier=} linkifier
  * @this {WebInspector.ArrayGroupingTreeElement}
  */
-WebInspector.ArrayGroupingTreeElement._populateRanges = function(treeNode, object, fromIndex, toIndex, topLevel)
+WebInspector.ArrayGroupingTreeElement._populateRanges = function(treeNode, object, fromIndex, toIndex, topLevel, linkifier)
 {
     object.callFunctionJSON(packRanges, [
         { value: fromIndex },
         { value: toIndex },
         { value: WebInspector.ArrayGroupingTreeElement._bucketThreshold },
         { value: WebInspector.ArrayGroupingTreeElement._sparseIterationThreshold },
         { value: WebInspector.ArrayGroupingTreeElement._getOwnPropertyNamesThreshold }
     ], callback);
 
     /**
@@ skipping 73 matching lines @@
 
         return { ranges: ranges, skipGetOwnPropertyNames: skipGetOwnPropertyNames };
     }
 
     function callback(result)
     {
         if (!result)
             return;
         var ranges = /** @type {!Array.<!Array.<number>>} */ (result.ranges);
         if (ranges.length === 1) {
-            WebInspector.ArrayGroupingTreeElement._populateAsFragment(treeNode, object, ranges[0][0], ranges[0][1]);
+            WebInspector.ArrayGroupingTreeElement._populateAsFragment(treeNode, object, ranges[0][0], ranges[0][1], linkifier);
         } else {
             for (var i = 0; i < ranges.length; ++i) {
                 var fromIndex = ranges[i][0];
                 var toIndex = ranges[i][1];
                 var count = ranges[i][2];
                 if (fromIndex === toIndex)
-                    WebInspector.ArrayGroupingTreeElement._populateAsFragment(treeNode, object, fromIndex, toIndex);
+                    WebInspector.ArrayGroupingTreeElement._populateAsFragment(treeNode, object, fromIndex, toIndex, linkifier);
                 else
-                    treeNode.appendChild(new WebInspector.ArrayGroupingTreeElement(object, fromIndex, toIndex, count));
+                    treeNode.appendChild(new WebInspector.ArrayGroupingTreeElement(object, fromIndex, toIndex, count, linkifier));
             }
         }
         if (topLevel)
-            WebInspector.ArrayGroupingTreeElement._populateNonIndexProperties(treeNode, object, result.skipGetOwnPropertyNames);
+            WebInspector.ArrayGroupingTreeElement._populateNonIndexProperties(treeNode, object, result.skipGetOwnPropertyNames, linkifier);
     }
 }
 
 /**
  * @param {!TreeElement} treeNode
  * @param {!WebInspector.RemoteObject} object
  * @param {number} fromIndex
  * @param {number} toIndex
+ * @param {?WebInspector.Linkifier=} linkifier
  * @this {WebInspector.ArrayGroupingTreeElement}
  */
-WebInspector.ArrayGroupingTreeElement._populateAsFragment = function(treeNode, object, fromIndex, toIndex)
+WebInspector.ArrayGroupingTreeElement._populateAsFragment = function(treeNode, object, fromIndex, toIndex, linkifier)
 {
     object.callFunction(buildArrayFragment, [{value: fromIndex}, {value: toIndex}, {value: WebInspector.ArrayGroupingTreeElement._sparseIterationThreshold}], processArrayFragment.bind(this));
 
     /**
      * @suppressReceiverCheck
      * @this {Object}
      * @param {number=} fromIndex // must declare optional
      * @param {number=} toIndex // must declare optional
      * @param {number=} sparseIterationThreshold // must declare optional
      */
@@ skipping 31 matching lines @@
 
     /** @this {WebInspector.ArrayGroupingTreeElement} */
     function processProperties(properties, internalProperties)
     {
         if (!properties)
             return;
 
         properties.sort(WebInspector.ObjectPropertiesSection.CompareProperties);
         for (var i = 0; i < properties.length; ++i) {
             properties[i].parentObject = this._object;
-            var childTreeElement = new WebInspector.ObjectPropertyTreeElement(properties[i]);
+            var childTreeElement = new WebInspector.ObjectPropertyTreeElement(properties[i], linkifier);
             childTreeElement._readOnly = true;
             treeNode.appendChild(childTreeElement);
         }
     }
 }
 
 /**
  * @param {!TreeElement} treeNode
  * @param {!WebInspector.RemoteObject} object
  * @param {boolean} skipGetOwnPropertyNames
+ * @param {?WebInspector.Linkifier=} linkifier
  * @this {WebInspector.ArrayGroupingTreeElement}
  */
-WebInspector.ArrayGroupingTreeElement._populateNonIndexProperties = function(treeNode, object, skipGetOwnPropertyNames)
+WebInspector.ArrayGroupingTreeElement._populateNonIndexProperties = function(treeNode, object, skipGetOwnPropertyNames, linkifier)
 {
     object.callFunction(buildObjectFragment, [{value: skipGetOwnPropertyNames}], processObjectFragment.bind(this));
 
     /**
      * @param {boolean=} skipGetOwnPropertyNames
      * @suppressReceiverCheck
      * @this {Object}
      */
     function buildObjectFragment(skipGetOwnPropertyNames)
     {
@@ skipping 30 matching lines @@
      * @param {?Array.<!WebInspector.RemoteObjectProperty>=} internalProperties
      * @this {WebInspector.ArrayGroupingTreeElement}
      */
     function processProperties(properties, internalProperties)
     {
         if (!properties)
             return;
         properties.sort(WebInspector.ObjectPropertiesSection.CompareProperties);
         for (var i = 0; i < properties.length; ++i) {
             properties[i].parentObject = this._object;
-            var childTreeElement = new WebInspector.ObjectPropertyTreeElement(properties[i]);
+            var childTreeElement = new WebInspector.ObjectPropertyTreeElement(properties[i], linkifier);
             childTreeElement._readOnly = true;
             treeNode.appendChild(childTreeElement);
         }
     }
 }
 
 WebInspector.ArrayGroupingTreeElement.prototype = {
     onpopulate: function()
     {
         if (this._propertyCount >= WebInspector.ArrayGroupingTreeElement._bucketThreshold) {
-            WebInspector.ArrayGroupingTreeElement._populateRanges(this, this._object, this._fromIndex, this._toIndex, false);
+            WebInspector.ArrayGroupingTreeElement._populateRanges(this, this._object, this._fromIndex, this._toIndex, false, this._linkifier);
             return;
         }
-        WebInspector.ArrayGroupingTreeElement._populateAsFragment(this, this._object, this._fromIndex, this._toIndex);
+        WebInspector.ArrayGroupingTreeElement._populateAsFragment(this, this._object, this._fromIndex, this._toIndex, this._linkifier);
     },
 
     onattach: function()
     {
         this.listItemElement.classList.add("object-properties-section-name");
     },
 
     __proto__: TreeElement.prototype
 }
 
@@ skipping 38 matching lines @@
         matches = /[^(]*(\([^)]*)/.exec(text);
     }
     var match = matches ? matches[1] : null;
     return match ? match.replace(/\n/g, " ") + ")" : (text || "");
 }
 
 /**
  * @param {!WebInspector.RemoteObject} value
  * @param {boolean} wasThrown
  * @param {!Element=} parentElement
+ * @param {?WebInspector.Linkifier=} linkifier
  * @return {!Element}
  */
-WebInspector.ObjectPropertiesSection.createValueElementWithCustomSupport = function(value, wasThrown, parentElement)
+WebInspector.ObjectPropertiesSection.createValueElementWithCustomSupport = function(value, wasThrown, parentElement, linkifier)
 {
     if (value.customPreview()) {
         var result = (new WebInspector.CustomPreviewComponent(value)).element;
         result.classList.add("object-properties-section-custom-section");
         return result
     }
-    return WebInspector.ObjectPropertiesSection.createValueElement(value, wasThrown, parentElement);
+    return WebInspector.ObjectPropertiesSection.createValueElement(value, wasThrown, parentElement, linkifier);
 }
 
 /**
  * @param {!WebInspector.RemoteObject} value
  * @param {boolean} wasThrown
  * @param {!Element=} parentElement
+ * @param {?WebInspector.Linkifier=} linkifier
  * @return {!Element}
  */
-WebInspector.ObjectPropertiesSection.createValueElement = function(value, wasThrown, parentElement)
+WebInspector.ObjectPropertiesSection.createValueElement = function(value, wasThrown, parentElement, linkifier)
 {
     var valueElement = createElementWithClass("span", "value");
     var type = value.type;
     var subtype = value.subtype;
     var description = value.description;
     var prefix;
     var valueText;
     var suffix;
     if (wasThrown) {
         prefix = "[Exception: ";
@@ skipping 33 matching lines @@
 
     if (type === "object" && subtype === "node" && description) {
         WebInspector.DOMPresentationUtils.createSpansForNodeTitle(valueElement, description);
         valueElement.addEventListener("click", mouseClick, false);
         valueElement.addEventListener("mousemove", mouseMove, false);
         valueElement.addEventListener("mouseleave", mouseLeave, false);
     } else {
         valueElement.title = description || "";
     }
 
+    if (type === "object" && subtype === "internal#location" && linkifier) {
+        var loc = value.value;

[dgozman, 2016/07/07 19:34:26]

location

[kozy, 2016/07/07 21:33:28]

Done.

+        return linkifier.linkifyScriptLocation(value.target(), loc.scriptId, "", loc.lineNumber, loc.columnNumber);
+    }
+
     function mouseMove()
     {
         WebInspector.DOMModel.highlightObjectAsDOMNode(value);
     }
 
     function mouseLeave()
     {
         WebInspector.DOMModel.hideDOMNodeHighlight();
     }
 
@@ skipping 176 matching lines @@
 
             result = currentName + (result ? "." + result : "");
             current = current.parent;
         }
         var treeOutlineId = treeElement.treeOutline[WebInspector.ObjectPropertiesSectionExpandController._treeOutlineId];
         result = treeOutlineId + (result ? ":" + result : "");
         treeElement[WebInspector.ObjectPropertiesSectionExpandController._cachedPathSymbol] = result;
         return result;
     }
 }