[Devtools] Rename logEntries to node in network

third_party/WebKit/Source/devtools/front_end/network/NetworkWaterfallColumn.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
  * @unrestricted
  */
 Network.NetworkWaterfallColumn = class extends UI.VBox {
   /**
    * @param {number} rowHeight
    * @param {!Network.NetworkTimeCalculator} calculator
@@ skipping 16 matching lines @@
     this._rightPadding = 0;
 
     this._rowHeight = rowHeight;
     this._headerHeight = 0;
     this._calculator = calculator;
 
     this._popoverHelper = new UI.PopoverHelper(this.element);
     this._popoverHelper.initializeCallbacks(this._getPopoverAnchor.bind(this), this._showPopover.bind(this));
     this._popoverHelper.setTimeout(300, 300);
 
-    /** @type {!Array<!Network.NetworkLogEntry>} */
-    this._logEntries = [];
+    /** @type {!Array<!Network.NetworkDataGridNode>} */
+    this._nodes = [];
 
-    /** @type {?Network.NetworkLogEntry} */
-    this._hoveredLogEntry = null;
+    /** @type {?Network.NetworkDataGridNode} */
+    this._hoveredNode = null;
     /** @type {?SDK.NetworkRequest.InitiatorGraph} */
     this._initiatorGraph = null;
 
     /** @type {!Map<string, !Array<number>>} */
     this._eventDividers = new Map();
 
     var colorUsage = UI.ThemeSupport.ColorUsage;
     this._rowNavigationRequestColor = UI.themeSupport.patchColor('#def', colorUsage.Background);
     this._rowStripeColor = UI.themeSupport.patchColor('#f5f5f5', colorUsage.Background);
     this._rowHoverColor = UI.themeSupport.patchColor(
@@ skipping 20 matching lines @@
   wasShown() {
     this.update();
   }
 
   /**
    * @param {!Element} element
    * @param {!Event} event
    * @return {!AnchorBox|undefined}
    */
   _getPopoverAnchor(element, event) {
-    if (!this._hoveredLogEntry)
+    if (!this._hoveredNode)
       return;
     var useTimingBars = !Common.moduleSetting('networkColorCodeResourceTypes').get() && !this._calculator.startAtZero;
     if (useTimingBars) {
-      var range = Network.RequestTimingView.calculateRequestTimeRanges(this._hoveredLogEntry.request(), 0)
+      var range = Network.RequestTimingView.calculateRequestTimeRanges(this._hoveredNode.request(), 0)
                       .find(data => data.name === Network.RequestTimeRangeNames.Total);
       var start = this._timeToPosition(range.start);
       var end = this._timeToPosition(range.end);
     } else {
-      var range = this._getSimplifiedBarRange(this._hoveredLogEntry, 0);
+      var range = this._getSimplifiedBarRange(this._hoveredNode, 0);
       var start = range.start;
       var end = range.end;
     }
 
     if (end - start < 50) {
       var halfWidth = (end - start) / 2;
       start = start + halfWidth - 25;
       end = end - halfWidth + 25;
     }
 
     if (event.clientX < this._canvasPosition.left + start || event.clientX > this._canvasPosition.left + end)
       return;
 
-    var rowIndex = this._logEntries.findIndex(logEntry => this._hoveredLogEntry === logEntry);
+    var rowIndex = this._nodes.findIndex(node => this._hoveredNode === node);
     var barHeight = this._getBarHeight(range.name);
     var y = this._headerHeight + (this._rowHeight * rowIndex - this._scrollTop) + ((this._rowHeight - barHeight) / 2);
 
     if (event.clientY < this._canvasPosition.top + y || event.clientY > this._canvasPosition.top + y + barHeight)
       return;
 
     var anchorBox = this.element.boxInWindow();
     anchorBox.x += start;
     anchorBox.y += y;
     anchorBox.width = end - start;
     anchorBox.height = barHeight;
     return anchorBox;
   }
 
   /**
    * @param {!Element|!AnchorBox} anchor
    * @param {!UI.Popover} popover
    */
   _showPopover(anchor, popover) {
-    if (!this._hoveredLogEntry)
+    if (!this._hoveredNode)
       return;
-    var content = Network.RequestTimingView.createTimingTable(
-        this._hoveredLogEntry.request(), this._calculator.minimumBoundary());
+    var content =
+        Network.RequestTimingView.createTimingTable(this._hoveredNode.request(), this._calculator.minimumBoundary());
     popover.showForAnchor(content, anchor);
   }
 
   /**
-   * @param {?Network.NetworkLogEntry} logEntry
+   * @param {?Network.NetworkDataGridNode} node
    * @param {boolean} highlightInitiatorChain
    */
-  setHoveredLogEntry(logEntry, highlightInitiatorChain) {
-    this._hoveredLogEntry = logEntry;
-    this._initiatorGraph = (highlightInitiatorChain && logEntry) ? logEntry.request().initiatorGraph() : null;
+  setHoveredNode(node, highlightInitiatorChain) {
+    this._hoveredNode = node;
+    this._initiatorGraph = (highlightInitiatorChain && node) ? node.request().initiatorGraph() : null;
     this.update();
   }
 
   /**
    * @param {number} height
    */
   setRowHeight(height) {
     this._rowHeight = height;
   }
 
@@ skipping 15 matching lines @@
   /**
    * @param {!Network.NetworkTimeCalculator} calculator
    */
   setCalculator(calculator) {
     this._calculator = calculator;
   }
 
   /**
    * @param {number} x
    * @param {number} y
-   * @return {?Network.NetworkLogEntry}
+   * @return {?Network.NetworkDataGridNode}
    */
-  getLogEntryFromPoint(x, y) {
-    return this._logEntries[Math.floor((this._scrollTop + y - this._headerHeight) / this._rowHeight)];
+  getNodeFromPoint(x, y) {
+    return this._nodes[Math.floor((this._scrollTop + y - this._headerHeight) / this._rowHeight)];
   }
 
   scheduleDraw() {
     if (this._updateRequestID)
       return;
     this._updateRequestID = this.element.window().requestAnimationFrame(() => this.update());
   }
 
   /**
    * @param {number=} scrollTop
    * @param {!Map<string, !Array<number>>=} eventDividers
-   * @param {!Array<!Network.NetworkLogEntry>=} logEntries
+   * @param {!Array<!Network.NetworkDataGridNode>=} nodes
    */
-  update(scrollTop, eventDividers, logEntries) {
+  update(scrollTop, eventDividers, nodes) {
     if (scrollTop !== undefined)
       this._scrollTop = scrollTop;
-    if (logEntries) {
-      this._logEntries = logEntries;
+    if (nodes) {
+      this._nodes = nodes;
       this._calculateCanvasSize();
     }
     if (eventDividers !== undefined)
       this._eventDividers = eventDividers;
     this.element.window().cancelAnimationFrame(this._updateRequestID);
     this._updateRequestID = null;
 
     this._startTime = this._calculator.minimumBoundary();
     this._endTime = this._calculator.maximumBoundary();
     this._resetCanvas();
@@ skipping 65 matching lines @@
     var availableWidth = this._offsetWidth - this._leftPadding;
     var timeToPixel = availableWidth / (this._endTime - this._startTime);
     return Math.floor(this._leftPadding + (time - this._startTime) * timeToPixel);
   }
 
   _didDrawForTest() {
   }
 
   _draw() {
     var useTimingBars = !Common.moduleSetting('networkColorCodeResourceTypes').get() && !this._calculator.startAtZero;
-    var logEntries = this._logEntries;
+    var nodes = this._nodes;
     var context = this._canvas.getContext('2d');
     context.save();
     context.scale(window.devicePixelRatio, window.devicePixelRatio);
     context.translate(0, this._headerHeight);
     context.rect(0, 0, this._offsetWidth, this._offsetHeight);
     context.clip();
     var firstRequestIndex = Math.floor(this._scrollTop / this._rowHeight);
-    var lastRequestIndex =
-        Math.min(logEntries.length, firstRequestIndex + Math.ceil(this._offsetHeight / this._rowHeight));
+    var lastRequestIndex = Math.min(nodes.length, firstRequestIndex + Math.ceil(this._offsetHeight / this._rowHeight));
     for (var i = firstRequestIndex; i < lastRequestIndex; i++) {
       var rowOffset = this._rowHeight * i;
-      var logEntry = logEntries[i];
-      this._decorateRow(context, logEntry, i, rowOffset - this._scrollTop);
+      var node = nodes[i];
+      this._decorateRow(context, node, i, rowOffset - this._scrollTop);
       if (useTimingBars)
-        this._drawTimingBars(context, logEntry, rowOffset - this._scrollTop);
+        this._drawTimingBars(context, node, rowOffset - this._scrollTop);
       else
-        this._drawSimplifiedBars(context, logEntry, rowOffset - this._scrollTop);
+        this._drawSimplifiedBars(context, node, rowOffset - this._scrollTop);
     }
     this._drawEventDividers(context);
     context.restore();
 
     const freeZoneAtLeft = 75;
     const freeZoneAtRight = 18;
     UI.TimelineGrid.drawCanvasGrid(context, this._calculator, this._fontSize, this._headerHeight, freeZoneAtLeft);
     context.clearRect(this._offsetWidth - freeZoneAtRight, 0, freeZoneAtRight, this._headerHeight);
     this._didDrawForTest();
   }
@@ skipping 38 matching lines @@
       case types.Blocking:
       case types.Push:
       case types.Queueing:
         return 7;
       default:
         return 13;
     }
   }
 
   /**
-   * @param {!Network.NetworkLogEntry} logEntry
+   * @param {!Network.NetworkDataGridNode} node
    * @return {string}
    */
-  _borderColorForResourceType(logEntry) {
-    var resourceType = logEntry.request().resourceType();
+  _borderColorForResourceType(node) {
+    var resourceType = node.request().resourceType();
     if (this._borderColorsForResourceTypeCache.has(resourceType))
       return this._borderColorsForResourceTypeCache.get(resourceType);
     var colorsForResourceType = Network.NetworkWaterfallColumn._colorsForResourceType;
     var color = colorsForResourceType[resourceType] || colorsForResourceType.Other;
     var parsedColor = Common.Color.parse(color);
     var hsla = parsedColor.hsla();
     hsla[1] /= 2;
     hsla[2] -= Math.min(hsla[2], 0.2);
     var resultColor = /** @type {string} */ (parsedColor.asString(null));
     this._borderColorsForResourceTypeCache.set(resourceType, resultColor);
     return resultColor;
   }
 
   /**
    * @param {!CanvasRenderingContext2D} context
-   * @param {!Network.NetworkLogEntry} logEntry
+   * @param {!Network.NetworkDataGridNode} node
    * @return {string|!CanvasGradient}
    */
-  _colorForResourceType(context, logEntry) {
-    var request = logEntry.request();
+  _colorForResourceType(context, node) {
+    var request = node.request();
     var colorsForResourceType = Network.NetworkWaterfallColumn._colorsForResourceType;
     var resourceType = request.resourceType();
     var color = colorsForResourceType[resourceType] || colorsForResourceType.Other;
     if (request.cached())
       return color;
 
     if (this._colorsForResourceTypeCache.has(color))
       return this._colorsForResourceTypeCache.get(color);
     var parsedColor = Common.Color.parse(color);
     var hsla = parsedColor.hsla();
     hsla[1] -= Math.min(hsla[1], 0.28);
     hsla[2] -= Math.min(hsla[2], 0.15);
     var gradient = context.createLinearGradient(0, 0, 0, this._getBarHeight());
     gradient.addColorStop(0, color);
     gradient.addColorStop(1, /** @type {string} */ (parsedColor.asString(null)));
     this._colorsForResourceTypeCache.set(color, gradient);
     return gradient;
   }
 
   /**
-   * @param {!Network.NetworkLogEntry} logEntry
+   * @param {!Network.NetworkDataGridNode} node
    * @param {number} borderOffset
    * @return {!{start: number, mid: number, end: number}}
    */
-  _getSimplifiedBarRange(logEntry, borderOffset) {
+  _getSimplifiedBarRange(node, borderOffset) {
     var drawWidth = this._offsetWidth - this._leftPadding;
-    var percentages = this._calculator.computeBarGraphPercentages(logEntry.request());
+    var percentages = this._calculator.computeBarGraphPercentages(node.request());
     return {
       start: this._leftPadding + Math.floor((percentages.start / 100) * drawWidth) + borderOffset,
       mid: this._leftPadding + Math.floor((percentages.middle / 100) * drawWidth) + borderOffset,
       end: this._leftPadding + Math.floor((percentages.end / 100) * drawWidth) + borderOffset
     };
   }
 
   /**
    * @param {!CanvasRenderingContext2D} context
-   * @param {!Network.NetworkLogEntry} logEntry
+   * @param {!Network.NetworkDataGridNode} node
    * @param {number} y
    */
-  _drawSimplifiedBars(context, logEntry, y) {
+  _drawSimplifiedBars(context, node, y) {
     const borderWidth = 1;
     var borderOffset = borderWidth % 2 === 0 ? 0 : 0.5;
 
     context.save();
-    var ranges = this._getSimplifiedBarRange(logEntry, borderOffset);
+    var ranges = this._getSimplifiedBarRange(node, borderOffset);
     var height = this._getBarHeight();
     y += Math.floor(this._rowHeight / 2 - height / 2 + borderWidth) - borderWidth / 2;
 
     context.translate(0, y);
-    context.fillStyle = this._colorForResourceType(context, logEntry);
-    context.strokeStyle = this._borderColorForResourceType(logEntry);
+    context.fillStyle = this._colorForResourceType(context, node);
+    context.strokeStyle = this._borderColorForResourceType(node);
     context.lineWidth = borderWidth;
 
     context.beginPath();
     context.globalAlpha = 0.5;
     context.rect(ranges.start, 0, ranges.mid - ranges.start, height - borderWidth);
     context.fill();
     context.stroke();
 
     var barWidth = Math.max(2, ranges.end - ranges.mid);
     context.beginPath();
     context.globalAlpha = 1;
     context.rect(ranges.mid, 0, barWidth, height - borderWidth);
     context.fill();
     context.stroke();
 
     /** @type {?{left: string, right: string, tooltip: (string|undefined)}} */
     var labels = null;
-    if (logEntry === this._hoveredLogEntry) {
-      labels = this._calculator.computeBarGraphLabels(logEntry.request());
+    if (node === this._hoveredNode) {
+      labels = this._calculator.computeBarGraphLabels(node.request());
       this._drawSimplifiedBarDetails(
           context, labels.left, labels.right, ranges.start, ranges.mid, ranges.mid + barWidth + borderOffset);
     }
 
     if (!this._calculator.startAtZero) {
-      var queueingRange = Network.RequestTimingView.calculateRequestTimeRanges(logEntry.request(), 0)
+      var queueingRange = Network.RequestTimingView.calculateRequestTimeRanges(node.request(), 0)
                               .find(data => data.name === Network.RequestTimeRangeNames.Total);
       var leftLabelWidth = labels ? context.measureText(labels.left).width : 0;
       var leftTextPlacedInBar = leftLabelWidth < ranges.mid - ranges.start;
       const wiskerTextPadding = 13;
       var textOffset = (labels && !leftTextPlacedInBar) ? leftLabelWidth + wiskerTextPadding : 0;
       var queueingStart = this._timeToPosition(queueingRange.start);
       if (ranges.start - textOffset > queueingStart) {
         context.beginPath();
         context.globalAlpha = 1;
         context.strokeStyle = UI.themeSupport.patchColor('#a5a5a5', UI.ThemeSupport.ColorUsage.Foreground);
@@ skipping 55 matching lines @@
       context.lineWidth = 1;
       context.moveTo(endX, Math.floor(height / 2));
       context.lineTo(endX + barDotLineLength, Math.floor(height / 2));
       context.stroke();
     }
     context.restore();
   }
 
   /**
    * @param {!CanvasRenderingContext2D} context
-   * @param {!Network.NetworkLogEntry} logEntry
+   * @param {!Network.NetworkDataGridNode} node
    * @param {number} y
    */
-  _drawTimingBars(context, logEntry, y) {
+  _drawTimingBars(context, node, y) {
     context.save();
-    var ranges = Network.RequestTimingView.calculateRequestTimeRanges(logEntry.request(), 0);
+    var ranges = Network.RequestTimingView.calculateRequestTimeRanges(node.request(), 0);
     for (var range of ranges) {
       if (range.name === Network.RequestTimeRangeNames.Total || range.name === Network.RequestTimeRangeNames.Sending ||
           range.end - range.start === 0)
         continue;
       context.beginPath();
       var lineWidth = 0;
       var color = this._colorForType(range.name);
       var borderColor = color;
       if (range.name === Network.RequestTimeRangeNames.Queueing) {
         borderColor = 'lightgrey';
@@ skipping 12 matching lines @@
         context.strokeStyle = borderColor;
         context.stroke();
       }
       context.fill();
     }
     context.restore();
   }
 
   /**
    * @param {!CanvasRenderingContext2D} context
-   * @param {!Network.NetworkLogEntry} logEntry
+   * @param {!Network.NetworkDataGridNode} node
    * @param {number} rowNumber
    * @param {number} y
    */
-  _decorateRow(context, logEntry, rowNumber, y) {
+  _decorateRow(context, node, rowNumber, y) {
     var isOddRow = rowNumber % 2 === 1;
-    if (isOddRow && this._hoveredLogEntry !== logEntry && !logEntry.isNavigationRequest() && !this._initiatorGraph)
+    if (isOddRow && this._hoveredNode !== node && !node.isNavigationRequest() && !this._initiatorGraph)
       return;
 
     var color = getRowColor.call(this);
     if (color === 'transparent')
       return;
     context.save();
     context.beginPath();
     context.fillStyle = color;
     context.rect(0, y, this._offsetWidth, this._rowHeight);
     context.fill();
     context.restore();
 
     /**
      * @return {string}
      * @this {Network.NetworkWaterfallColumn}
      */
     function getRowColor() {
-      var request = logEntry.request();
-      if (this._hoveredLogEntry === logEntry)
+      var request = node.request();
+      if (this._hoveredNode === node)
         return this._rowHoverColor;
       if (this._initiatorGraph) {
         if (this._initiatorGraph.initiators.has(request))
           return this._parentInitiatorColor;
         if (this._initiatorGraph.initiated.has(request))
           return this._initiatedColor;
       }
-      if (logEntry.isNavigationRequest())
+      if (node.isNavigationRequest())
         return this._rowNavigationRequestColor;
       if (rowNumber % 2 === 1)
         return 'transparent';
       return this._rowStripeColor;
     }
   }
 };
 
 Network.NetworkWaterfallColumn._colorsForResourceType = {
   document: 'hsl(215, 100%, 80%)',
   font: 'hsl(8, 100%, 80%)',
   media: 'hsl(90, 50%, 80%)',
   image: 'hsl(90, 50%, 80%)',
   script: 'hsl(31, 100%, 80%)',
   stylesheet: 'hsl(272, 64%, 80%)',
   texttrack: 'hsl(8, 100%, 80%)',
   websocket: 'hsl(0, 0%, 95%)',
   xhr: 'hsl(53, 100%, 80%)',
   other: 'hsl(0, 0%, 95%)'
 };