[turbolizer] Use locations rather than ranges everywhere

tools/turbolizer/text-view.js

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 "use strict";
 
 class TextView extends View {
   constructor(id, broker, patterns, allowSpanSelection) {
     super(id, broker);
     let view = this;
-    view.sortedPositionList = [];
-    view.nodePositionMap = [];
-    view.positionNodeMap = [];
+    view.hide();
     view.textListNode = view.divNode.getElementsByTagName('ul')[0];
     view.fillerSvgElement = view.divElement.append("svg").attr('version','1.1').attr("width", "0");
     view.patterns = patterns;
     view.allowSpanSelection = allowSpanSelection;
     view.nodeToLineMap = [];
     var selectionHandler = {
       clear: function() {
         broker.clear(selectionHandler);
       },
       select: function(items, selected) {
         for (let i of items) {
           if (selected) {
             i.classList.add("selected");
           } else {
             i.classList.remove("selected");
           }
         }
         broker.clear(selectionHandler);
-        broker.select(selectionHandler, view.getRanges(items), selected);
+        broker.select(selectionHandler, view.getLocations(items), selected);
       },
       selectionDifference: function(span1, inclusive1, span2, inclusive2) {
         return null;
       },
-      brokeredSelect: function(ranges, selected) {
-        let locations = view.rangesToLocations(ranges);
+      brokeredSelect: function(locations, selected) {
         view.selectLocations(locations, selected, true);
       },
       brokeredClear: function() {
         view.selection.clear();
       }
     };
     view.selection = new Selection(selectionHandler);
     broker.addSelectionHandler(selectionHandler);
   }
 
   setPatterns(patterns) {
     let view = this;
     view.patterns = patterns;
   }
 
   clearText() {
     let view = this;
     while (view.textListNode.firstChild) {
       view.textListNode.removeChild(view.textListNode.firstChild);
     }
   }
 
-  rangeToLocation(range) {
-    return range;
-  }
-
-  rangesToLocations(ranges) {
-    let view = this;
-    let nodes = new Set();
-    let result = [];
-    for (let range of ranges) {
-      let start = range[0];
-      let end = range[1];
-      let block_id = range[3];
-      let location = { pos_start: start, pos_end: end, block_id: block_id };
-      if (range[2] !== null && range[2] != -1) {
-        location.node_id = range[2];
-        if (range[0] == -1 && range[1] == -1) {
-          location.pos_start = view.nodePositionMap[location.node_id];
-          location.pos_end = location.pos_start + 1;
-        }
-      } else {
-        if (range[0] != undefined) {
-          location.pos_start = range[0];
-          location.pos_end = range[1];
-        }
-      }
-      result.push(location);
-    }
-    return result;
-  }
-
   sameLocation(l1, l2) {
     let view = this;
     if (l1.block_id != undefined && l2.block_id != undefined &&
       l1.block_id == l2.block_id && l1.node_id === undefined) {
       return true;
     }
 
     if (l1.address != undefined && l1.address == l2.address) {
       return true;
     }
 
     let node1 = l1.node_id;
     let node2 = l2.node_id;
 
-    if (node1 === undefined && node2 == undefined) {
+    if (node1 === undefined || node2 == undefined) {
       if (l1.pos_start === undefined || l2.pos_start == undefined) {
         return false;
       }
       if (l1.pos_start == -1 || l2.pos_start == -1) {
         return false;
       }
       if (l1.pos_start < l2.pos_start) {
         return l1.pos_end > l2.pos_start;
       } {
         return l1.pos_start < l2.pos_end;
       }
     }
 
-    if (node1 === undefined) {
-      let lower = lowerBound(view.positionNodeMap, l1.pos_start, undefined, function(a, b) {
-        var node = a[b];
-        return view.nodePositionMap[node];
-      } );
-      while (++lower < view.positionNodeMap.length &&
-             view.nodePositionMap[view.positionNodeMap[lower]] < l1.pos_end) {
-        if (view.positionNodeMap[lower] == node2) {
-          return true;
-        }
-      }
-      return false;
-    }
-
-    if (node2 === undefined) {
-      let lower = lowerBound(view.positionNodeMap, l2.pos_start, undefined, function(a, b) {
-        var node = a[b];
-        return view.nodePositionMap[node];
-      } );
-      while (++lower < view.positionNodeMap.length &&
-             view.nodePositionMap[view.positionNodeMap[lower]] < l2.pos_end) {
-        if (view.positionNodeMap[lower] == node1) {
-          return true;
-        }
-      }
-      return false;
-    }
-
     return l1.node_id == l2.node_id;
   }
 
-  setNodePositionMap(map) {
-    let view = this;
-    view.nodePositionMap = map;
-    view.positionNodeMap = [];
-    view.sortedPositionList = [];
-    let next = 0;
-    for (let i in view.nodePositionMap) {
-      view.sortedPositionList[next] = Number(view.nodePositionMap[i]);
-      view.positionNodeMap[next++] = i;
-    }
-    view.sortedPositionList = sortUnique(view.sortedPositionList,
-                                         function(a,b) { return a - b; });
-    this.positionNodeMap.sort(function(a,b) {
-      let result = view.nodePositionMap[a] - view.nodePositionMap[b];
-      if (result != 0) return result;
-      return a - b;
-    });
-  }
-
   selectLocations(locations, selected, makeVisible) {
     let view = this;
     let s = new Set();
     for (let l of locations) {
       for (let i = 0; i < view.textListNode.children.length; ++i) {
         let child = view.textListNode.children[i];
         if (child.location != undefined && view.sameLocation(l, child.location)) {
           s.add(child);
         }
       }
     }
     view.selectCommon(s, selected, makeVisible);
   }
 
-  getRanges(items) {
+  getLocations(items) {
     let result = [];
     let lastObject = null;
     for (let i of items) {
       if (i.location) {
-        let location = i.location;
-        let start = -1;
-        let end = -1;
-        let node_id = -1;
-        let block_id = -1;
-        if (location.node_id !== undefined) {
-          node_id = location.node_id;
-        }
-        if (location.block_id !== undefined) {
-          block_id = location.block_id;
-        }
-        if (location.pos_start !== undefined) {
-          start = location.pos_start;
-          end = location.pos_end;
-        } else {
-          if (this.nodePositionMap && this.nodePositionMap[node_id]) {
-            start = this.nodePositionMap[node_id];
-            end = start + 1;
-          }
-        }
-        if (lastObject == null ||
-            (lastObject[2] != node_id ||
-             lastObject[0] != start ||
-             lastObject[1] != end ||
-             lastObject[3] != block_id)) {
-          lastObject = [start, end, node_id, block_id];
-          result.push(lastObject);
-        }
+        result.push(i.location);
       }
     }
     return result;
   }
 
   createFragment(text, style) {
     let view = this;
     let span = document.createElement("SPAN");
     span.onmousedown = function(e) {
       view.mouseDownSpan(span, e);
@@ skipping 71 matching lines @@
         let child = view.textListNode.children[i];
         if (child.location && s(child.location)) {
           if (firstSelect) {
             makeContainerPosVisible(view.parentNode, child.offsetTop);
             firstSelect = false;
           }
           view.selection.select(child, selected);
         }
       }
     } else if (typeof s[Symbol.iterator] === 'function') {
-      for (let i of s) {
-        if (firstSelect) {
+      if (firstSelect) {
+        for (let i of s) {
           makeContainerPosVisible(view.parentNode, i.offsetTop);
-          firstSelect = false;
+          break;
         }
-        view.selection.select(i, selected);
       }
+      view.selection.select(s, selected);
     } else {
       if (firstSelect) {
         makeContainerPosVisible(view.parentNode, s.offsetTop);
       }
       view.selection.select(s, selected);
     }
   }
 
   mouseDownLine(li, e) {
     let view = this;
@@ skipping 70 matching lines @@
   lineLocation(li) {
     let view = this;
     for (let i = 0; i < li.children.length; ++i) {
       let fragment = li.children[i];
       if (fragment.location != undefined && !view.allowSpanSelection) {
         return fragment.location;
       }
     }
   }
 }