DevTools: ConsoleViewMessage rewrite signatures to isolate 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 28 matching lines @@
 {
     this._message = consoleMessage;
     this._linkifier = linkifier;
     this._repeatCount = 1;
     this._closeGroupDecorationCount = 0;
     this._nestingLevel = nestingLevel;
 
     /** @type {?WebInspector.DataGrid} */
     this._dataGrid = null;
 
-    /** @type {!Object.<string, function(!WebInspector.RemoteObject, !Element, boolean=)>} */
-    this._customFormatters = {
-        "array": this._formatParameterAsArray,
-        "typedarray": this._formatParameterAsArray,
-        "error": this._formatParameterAsError,
-        "function": this._formatParameterAsFunction,
-        "generator": this._formatParameterAsObject,
-        "iterator": this._formatParameterAsObject,
-        "map": this._formatParameterAsObject,
-        "node": this._formatParameterAsNode,
-        "object": this._formatParameterAsObject,
-        "promise": this._formatParameterAsObject,
-        "proxy": this._formatParameterAsObject,
-        "set": this._formatParameterAsObject,
-        "string": this._formatParameterAsString
-    };
     this._previewFormatter = new WebInspector.RemoteObjectPreviewFormatter();
     this._searchRegex = null;
 }
 
 WebInspector.ConsoleViewMessage.prototype = {
     /**
      * @return {?WebInspector.Target}
      */
     _target: function()
     {
@@ skipping 64 matching lines @@
 
     /**
      * @param {!WebInspector.ConsoleMessage} consoleMessage
      * @return {!Element}
      */
     _buildTableMessage: function(consoleMessage)
     {
         var formattedMessage = createElement("span");
         WebInspector.appendStyle(formattedMessage, "components/objectValue.css");
         formattedMessage.className = "console-message-text source-code";
-        var anchorElement = this._buildMessageAnchor(consoleMessage);
+        var anchorElement = this._buildMessageAnchor(consoleMessage, this._linkifier);
         if (anchorElement)
             formattedMessage.appendChild(anchorElement);
 
         var table = consoleMessage.parameters && consoleMessage.parameters.length ? consoleMessage.parameters[0] : null;
         if (table)
             table = this._parameterToRemoteObject(table, this._target());
         if (!table || !table.preview)
             return formattedMessage;
 
         var columnNames = [];
@@ skipping 34 matching lines @@
             for (var j = 0; j < columnNames.length; ++j)
                 flatValues.push(rowValue[columnNames[j]]);
         }
         columnNames.unshift(WebInspector.UIString("(index)"));
 
         if (flatValues.length) {
             this._dataGrid = WebInspector.SortableDataGrid.create(columnNames, flatValues);
 
             var tableElement = formattedMessage.createChild("div", "console-message-formatted-table");
             var dataGridContainer = tableElement.createChild("span");
-            tableElement.appendChild(this._formatParameter(table, true, false));
+            tableElement.appendChild(this._formatParameter(consoleMessage, this._linkifier, table, true, false));
             dataGridContainer.appendChild(this._dataGrid.element);
             this._dataGrid.renderInline();
         }
         return formattedMessage;
     },
 
     /**
      * @param {!WebInspector.ConsoleMessage} consoleMessage
+     * @param {!WebInspector.Linkifier} linkifier
      * @return {!Element}
      */
-    _buildMessage: function(consoleMessage)
+    _buildMessage: function(consoleMessage, linkifier)
     {
         var messageElement;
         if (consoleMessage.source === WebInspector.ConsoleMessage.MessageSource.ConsoleAPI) {
             switch (consoleMessage.type) {
             case WebInspector.ConsoleMessage.MessageType.Trace:
-                messageElement = this._format(consoleMessage.parameters || ["console.trace"]);
+                messageElement = this._format(consoleMessage, linkifier, consoleMessage.parameters || ["console.trace"]);
                 break;
             case WebInspector.ConsoleMessage.MessageType.Clear:
                 messageElement = createElementWithClass("span", "console-info");
                 messageElement.textContent = WebInspector.UIString("Console was cleared");
                 break;
             case WebInspector.ConsoleMessage.MessageType.Assert:
                 var args = [WebInspector.UIString("Assertion failed:")];
                 if (consoleMessage.parameters)
                     args = args.concat(consoleMessage.parameters);
-                messageElement = this._format(args);
+                messageElement = this._format(consoleMessage, linkifier, args);
                 break;
             case WebInspector.ConsoleMessage.MessageType.Dir:
                 var obj = consoleMessage.parameters ? consoleMessage.parameters[0] : undefined;
                 var args = ["%O", obj];
-                messageElement = this._format(args);
+                messageElement = this._format(consoleMessage, linkifier, args);
                 break;
             case WebInspector.ConsoleMessage.MessageType.Profile:
             case WebInspector.ConsoleMessage.MessageType.ProfileEnd:
-                messageElement = this._format([consoleMessage.messageText]);
+                messageElement = this._format(consoleMessage, linkifier, [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(consoleMessage.target(), linkifier, /** @type {string} */(consoleMessage.parameters[0].value));
                 var args = consoleMessage.parameters || [consoleMessage.messageText];
-                messageElement = messageElement || this._format(args);
+                messageElement = messageElement || this._format(consoleMessage, linkifier, 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)
                         messageElement.createTextChildren(" ", consoleMessage.request.localizedFailDescription);
                     else
                         messageElement.createTextChildren(" ", String(consoleMessage.request.statusCode), " (", consoleMessage.request.statusText, ")");
                 } else {
                     var fragment = WebInspector.linkifyStringAsFragmentWithCustomLinkifier(consoleMessage.messageText, linkifyRequest.bind(consoleMessage));
                     messageElement.appendChild(fragment);
                 }
             } else {
-                messageElement = this._format([consoleMessage.messageText]);
+                messageElement = this._format(consoleMessage, linkifier, [consoleMessage.messageText]);
             }
         } else {
             var args = consoleMessage.parameters || [consoleMessage.messageText];
-            messageElement = this._format(args);
+            messageElement = this._format(consoleMessage, linkifier, args);
         }
 
         var formattedMessage = createElement("span");
         WebInspector.appendStyle(formattedMessage, "components/objectValue.css");
         formattedMessage.className = "console-message-text source-code";
-        var anchorElement = this._buildMessageAnchor(consoleMessage);
+        var anchorElement = this._buildMessageAnchor(consoleMessage, linkifier);
         if (anchorElement)
             formattedMessage.appendChild(anchorElement);
         formattedMessage.appendChild(messageElement);
 
         if (!!consoleMessage.stackTrace && (consoleMessage.source === WebInspector.ConsoleMessage.MessageSource.Network || consoleMessage.level === WebInspector.ConsoleMessage.MessageLevel.Error || consoleMessage.level === WebInspector.ConsoleMessage.MessageLevel.RevokedError || consoleMessage.type === WebInspector.ConsoleMessage.MessageType.Trace || consoleMessage.level === WebInspector.ConsoleMessage.MessageLevel.Warning))
-            formattedMessage = this._buildMessageStackTrace(formattedMessage, consoleMessage, this._linkifier);
+            formattedMessage = this._buildMessageStackTrace(formattedMessage, consoleMessage, linkifier);
         return formattedMessage;
 
         /**
          * @param {string} title
          * @return {!Element}
          * @this {WebInspector.ConsoleMessage}
          */
         function linkifyRequest(title)
         {
             return WebInspector.Linkifier.linkifyUsingRevealer(/** @type {!WebInspector.NetworkRequest} */ (this.request), title, this.request.url);
         }
     },
 
     /**
      * @param {!WebInspector.ConsoleMessage} consoleMessage
+     * @param {!WebInspector.Linkifier} linkifier
      * @return {?Element}
      */
-    _buildMessageAnchor: function(consoleMessage)
+    _buildMessageAnchor: function(consoleMessage, linkifier)
     {
         var anchorElement = null;
         if (consoleMessage.source !== WebInspector.ConsoleMessage.MessageSource.Network || consoleMessage.request) {
-            if (consoleMessage.scriptId) {
-                anchorElement = this._linkifyScriptId(consoleMessage.scriptId, consoleMessage.url || "", consoleMessage.line, consoleMessage.column);
-            } else {
-                if (consoleMessage.stackTrace && consoleMessage.stackTrace.callFrames.length)
-                    anchorElement = this._linkifyStackTraceTopFrame(consoleMessage.stackTrace);
-                else if (consoleMessage.url && consoleMessage.url !== "undefined")
-                    anchorElement = this._linkifyLocation(consoleMessage.url, consoleMessage.line, consoleMessage.column);
-            }
+            if (consoleMessage.scriptId)
+                anchorElement = this._linkifyScriptId(linkifier, consoleMessage);
+            else if (consoleMessage.stackTrace && consoleMessage.stackTrace.callFrames.length)
+                anchorElement = this._linkifyStackTraceTopFrame(linkifier, consoleMessage);
+            else if (consoleMessage.url && consoleMessage.url !== "undefined")
+                anchorElement = this._linkifyLocation(linkifier, consoleMessage);
         } else if (consoleMessage.url) {
             var url = consoleMessage.url;
             var isExternal = !WebInspector.resourceForURL(url) && !WebInspector.networkMapping.uiSourceCodeForURLForAnyTarget(url);
             anchorElement = WebInspector.linkifyURLAsNode(url, url, "console-message-url", isExternal);
         }
 
         // Append a space to prevent the anchor text from being glued to the console message when the user selects and copies the console messages.
         if (anchorElement)
             anchorElement.appendChild(createTextNode(" "));
         return anchorElement;
@@ skipping 45 matching lines @@
         clickableElement.addEventListener("click", toggleStackTrace, false);
         triangleElement.addEventListener("click", toggleStackTrace, false);
         if (consoleMessage.type === WebInspector.ConsoleMessage.MessageType.Trace)
             expandStackTrace(true);
 
         toggleElement._expandStackTraceForTest = expandStackTrace.bind(null, true);
         return toggleElement;
     },
 
     /**
-     * @param {string} url
-     * @param {number} lineNumber
-     * @param {number} columnNumber
+     * @param {!WebInspector.Linkifier} linkifier
+     * @param {!WebInspector.ConsoleMessage} consoleMessage
      * @return {?Element}
      */
-    _linkifyLocation: function(url, lineNumber, columnNumber)
+    _linkifyLocation: function(linkifier, consoleMessage)
     {
-        var target = this._target();
+        var target = consoleMessage.target();
         if (!target)
             return null;
-        return this._linkifier.linkifyScriptLocation(target, null, url, lineNumber, columnNumber, "console-message-url");
+        return linkifier.linkifyScriptLocation(target, null, consoleMessage.url || "", consoleMessage.line, consoleMessage.column, "console-message-url");
     },
 
     /**
-     * @param {!RuntimeAgent.StackTrace} stackTrace
+     * @param {!WebInspector.Linkifier} linkifier
+     * @param {!WebInspector.ConsoleMessage} consoleMessage
      * @return {?Element}
      */
-    _linkifyStackTraceTopFrame: function(stackTrace)
+    _linkifyStackTraceTopFrame: function(linkifier, consoleMessage)
     {
-        var target = this._target();
+        var target = consoleMessage.target();
         if (!target)
             return null;
-        return this._linkifier.linkifyStackTraceTopFrame(target, stackTrace, "console-message-url");
+        return linkifier.linkifyStackTraceTopFrame(target, /** @type {!RuntimeAgent.StackTrace} **/ (consoleMessage.stackTrace), "console-message-url");
     },
 
     /**
-     * @param {string} scriptId
-     * @param {string} url
-     * @param {number} lineNumber
-     * @param {number} columnNumber
+     * @param {!WebInspector.Linkifier} linkifier
+     * @param {!WebInspector.ConsoleMessage} consoleMessage
      * @return {?Element}
      */
-    _linkifyScriptId: function(scriptId, url, lineNumber, columnNumber)
+    _linkifyScriptId: function(linkifier, consoleMessage)
     {
-        var target = this._target();
+        var target = consoleMessage.target();
         if (!target)
             return null;
-        return this._linkifier.linkifyScriptLocation(target, scriptId, url, lineNumber, columnNumber, "console-message-url");
+        return linkifier.linkifyScriptLocation(target, consoleMessage.scriptId, consoleMessage.url || "", consoleMessage.line, consoleMessage.column, "console-message-url");
     },
 
     /**
      * @param {!WebInspector.RemoteObject|!Object|string} parameter
      * @param {?WebInspector.Target} target
      * @return {!WebInspector.RemoteObject}
      */
     _parameterToRemoteObject: function(parameter, target)
     {
         if (parameter instanceof WebInspector.RemoteObject)
             return parameter;
         if (!target)
             return WebInspector.RemoteObject.fromLocalObject(parameter);
         if (typeof parameter === "object")
             return target.runtimeModel.createRemoteObject(parameter);
         return target.runtimeModel.createRemoteObjectFromPrimitiveValue(parameter);
     },
 
     /**
+     * @param {!WebInspector.ConsoleMessage} consoleMessage
+     * @param {!WebInspector.Linkifier} linkifier
      * @param {!Array.<!WebInspector.RemoteObject|string>} parameters
      * @return {!Element}
      */
-    _format: function(parameters)
+    _format: function(consoleMessage, linkifier, parameters)
     {
         // This node is used like a Builder. Values are continually appended onto it.
         var formattedResult = createElement("span");
         if (!parameters.length)
             return formattedResult;
 
         // Formatting code below assumes that parameters are all wrappers whereas frontend console
         // API allows passing arbitrary values as messages (strings, numbers, etc.). Wrap them here.
         // FIXME: Only pass runtime wrappers here.
         for (var i = 0; i < parameters.length; ++i)
-            parameters[i] = this._parameterToRemoteObject(parameters[i], this._target());
+            parameters[i] = this._parameterToRemoteObject(parameters[i], consoleMessage.target());
 
         // There can be string log and string eval result. We distinguish between them based on message type.
-        var shouldFormatMessage = WebInspector.RemoteObject.type((/** @type {!Array.<!WebInspector.RemoteObject>} **/ (parameters))[0]) === "string" && (this._message.type !== WebInspector.ConsoleMessage.MessageType.Result || this._message.level === WebInspector.ConsoleMessage.MessageLevel.Error || this._message.level === WebInspector.ConsoleMessage.MessageLevel.RevokedError);
+        var messageType = consoleMessage.type;
+        var shouldFormatMessage = WebInspector.RemoteObject.type((/** @type {!Array.<!WebInspector.RemoteObject>} **/ (parameters))[0]) === "string" && (messageType !== WebInspector.ConsoleMessage.MessageType.Result || consoleMessage.level === WebInspector.ConsoleMessage.MessageLevel.Error || consoleMessage.level === WebInspector.ConsoleMessage.MessageLevel.RevokedError);
 
         // Multiple parameters with the first being a format string. Save unused substitutions.
         if (shouldFormatMessage) {
-            var result = this._formatWithSubstitutionString(/** @type {string} **/ (parameters[0].description), parameters.slice(1), formattedResult);
+            var result = this._formatWithSubstitutionString(consoleMessage, linkifier, /** @type {string} **/ (parameters[0].description), parameters.slice(1), formattedResult);
             parameters = result.unusedSubstitutions;
             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));
+                formattedResult.appendChild(this._formatParameter(consoleMessage, linkifier, parameters[i], false, true));
             if (i < parameters.length - 1)
                 formattedResult.createTextChild(" ");
         }
         return formattedResult;
     },
 
     /**
+     * @param {!WebInspector.ConsoleMessage} consoleMessage
+     * @param {!WebInspector.Linkifier} linkifier
      * @param {!WebInspector.RemoteObject} output
      * @param {boolean=} forceObjectFormat
      * @param {boolean=} includePreview
      * @return {!Element}
      */
