DevTools: convert linkifyURL params into options object

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

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 131 matching lines @@
   /**
    * @param {?SDK.Target} target
    * @param {?string} scriptId
    * @param {string} sourceURL
    * @param {number} lineNumber
    * @param {number=} columnNumber
    * @param {string=} classes
    * @return {?Element}
    */
   maybeLinkifyScriptLocation(target, scriptId, sourceURL, lineNumber, columnNumber, classes) {
-    var fallbackAnchor = sourceURL ?
-        Components.Linkifier.linkifyURL(
-            sourceURL, undefined, classes, lineNumber, columnNumber, undefined, this._maxLength) :
-        null;
+    var fallbackAnchor = null;
+    if (sourceURL) {
+      fallbackAnchor = Components.Linkifier.linkifyURL({
+        url: sourceURL,
+        className: classes,
+        lineNumber: lineNumber,
+        columnNumber: columnNumber,
+        maxLength: this._maxLength
+      });
+    }
     if (!target || target.isDisposed())
       return fallbackAnchor;
     var debuggerModel = target.model(SDK.DebuggerModel);
     if (!debuggerModel)
       return fallbackAnchor;
 
     var rawLocation =
         (scriptId ? debuggerModel.createRawLocationByScriptId(scriptId, lineNumber, columnNumber || 0) : null) ||
         debuggerModel.createRawLocationByURL(sourceURL, lineNumber, columnNumber || 0);
     if (!rawLocation)
@@ skipping 15 matching lines @@
   /**
    * @param {?SDK.Target} target
    * @param {?string} scriptId
    * @param {string} sourceURL
    * @param {number} lineNumber
    * @param {number=} columnNumber
    * @param {string=} classes
    * @return {!Element}
    */
   linkifyScriptLocation(target, scriptId, sourceURL, lineNumber, columnNumber, classes) {
-    return this.maybeLinkifyScriptLocation(target, scriptId, sourceURL, lineNumber, columnNumber, classes) ||
-        Components.Linkifier.linkifyURL(
-            sourceURL, undefined, classes, lineNumber, columnNumber, undefined, this._maxLength);
+    var scriptLink = this.maybeLinkifyScriptLocation(target, scriptId, sourceURL, lineNumber, columnNumber, classes);
+    return scriptLink || Components.Linkifier.linkifyURL({
+      url: sourceURL,
+      className: classes,
+      lineNumber: lineNumber,
+      columnNumber: columnNumber,
+      maxLength: this._maxLength
+    });
   }
 
   /**
    * @param {!SDK.DebuggerModel.Location} rawLocation
    * @param {string} fallbackUrl
    * @param {string=} classes
    * @return {!Element}
    */
   linkifyRawLocation(rawLocation, fallbackUrl, classes) {
     return this.linkifyScriptLocation(
@@ skipping 15 matching lines @@
   /**
    * @param {!SDK.Target} target
    * @param {!Protocol.Runtime.StackTrace} stackTrace
    * @param {string=} classes
    * @return {!Element}
    */
   linkifyStackTraceTopFrame(target, stackTrace, classes) {
     console.assert(stackTrace.callFrames && stackTrace.callFrames.length);
 
     var topFrame = stackTrace.callFrames[0];
-    var fallbackAnchor = Components.Linkifier.linkifyURL(
-        topFrame.url, undefined, classes, topFrame.lineNumber, topFrame.columnNumber, undefined, this._maxLength);
+    var fallbackAnchor = Components.Linkifier.linkifyURL({
+      url: topFrame.url,
+      className: classes,
+      lineNumber: topFrame.lineNumber,
+      columnNumber: topFrame.columnNumber,
+      maxLength: this._maxLength
+    });
     if (target.isDisposed())
       return fallbackAnchor;
 
     var debuggerModel = target.model(SDK.DebuggerModel);
     var rawLocations = debuggerModel.createRawLocationsByStackTrace(stackTrace);
     if (rawLocations.length === 0)
       return fallbackAnchor;
 
     var anchor = Components.Linkifier._createLink('', classes || '');
     var info = Components.Linkifier._linkInfo(anchor);
@@ skipping 75 matching lines @@
       anchor.removeChild(info.icon);
     var icon = Components.Linkifier._decorator.linkIcon(info.uiLocation.uiSourceCode);
     if (icon) {
       icon.style.setProperty('margin-right', '2px');
       anchor.insertBefore(icon, anchor.firstChild);
     }
     info.icon = icon;
   }
 
   /**
-   * @param {string} url
-   * @param {string=} text
-   * @param {string=} className
-   * @param {number=} lineNumber
-   * @param {number=} columnNumber
-   * @param {boolean=} preventClick
-   * @param {number=} maxLength
+   * @param  {!Components.LinkifyURLOptions} options
    * @return {!Element}
    */
-  static linkifyURL(url, text, className, lineNumber, columnNumber, preventClick, maxLength) {
+  static linkifyURL(options) {

[pfeldman, 2017/05/31 21:54:59]

In my original review, I was suggesting to only convert optional parameters to
options, retaining the url itself. You'll see how much more readable the code
would be!

[luoe, 2017/06/02 18:21:12]

I see.  Looks better to me!

+    var url = options.url;
+    var text = options.text;
+    var className = options.className || '';
+    var lineNumber = options.lineNumber;
+    var columnNumber = options.columnNumber;
+    var preventClick = options.preventClick;
+    var maxLength = maxLength || UI.MaxLengthForDisplayedURLs;
     if (!url || url.trim().toLowerCase().startsWith('javascript:')) {
       var element = createElementWithClass('span', className);
       element.textContent = text || url || Common.UIString('(unknown)');
       return element;
     }
 
     var linkText = text || Bindings.displayNameForURL(url);
     if (typeof lineNumber === 'number' && !text)
       linkText += ':' + (lineNumber + 1);
     var title = linkText !== url ? url : '';
-    var link = Components.Linkifier._createLink(
-        linkText, className || '', maxLength || UI.MaxLengthForDisplayedURLs, title, url, preventClick);
+    var link = Components.Linkifier._createLink(linkText, className, maxLength, title, url, preventClick);
     var info = Components.Linkifier._linkInfo(link);
     if (typeof lineNumber === 'number')
       info.lineNumber = lineNumber;
     if (typeof columnNumber === 'number')
       info.columnNumber = columnNumber;
     return link;
   }
 
   /**
    * @param {!Object} revealable
@@ skipping 242 matching lines @@
  *     url: ?string,
  *     lineNumber: ?number,
  *     columnNumber: ?number,
  *     revealable: ?Object,
  *     fallback: ?Element
  * }}
  */
 Components._LinkInfo;
 
 /**
+ * @typedef {{
+ *     url: string,
+ *     text: (string|undefined),
+ *     className: (string|undefined),
+ *     lineNumber: (number|undefined),
+ *     columnNumber: (number|undefined),
+ *     preventClick: (boolean|undefined),
+ *     maxLength: (number|undefined)
+ * }}
+ */
+Components.LinkifyURLOptions;
+
+/**
  * The maximum length before strings are considered too long for finding URLs.
  * @const
  * @type {number}
  */
 Components.Linkifier.MaxLengthToIgnoreLinkifier = 10000;
 
 /**
  * @typedef {function(!Common.ContentProvider, number)}
  */
 Components.Linkifier.LinkHandler;
@@ skipping 65 matching lines @@
  */
 Components.linkifyStringAsFragment = function(string) {
   /**
    * @param {string} title
    * @param {string} url
    * @param {number=} lineNumber
    * @param {number=} columnNumber
    * @return {!Node}
    */
   function linkifier(title, url, lineNumber, columnNumber) {
-    return Components.Linkifier.linkifyURL(url, title, undefined, lineNumber, columnNumber);
+    return Components.Linkifier.linkifyURL({url: url, text: title, lineNumber: lineNumber, columnNumber: columnNumber});
   }
 
   return Components.linkifyStringAsFragmentWithCustomLinkifier(string, linkifier);
 };
 
 /**
  * @implements {UI.ContextMenu.Provider}
  * @unrestricted
  */
 Components.Linkifier.LinkContextMenuProvider = class {
@@ skipping 114 matching lines @@
     contextMenu.appendSeparator();
     contextMenu.appendItem(Common.UIString('Save'), save.bind(null, false));
 
     if (contentProvider instanceof Workspace.UISourceCode) {
       var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (contentProvider);
       if (!uiSourceCode.project().canSetFileContent())
         contextMenu.appendItem(Common.UIString.capitalize('Save ^as...'), save.bind(null, true));
     }
   }
 };