DevTools: ConsoleViewMessage pass linkifier into formatting functions

third_party/WebKit/Source/devtools/front_end/console/ConsoleViewMessage.js

 /*
  * Copyright (C) 2011 Google Inc.  All rights reserved.
  * Copyright (C) 2007, 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
@@ skipping 166 matching lines @@
                 flatValues.push(rowValue[columnNames[j]]);
         }
         columnNames.unshift(WebInspector.UIString("(index)"));
 
         if (flatValues.length) {
             this._dataGrid = WebInspector.SortableDataGrid.create(columnNames, flatValues);
 
             var formattedResult = createElement("span");
             var tableElement = formattedResult.createChild("div", "console-message-formatted-table");
             var dataGridContainer = tableElement.createChild("span");
-            tableElement.appendChild(this._formatParameter(table, true));
+            tableElement.appendChild(this._formatParameter(table, this._linkifier, true));
             dataGridContainer.appendChild(this._dataGrid.element);
             formattedMessage.appendChild(formattedResult);
             this._dataGrid.renderInline();
         }
         return formattedMessage;
     },
 
     /**
      * @return {!Element}
      */
@@ skipping 20 matching lines @@
                 var obj = consoleMessage.parameters ? consoleMessage.parameters[0] : undefined;
                 var args = ["%O", obj];
                 messageElement = this._format(args);
                 break;
             case WebInspector.ConsoleMessage.MessageType.Profile:
             case WebInspector.ConsoleMessage.MessageType.ProfileEnd:
                 messageElement = this._format([consoleMessage.messageText]);
                 break;
             default:
                 if (consoleMessage.parameters && consoleMessage.parameters.length === 1 && consoleMessage.parameters[0].type === "string")