-    _formatParameter: function(output, forceObjectFormat, includePreview)
+    _formatParameter: function(consoleMessage, linkifier, output, forceObjectFormat, includePreview)
     {
-        if (output.customPreview()) {
+        if (output.customPreview())
             return (new WebInspector.CustomPreviewComponent(output)).element;
+
+        var messageType = consoleMessage.type;
+        var target = consoleMessage.target();
+        var elem;

[lushnikov, 2016/10/01 02:54:39]

element

+        var type = forceObjectFormat ? "object" : (output.subtype || output.type);
+        switch (type) {
+        case "array":
+        case "typedarray":
+            elem = this._formatParameterAsArray(output, linkifier, messageType);
+            break;
+        case "error":
+            elem = this._formatParameterAsError(output, linkifier, target);
+            break;
+        case "function":
+        case "generator":
+            elem = this._formatParameterAsFunction(output, includePreview);
+            break;
+        case "iterator":
+        case "map":
+        case "object":
+        case "promise":
+        case "proxy":
+        case "set":
+            elem = this._formatParameterAsObject(output, linkifier, includePreview);
+            break;
+        case "node":
+            elem = this._formatParameterAsNode(output, linkifier);
+            break;
+        case "string":
+            elem = this._formatParameterAsString(output);
+            break;
+        default:

[lushnikov, 2016/10/01 02:54:39]

can we explicitly state them all? I feel uneasy because of this default!

+            elem = this._formatParameterAsValue(output);
         }
-
-        var type = forceObjectFormat ? "object" : (output.subtype || output.type);
-        var formatter = this._customFormatters[type] || this._formatParameterAsValue;
-        var span = createElement("span");
-        span.className = "object-value-" + type + " source-code";
-        formatter.call(this, output, span, includePreview);
-        return span;
+        // Do not apply object-value-string to outer string element to keep quotes black.
+        elem.className = type === "string" ? "source-code" : "object-value-" + type + " source-code";

[luoe, 2016/10/01 01:10:52]

This is 'moved' from _formatParameterAsString() down below

[lushnikov, 2016/10/01 02:54:39]

let's make every formatter to specify the classname explicitly

+        return elem;
     },
 
     /**
      * @param {!WebInspector.RemoteObject} obj
-     * @param {!Element} elem
+     * @return {!Element}
      */
-    _formatParameterAsValue: function(obj, elem)
+    _formatParameterAsValue: function(obj)
     {
+        var elem = createElement("span");

[lushnikov, 2016/10/01 02:54:39]

createElementWithClass("span", "object-value-...")

         elem.createTextChild(obj.description || "");
         if (obj.objectId)
             elem.addEventListener("contextmenu", this._contextMenuEventFired.bind(this, obj), false);
+        return elem;

[lushnikov, 2016/10/01 02:54:39]

s/elem/element/gc

     },
 
     /**
      * @param {!WebInspector.RemoteObject} obj
-     * @param {!Element} elem
+     * @param {!WebInspector.Linkifier} linkifier
      * @param {boolean=} includePreview
+     * @return {!Element}
      */
-    _formatParameterAsObject: function(obj, elem, includePreview)
+    _formatParameterAsObject: function(obj, linkifier, includePreview)
     {
-        this._formatParameterAsArrayOrObject(obj, elem, includePreview);
+        var elem = createElement("span");
+        var sectionElement = this._objectFormatterHelper(obj, linkifier, includePreview);
+        elem.appendChild(sectionElement);
+        return elem;
     },
 
     /**
      * @param {!WebInspector.RemoteObject} obj
-     * @param {!Element} elem
+     * @param {!WebInspector.Linkifier} linkifier
      * @param {boolean=} includePreview
+     * @return {!Element}
      */
-    _formatParameterAsArrayOrObject: function(obj, elem, includePreview)
+    _objectFormatterHelper: function(obj, linkifier, includePreview)

[lushnikov, 2016/10/01 02:54:39]

_formatRemoteObject: 

     {
         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 {
-            if (obj.type === "function") {
-                WebInspector.ObjectPropertiesSection.formatObjectAsFunction(obj, titleElement, false);
-                titleElement.classList.add("object-value-function");
-            } else {
-                titleElement.createTextChild(obj.description || "");
-            }
+            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();
-        elem.appendChild(section.element);
+        return section.element;
     },
 
     /**
      * @param {!WebInspector.RemoteObject} func
-     * @param {!Element} element
      * @param {boolean=} includePreview
+     * @return {!Element}
      */
-    _formatParameterAsFunction: function(func, element, includePreview)
+    _formatParameterAsFunction: function(func, includePreview)
     {
+        var elem = createElement("span");
         WebInspector.RemoteFunction.objectAsFunction(func).targetFunction().then(formatTargetFunction.bind(this));
+        return elem;
 
         /**
          * @param {!WebInspector.RemoteObject} targetFunction
          * @this {WebInspector.ConsoleViewMessage}
          */
         function formatTargetFunction(targetFunction)
         {
             var functionElement = createElement("span");
             WebInspector.ObjectPropertiesSection.formatObjectAsFunction(targetFunction, functionElement, true, includePreview);
-            element.appendChild(functionElement);
+            elem.appendChild(functionElement);
             if (targetFunction !== func) {
-                var note = element.createChild("span", "object-info-state-note");
+                var note = elem.createChild("span", "object-info-state-note");
                 note.title = WebInspector.UIString("Function was resolved from bound function.");
             }
-            element.addEventListener("contextmenu", this._contextMenuEventFired.bind(this, targetFunction), false);
+            elem.addEventListener("contextmenu", this._contextMenuEventFired.bind(this, targetFunction), false);
         }
     },
 
     /**
      * @param {!WebInspector.RemoteObject} obj
      * @param {!Event} event
      */
     _contextMenuEventFired: function(obj, event)
     {
         var contextMenu = new WebInspector.ContextMenu(event);
         contextMenu.appendApplicableItems(obj);
         contextMenu.show();
     },
 
     /**
      * @param {?WebInspector.RemoteObject} object
      * @param {!Array.<!RuntimeAgent.PropertyPreview>} propertyPath
      * @return {!Element}
      */
     _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 {!Element} elem
+     * @param {!WebInspector.RemoteObject} obj

[lushnikov, 2016/10/01 02:54:39]

object

+     * @param {!WebInspector.Linkifier} linkifier
+     * @return {!Element}
      */
-    _formatParameterAsNode: function(object, elem)
+    _formatParameterAsNode: function(obj, linkifier)
     {
-        WebInspector.Renderer.renderPromise(object).then(appendRenderer.bind(this), failedToRender.bind(this));
+        var elem = createElement("span");

[lushnikov, 2016/10/01 02:54:39]

element

+        WebInspector.Renderer.renderPromise(obj).then(appendRenderer.bind(this), failedToRender.bind(this));
+        return elem;
+
         /**
          * @param {!Element} rendererElement
          * @this {WebInspector.ConsoleViewMessage}
          */
         function appendRenderer(rendererElement)
         {
             elem.appendChild(rendererElement);
             this._formattedParameterAsNodeForTest();
         }
 
         /**
          * @this {WebInspector.ConsoleViewMessage}
          */
         function failedToRender()
         {
-            this._formatParameterAsObject(object, elem, false);
+            var sectionElement = this._objectFormatterHelper(obj, linkifier, false);
+            elem.appendChild(sectionElement);
         }
     },
 
     _formattedParameterAsNodeForTest: function()
     {
     },
 
     /**
-     * @return {boolean}
+     * @param {!WebInspector.RemoteObject} array
+     * @param {!WebInspector.Linkifier} linkifier
+     * @param {string} messageType
+     * @return {!Element}
      */
-    _usePrintedArrayFormatter: function()
+    _formatParameterAsArray: function(array, linkifier, messageType)
     {
-        return this._message.type !== WebInspector.ConsoleMessage.MessageType.DirXML && this._message.type !== WebInspector.ConsoleMessage.MessageType.Result;
+        var elem = createElement("span");
+        var usePrintedArrayFormat = messageType !== WebInspector.ConsoleMessage.MessageType.DirXML && messageType !== WebInspector.ConsoleMessage.MessageType.Result;
+        var maxFlatArrayLength = 100;
+        if (usePrintedArrayFormat || array.arrayLength() > maxFlatArrayLength)
+            return this._formatParameterAsObject(array, linkifier, usePrintedArrayFormat || array.arrayLength() <= maxFlatArrayLength);
+        array.getAllProperties(false, this._printArrayResult.bind(this, array, elem, linkifier));
+        return elem;
+    },
+
+    /**
+     * @param {!WebInspector.RemoteObject} output
+     * @return {!Element}
+     */
+    _formatParameterAsString: function(output)
+    {
+        var elem = createElement("span");
+        var span = createElement("span");
+        span.className = "object-value-string source-code";
+        span.appendChild(WebInspector.linkifyStringAsFragment(output.description || ""));
+
+        elem.createTextChild("\"");
+        elem.appendChild(span);
+        elem.createTextChild("\"");
+        return elem;
+    },
+
+    /**
+     * @param {!WebInspector.RemoteObject} output
+     * @param {!WebInspector.Linkifier} linkifier
+     * @param {?WebInspector.Target} target
+     * @return {!Element}
+     */
+    _formatParameterAsError: function(output, linkifier, target)
+    {
+        var elem = createElement("span");
+        var span = elem.createChild("span", "object-value-error source-code");
+        var errorSpan = this._tryFormatAsError(target, linkifier, output.description || "");
+        span.appendChild(errorSpan ? errorSpan : WebInspector.linkifyStringAsFragment(output.description || ""));
+        return elem;
     },
 
     /**
      * @param {!WebInspector.RemoteObject} array
      * @param {!Element} elem
-     */
-    _formatParameterAsArray: function(array, elem)
-    {
-        var maxFlatArrayLength = 100;
-        if (this._usePrintedArrayFormatter() || array.arrayLength() > maxFlatArrayLength)
-            this._formatParameterAsArrayOrObject(array, elem, this._usePrintedArrayFormatter() || array.arrayLength() <= maxFlatArrayLength);
-        else
-            array.getAllProperties(false, this._printArrayResult.bind(this, array, elem));
-    },
-
-    /**
-     * @param {!WebInspector.RemoteObject} output
-     * @param {!Element} elem
-     */
-    _formatParameterAsString: function(output, elem)
-    {
-        var span = createElement("span");
-        span.className = "object-value-string source-code";
-        span.appendChild(WebInspector.linkifyStringAsFragment(output.description || ""));
-
-        // Make black quotes.
-        elem.classList.remove("object-value-string");
-        elem.createTextChild("\"");
-        elem.appendChild(span);
-        elem.createTextChild("\"");
-    },
-
-    /**
-     * @param {!WebInspector.RemoteObject} output
-     * @param {!Element} elem
-     */
-    _formatParameterAsError: function(output, elem)
-    {
-        var span = elem.createChild("span", "object-value-error source-code");
-        var errorSpan = this._tryFormatAsError(output.description || "");
-        span.appendChild(errorSpan ? errorSpan : WebInspector.linkifyStringAsFragment(output.description || ""));
-    },
-
-    /**
-     * @param {!WebInspector.RemoteObject} array
-     * @param {!Element} elem
+     * @param {!WebInspector.Linkifier} linkifier
      * @param {?Array.<!WebInspector.RemoteObjectProperty>} properties
      */
-    _printArrayResult: function(array, elem, properties)
+    _printArrayResult: function(array, elem, linkifier, properties)

[lushnikov, 2016/10/01 02:54:39]

probably, you should create and return element here rather then accepting one
from the outer world

     {
         if (!properties) {
-            this._formatParameterAsObject(array, elem, false);
+            var sectionElement = this._objectFormatterHelper(array, linkifier, false);
+            elem.appendChild(sectionElement);
             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();
         elem.appendChild(section.element);
     },
 
     /**
      * @param {!WebInspector.RemoteObject} output
      * @return {!Element}
      */
     _formatAsArrayEntry: function(output)
@@ skipping 40 matching lines @@
                         description = result.description.trimEnd(maxLength);
                 }
                 rootElement.appendChild(this._previewFormatter.renderPropertyPreview(type, subtype, description));
             }
         }
 
         return rootElement;
     },
 
     /**
+     * @param {!WebInspector.ConsoleMessage} consoleMessage
+     * @param {!WebInspector.Linkifier} linkifier
      * @param {string} format
      * @param {!Array.<!WebInspector.RemoteObject>} parameters
      * @param {!Element} formattedResult
      */
