DevTools: untruncate links on copy

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * 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 53 matching lines @@
     this._itemCount = 0;
 
     // Listen for any changes to descendants and trigger a refresh. This ensures
     // that items updated asynchronously will not break stick-to-bottom behavior
     // if they change the scroll height.
     this._observer = new MutationObserver(this.refresh.bind(this));
     this._observerConfig = {childList: true, subtree: true};
   }
 
   /**
+   * @param {!Node} node
+   * @return {string}
+   */
+  static contentTransform(node) {
+    var originalLinkText = Components.Linkifier.originalLinkText(node.parentElement);
+    return typeof originalLinkText === 'string' ? originalLinkText : node.textContent;

[allada, 2017/03/28 01:13:08]

nit: return originalLinkText === null ? node.textContent : originalLinkText

(maybe consider if empty strings should look into node.textContent too?)

[luoe, 2017/03/31 21:35:21]

Done.

Empty strings is a good case to consider, but right now there's no reason why
they should be different.  I'd keep non-nulls consistent.

[allada, 2017/03/31 23:17:33]

Acknowledged.

+  }
+
+  /**
    * @return {boolean}
    */
   stickToBottom() {
     return this._stickToBottom;
   }
 
   /**
    * @param {boolean} value
    */
   setStickToBottom(value) {
@@ skipping 332 matching lines @@
     var endSelection = null;
     if (this._selectionIsBackward) {
       startSelection = this._headSelection;
       endSelection = this._anchorSelection;
     } else {
       startSelection = this._anchorSelection;
       endSelection = this._headSelection;
     }
 
     var textLines = [];
-    for (var i = startSelection.item; i <= endSelection.item; ++i)
-      textLines.push(this._providerElement(i).element().deepTextContent());
+    for (var i = startSelection.item; i <= endSelection.item; ++i) {
+      var currElement = this._providerElement(i).element();
+      var lineContent = currElement.childTextNodes().map(Console.ConsoleViewport.contentTransform).join('');
+      textLines.push(lineContent);
+    }
 
     var endSelectionElement = this._providerElement(endSelection.item).element();
     if (endSelection.node && endSelection.node.isSelfOrDescendant(endSelectionElement)) {
       var itemTextOffset = this._textOffsetInNode(endSelectionElement, endSelection.node, endSelection.offset);
       textLines[textLines.length - 1] = textLines.peekLast().substring(0, itemTextOffset);
     }
 
     var startSelectionElement = this._providerElement(startSelection.item).element();
     if (startSelection.node && startSelection.node.isSelfOrDescendant(startSelectionElement)) {
       var itemTextOffset = this._textOffsetInNode(startSelectionElement, startSelection.node, startSelection.offset);
@@ skipping 11 matching lines @@
    */
   _textOffsetInNode(itemElement, container, offset) {
     if (container.nodeType !== Node.TEXT_NODE) {
       if (offset < container.childNodes.length) {
         container = /** @type {!Node} */ (container.childNodes.item(offset));
         offset = 0;
       } else {
         offset = container.textContent.length;
       }
     }
+    // To calculate the correct offset, this assumes that links truncate from the middle.
+    var originalLinkText = Components.Linkifier.originalLinkText(container.parentElement);
+    if (typeof originalLinkText === 'string') {
+      var truncatedLength = originalLinkText.length - container.textContent.length;
+      if (offset > container.textContent.length >> 1)
+        offset += truncatedLength;
+    }
     var chars = 0;
     var node = itemElement;
     while ((node = node.traverseNextTextNode(itemElement)) && !node.isSelfOrDescendant(container))
-      chars += node.textContent.length;
+      chars += Console.ConsoleViewport.contentTransform(node).length;
     return chars + offset;
   }
 
   /**
    * @param {!Event} event
    */
   _onScroll(event) {
     this.refresh();
   }
 
@@ skipping 125 matching lines @@
 Console.ConsoleViewportElement.prototype = {
   willHide() {},
 
   wasShown() {},
 
   /**
    * @return {!Element}
    */
   element() {},
 };