-                    messageElement = this._tryFormatAsError(/** @type {string} */(consoleMessage.parameters[0].value));
+                    messageElement = this._tryFormatAsError(/** @type {string} */(consoleMessage.parameters[0].value), this._linkifier);
                 var args = consoleMessage.parameters || [consoleMessage.messageText];
                 messageElement = messageElement || this._format(args);
             }
         } else if (consoleMessage.source === WebInspector.ConsoleMessage.MessageSource.Network) {
             if (consoleMessage.request) {
                 messageElement = createElement("span");
                 if (consoleMessage.level === WebInspector.ConsoleMessage.MessageLevel.Error || consoleMessage.level === WebInspector.ConsoleMessage.MessageLevel.RevokedError) {
                     messageElement.createTextChildren(consoleMessage.request.requestMethod, " ");
                     messageElement.appendChild(WebInspector.Linkifier.linkifyUsingRevealer(consoleMessage.request, consoleMessage.request.url, consoleMessage.request.url));
                     if (consoleMessage.request.failed)
@@ skipping 155 matching lines @@
             if (parameters.length)
                 formattedResult.createTextChild(" ");
         }
 
         // Single parameter, or unused substitutions from above.
         for (var i = 0; i < parameters.length; ++i) {
             // Inline strings when formatting.
             if (shouldFormatMessage && parameters[i].type === "string")
                 formattedResult.appendChild(WebInspector.linkifyStringAsFragment(parameters[i].description));
             else
-                formattedResult.appendChild(this._formatParameter(parameters[i], false, true, showUndefinedsInArrays));
+                formattedResult.appendChild(this._formatParameter(parameters[i], this._linkifier, false, true, showUndefinedsInArrays));
             if (i < parameters.length - 1)
                 formattedResult.createTextChild(" ");
         }
         return formattedResult;
     },
 
     /**
      * @param {!WebInspector.RemoteObject} output
+     * @param {!WebInspector.Linkifier} linkifier
      * @param {boolean=} forceObjectFormat
      * @param {boolean=} includePreview
      * @param {boolean=} showUndefinedsInArrays
      * @return {!Element}
      */
-    _formatParameter: function(output, forceObjectFormat, includePreview, showUndefinedsInArrays)
+    _formatParameter: function(output, linkifier, forceObjectFormat, includePreview, showUndefinedsInArrays)
     {
         if (output.customPreview())
             return (new WebInspector.CustomPreviewComponent(output)).element;
 
         var type = forceObjectFormat ? "object" : (output.subtype || output.type);
         var element;
         switch (type) {
         case "array":
         case "typedarray":
-            element = this._formatParameterAsArray(output, showUndefinedsInArrays);
+            element = this._formatParameterAsArray(output, linkifier, showUndefinedsInArrays);
             break;
         case "error":
-            element = this._formatParameterAsError(output);
+            element = this._formatParameterAsError(output, linkifier);
             break;
         case "function":
         case "generator":
             element = this._formatParameterAsFunction(output, includePreview);
             break;
         case "iterator":
         case "map":
         case "object":
         case "promise":
         case "proxy":
         case "set":
-            element = this._formatParameterAsObject(output, includePreview);
+            element = this._formatParameterAsObject(output, linkifier, includePreview);
             break;
         case "node":
-            element = this._formatParameterAsNode(output);
+            element = this._formatParameterAsNode(output, linkifier);
             break;
         case "string":
             element = this._formatParameterAsString(output);
             break;
         case "boolean":
         case "date":
         case "null":
         case "number":
         case "regexp":
         case "symbol":
@@ skipping 17 matching lines @@
     {
         var result = createElement("span");
         result.createTextChild(obj.description || "");
         if (obj.objectId)
             result.addEventListener("contextmenu", this._contextMenuEventFired.bind(this, obj), false);
         return result;
     },
 
     /**
      * @param {!WebInspector.RemoteObject} obj
+     * @param {!WebInspector.Linkifier} linkifier
      * @param {boolean=} includePreview
      * @return {!Element}
      */
-    _formatParameterAsObject: function(obj, includePreview)
+    _formatParameterAsObject: function(obj, linkifier, includePreview)
     {
         var titleElement = createElement("span");
         if (includePreview && obj.preview) {
             titleElement.classList.add("console-object-preview");
             this._previewFormatter.appendObjectPreview(titleElement, obj.preview);
         } else if (obj.type === "function") {
             WebInspector.ObjectPropertiesSection.formatObjectAsFunction(obj, titleElement, false);
             titleElement.classList.add("object-value-function");
         } else {
             titleElement.createTextChild(obj.description || "");
         }
 
-        var section = new WebInspector.ObjectPropertiesSection(obj, titleElement, this._linkifier);
+        var section = new WebInspector.ObjectPropertiesSection(obj, titleElement, linkifier);
         section.element.classList.add("console-view-object-properties-section");
         section.enableContextMenu();
         return section.element;
     },
 
     /**
      * @param {!WebInspector.RemoteObject} func
      * @param {boolean=} includePreview
      * @return {!Element}
      */
@@ skipping 39 matching lines @@
     _renderPropertyPreviewOrAccessor: function(object, propertyPath)
     {
         var property = propertyPath.peekLast();
         if (property.type === "accessor")
             return this._formatAsAccessorProperty(object, propertyPath.map(property => property.name), false);
         return this._previewFormatter.renderPropertyPreview(property.type, /** @type {string} */ (property.subtype), property.value);
     },
 
     /**
      * @param {!WebInspector.RemoteObject} object
+     * @param {!WebInspector.Linkifier} linkifier
      * @return {!Element}
      */
-    _formatParameterAsNode: function(object)
+    _formatParameterAsNode: function(object, linkifier)
     {
         var result = createElement("span");
         WebInspector.Renderer.renderPromise(object).then(appendRenderer.bind(this), failedToRender.bind(this));
         return result;
 
         /**
          * @param {!Element} rendererElement
          * @this {WebInspector.ConsoleViewMessage}
          */
         function appendRenderer(rendererElement)
         {
             result.appendChild(rendererElement);
             this._formattedParameterAsNodeForTest();
         }
 
         /**
          * @this {WebInspector.ConsoleViewMessage}
          */
         function failedToRender()
         {
-            result.appendChild(this._formatParameterAsObject(object, false));
+            result.appendChild(this._formatParameterAsObject(object, linkifier, false));
         }
     },
 
     _formattedParameterAsNodeForTest: function()
     {
     },
 
     /**
      * @param {!WebInspector.RemoteObject} array
+     * @param {!WebInspector.Linkifier} linkifier
      * @param {boolean=} showUndefinedsInArrays
      * @return {!Element}
      */
-    _formatParameterAsArray: function(array, showUndefinedsInArrays)
+    _formatParameterAsArray: function(array, linkifier, showUndefinedsInArrays)
     {
         var isLongArray = array.arrayLength() > 100;
         if (!showUndefinedsInArrays || isLongArray)
-            return this._formatParameterAsObject(array, !showUndefinedsInArrays || !isLongArray);
+            return this._formatParameterAsObject(array, linkifier, !showUndefinedsInArrays || !isLongArray);
         var result = createElement("span");
         array.getAllProperties(false, printArrayResult.bind(this));
         return result;
 
         /**
          * @param {?Array.<!WebInspector.RemoteObjectProperty>} properties
          * @this {!WebInspector.ConsoleViewMessage}
          */
         function printArrayResult(properties)
         {
             if (!properties) {
-                result.appendChild(this._formatParameterAsObject(array, false));
+                result.appendChild(this._formatParameterAsObject(array, linkifier, false));
                 return;
             }
 
             var titleElement = createElement("span");
             var elements = {};
             for (var i = 0; i < properties.length; ++i) {
                 var property = properties[i];
                 var name = property.name;
                 if (isNaN(name))
                     continue;
@@ skipping 27 matching lines @@
 
                 titleElement.appendChild(element);
                 lastNonEmptyIndex = i;
                 if (i < length - 1)
                     titleElement.createTextChild(", ");
             }
             appendUndefined(titleElement, length);
 
             titleElement.createTextChild("]");
 
-            var section = new WebInspector.ObjectPropertiesSection(array, titleElement, this._linkifier);
+            var section = new WebInspector.ObjectPropertiesSection(array, titleElement, linkifier);
             section.element.classList.add("console-view-object-properties-section");
             section.enableContextMenu();
             result.appendChild(section.element);
         }
     },
 
     /**
      * @param {!WebInspector.RemoteObject} output
      * @return {!Element}
      */
     _formatParameterAsString: function(output)
     {
         var span = createElement("span");
         span.appendChild(WebInspector.linkifyStringAsFragment(output.description || ""));
 
         var result = createElement("span");
         result.createChild("span", "object-value-string-quote").textContent = "\"";
         result.appendChild(span);
         result.createChild("span", "object-value-string-quote").textContent = "\"";
         return result;
     },
 
     /**
      * @param {!WebInspector.RemoteObject} output
+     * @param {!WebInspector.Linkifier} linkifier
      * @return {!Element}
      */
-    _formatParameterAsError: function(output)
+    _formatParameterAsError: function(output, linkifier)
     {
         var result = createElement("span");
-        var errorSpan = this._tryFormatAsError(output.description || "");
+        var errorSpan = this._tryFormatAsError(output.description || "", linkifier);
         result.appendChild(errorSpan ? errorSpan : WebInspector.linkifyStringAsFragment(output.description || ""));
         return result;
     },
 
     /**
      * @param {!WebInspector.RemoteObject} output
      * @return {!Element}
      */
     _formatAsArrayEntry: function(output)
     {
@@ skipping 56 matching lines @@
         var formatters = {};
 
         /**
          * @param {boolean} force
          * @param {!WebInspector.RemoteObject} obj
          * @return {!Element}
          * @this {WebInspector.ConsoleViewMessage}
          */
         function parameterFormatter(force, obj)
         {
-            return this._formatParameter(obj, force, false, showUndefinedsInArrays);
+            return this._formatParameter(obj, this._linkifier, force, false, showUndefinedsInArrays);
         }
 
         function stringFormatter(obj)
         {
             return obj.description;
         }
 
         function floatFormatter(obj)
         {
             if (typeof obj.value !== "number")
@@ skipping 327 matching lines @@
     /**
      * @return {!Element}
      */
     searchHighlightNode: function(index)
     {
         return this._searchHighlightNodes[index];
     },
 
     /**
      * @param {string} string
+     * @param {!WebInspector.Linkifier} linkifier
      * @return {?Element}
      */
-    _tryFormatAsError: function(string)
+    _tryFormatAsError: function(string, linkifier)
     {
         /**
          * @param {string} prefix
          */
         function startsWith(prefix)
         {
             return string.startsWith(prefix);
         }
 
         var errorPrefixes = ["EvalError", "ReferenceError", "SyntaxError", "TypeError", "RangeError", "Error", "URIError"];
@@ skipping 45 matching lines @@
             links.push({url: url, positionLeft: position + left, positionRight: position + right, lineNumber: splitResult.lineNumber, columnNumber: splitResult.columnNumber});
         }
 
         if (!links.length)
             return null;
 
         var formattedResult = createElement("span");
         var start = 0;
         for (var i = 0; i < links.length; ++i) {
             formattedResult.appendChild(WebInspector.linkifyStringAsFragment(string.substring(start, links[i].positionLeft)));
-            formattedResult.appendChild(this._linkifier.linkifyScriptLocation(target, null, links[i].url, links[i].lineNumber, links[i].columnNumber));
+            formattedResult.appendChild(linkifier.linkifyScriptLocation(target, null, links[i].url, links[i].lineNumber, links[i].columnNumber));
             start = links[i].positionRight;
         }
 
         if (start !== string.length)
             formattedResult.appendChild(WebInspector.linkifyStringAsFragment(string.substring(start)));
 
         return formattedResult;
     }
 };
 
@@ skipping 38 matching lines @@
     {
         if (!this._element) {
             WebInspector.ConsoleViewMessage.prototype.toMessageElement.call(this);
             this._element.classList.toggle("collapsed", this._collapsed);
         }
         return this._element;
     },
 
     __proto__: WebInspector.ConsoleViewMessage.prototype
 };