-    _formatWithSubstitutionString: function(format, parameters, formattedResult)
+    _formatWithSubstitutionString: function(consoleMessage, linkifier, format, parameters, formattedResult)
     {
         var formatters = {};
 
         /**
+         * @param {!WebInspector.RemoteObject} obj
          * @param {boolean} force
-         * @param {!WebInspector.RemoteObject} obj
          * @return {!Element}
          * @this {WebInspector.ConsoleViewMessage}
          */
         function parameterFormatter(force, obj)
         {
-            return this._formatParameter(obj, force, false);
+            return this._formatParameter(consoleMessage, linkifier, obj, force, false);
         }
 
         function stringFormatter(obj)
         {
             return obj.description;
         }
 
         function floatFormatter(obj)
         {
             if (typeof obj.value !== "number")
@@ skipping 157 matching lines @@
 
         var contentElement = createElementWithClass("div", "console-message");
         this._contentElement = contentElement;
         if (this._message.type === WebInspector.ConsoleMessage.MessageType.StartGroup || this._message.type === WebInspector.ConsoleMessage.MessageType.StartGroupCollapsed)
             contentElement.classList.add("console-group-title");
 
         var formattedMessage;
         if (this._message.type === WebInspector.ConsoleMessage.MessageType.Table)
             formattedMessage = this._buildTableMessage(this._message);
         else
-            formattedMessage = this._buildMessage(this._message);
+            formattedMessage = this._buildMessage(this._message, this._linkifier);
         contentElement.appendChild(formattedMessage);
 
         this.updateTimestamp(WebInspector.moduleSetting("consoleTimestampsEnabled").get());
         return this._contentElement;
     },
 
     /**
      * @return {!Element}
      */
     toMessageElement: function()
@@ skipping 143 matching lines @@
 
     /**
      * @return {!Element}
      */
     searchHighlightNode: function(index)
     {
         return this._searchHighlightNodes[index];
     },
 
     /**
+     * @param {?WebInspector.Target} target
+     * @param {!WebInspector.Linkifier} linkifier
      * @param {string} string
      * @return {?Element}
      */
-    _tryFormatAsError: function(string)
+    _tryFormatAsError: function(target, linkifier, string)
     {
         /**
          * @param {string} prefix
          */
         function startsWith(prefix)
         {
             return string.startsWith(prefix);
         }
 
         var errorPrefixes = ["EvalError", "ReferenceError", "SyntaxError", "TypeError", "RangeError", "Error", "URIError"];
-        var target = this._target();
         if (!target || !errorPrefixes.some(startsWith))
             return null;
         var debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
         if (!debuggerModel)
             return null;
 
         var lines = string.split("\n");
         var links = [];
         var position = 0;
         for (var i = 0; i < lines.length; ++i) {
@@ skipping 34 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
 }