DevTools: simplify TimelineOverview interface, move windowTimes()/windowBoundaries() to pane

third_party/WebKit/Source/devtools/front_end/perf_ui/TimelineOverviewPane.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 198 matching lines @@
      */
     function process() {
       this._update();
       return Promise.resolve();
     }
   }
 
   _update() {
     if (!this.isShowing())
       return;
-    this._overviewCalculator.setDisplayWindow(this._overviewGrid.clientWidth());
+    this._overviewCalculator.setDisplayWidth(this._overviewGrid.clientWidth());
     for (var i = 0; i < this._overviewControls.length; ++i)
       this._overviewControls[i].update();
     this._overviewGrid.updateDividers(this._overviewCalculator);
     this._updateMarkers();
     this._updateWindow();
   }
 
   /**
    * @param {!Map<number, !Element>} markers
    */
@@ skipping 47 matching lines @@
 
   /**
    * @param {!Common.Event} event
    */
   _onWindowChanged(event) {
     if (this._muteOnWindowChanged)
       return;
     // Always use first control as a time converter.
     if (!this._overviewControls.length)
       return;
-    var windowTimes =
-        this._overviewControls[0].windowTimes(this._overviewGrid.windowLeft(), this._overviewGrid.windowRight());
+
+    var absoluteMin = this._overviewCalculator.minimumBoundary();
+    var timeSpan = this._overviewCalculator.maximumBoundary() - absoluteMin;
+    var windowTimes = {
+      startTime: absoluteMin + timeSpan * this._overviewGrid.windowLeft(),
+      endTime: absoluteMin + timeSpan * this._overviewGrid.windowRight()
+    };
     this._windowStartTime = windowTimes.startTime;
     this._windowEndTime = windowTimes.endTime;
     this.dispatchEventToListeners(PerfUI.TimelineOverviewPane.Events.WindowChanged, windowTimes);
   }
 
   /**
    * @param {number} startTime
    * @param {number} endTime
    */
   requestWindowTimes(startTime, endTime) {
     if (startTime === this._windowStartTime && endTime === this._windowEndTime)
       return;
     this._windowStartTime = startTime;
     this._windowEndTime = endTime;
     this._updateWindow();
     this.dispatchEventToListeners(
         PerfUI.TimelineOverviewPane.Events.WindowChanged, {startTime: startTime, endTime: endTime});
   }
 
   _updateWindow() {
     if (!this._overviewControls.length)
       return;
-    var windowBoundaries = this._overviewControls[0].windowBoundaries(this._windowStartTime, this._windowEndTime);
+
+    var absoluteMin = this._overviewCalculator.minimumBoundary();
+    var timeSpan = this._overviewCalculator.maximumBoundary() - absoluteMin;
+    var haveRecords = absoluteMin > 0;
+    var left = haveRecords && this._windowStartTime ? Math.min((this._windowStartTime - absoluteMin) / timeSpan, 1) : 0;
+    var right = haveRecords && this._windowEndTime < Infinity ? (this._windowEndTime - absoluteMin) / timeSpan : 1;
     this._muteOnWindowChanged = true;
-    this._overviewGrid.setWindow(windowBoundaries.left, windowBoundaries.right);
+    this._overviewGrid.setWindow(left, right);
     this._muteOnWindowChanged = false;
   }
 };
 
 /** @enum {symbol} */
 PerfUI.TimelineOverviewPane.Events = {
   WindowChanged: Symbol('WindowChanged')
 };
 
 /**
@@ skipping 13 matching lines @@
 PerfUI.TimelineOverviewCalculator = class {
   constructor() {
     this.reset();
   }
 
   /**
    * @override
    * @return {number}
    */
   paddingLeft() {
-    return this._paddingLeft;
+    return 0;
   }
 
   /**
    * @override
    * @param {number} time
    * @return {number}
    */
   computePosition(time) {
-    return (time - this._minimumBoundary) / this.boundarySpan() * this._workingArea + this._paddingLeft;
+    return (time - this._minimumBoundary) / this.boundarySpan() * this._workingArea;
   }
 
   /**
    * @param {number} position
    * @return {number}
    */
   positionToTime(position) {
-    return (position - this._paddingLeft) / this._workingArea * this.boundarySpan() + this._minimumBoundary;
+    return position / this._workingArea * this.boundarySpan() + this._minimumBoundary;
   }
 
   /**
    * @param {number} minimumBoundary
    * @param {number} maximumBoundary
    */
   setBounds(minimumBoundary, maximumBoundary) {
     this._minimumBoundary = minimumBoundary;
     this._maximumBoundary = maximumBoundary;
   }
 
   /**
    * @param {number} clientWidth
-   * @param {number=} paddingLeft
    */
-  setDisplayWindow(clientWidth, paddingLeft) {
-    this._paddingLeft = paddingLeft || 0;
-    this._workingArea = clientWidth - this._paddingLeft;
+  setDisplayWidth(clientWidth) {
+    this._workingArea = clientWidth;
   }
 
   reset() {
     this.setBounds(0, 100);
   }
 
   /**
    * @override
    * @param {number} value
    * @param {number=} precision
@@ skipping 58 matching lines @@
    * @param {number} x
    * @return {!Promise<?Element>}
    */
   popoverElementPromise(x) {},
 
   /**
    * @param {!Event} event
    * @return {boolean}
    */
   onClick(event) {},
-
-  /**
-   * @param {number} windowLeft
-   * @param {number} windowRight
-   * @return {!{startTime: number, endTime: number}}
-   */
-  windowTimes(windowLeft, windowRight) {},
-
-  /**
-   * @param {number} startTime
-   * @param {number} endTime
-   * @return {!{left: number, right: number}}
-   */
-  windowBoundaries(startTime, endTime) {},
 };
 
 /**
  * @implements {PerfUI.TimelineOverview}
  * @unrestricted
  */
 PerfUI.TimelineOverviewBase = class extends UI.VBox {
   constructor() {
     super();
     /** @type {?PerfUI.TimelineOverviewCalculator} */
@@ skipping 63 matching lines @@
 
   /**
    * @override
    * @param {!Event} event
    * @return {boolean}
    */
   onClick(event) {
     return false;
   }
 
-  /**
-   * @override
-   * @param {number} windowLeft
-   * @param {number} windowRight
-   * @return {!{startTime: number, endTime: number}}
-   */
-  windowTimes(windowLeft, windowRight) {
-    var absoluteMin = this._calculator.minimumBoundary();
-    var timeSpan = this._calculator.maximumBoundary() - absoluteMin;
-    return {startTime: absoluteMin + timeSpan * windowLeft, endTime: absoluteMin + timeSpan * windowRight};
-  }
-
-  /**
-   * @override
-   * @param {number} startTime
-   * @param {number} endTime
-   * @return {!{left: number, right: number}}
-   */
-  windowBoundaries(startTime, endTime) {
-    var absoluteMin = this._calculator.minimumBoundary();
-    var timeSpan = this._calculator.maximumBoundary() - absoluteMin;
-    var haveRecords = absoluteMin > 0;
-    return {
-      left: haveRecords && startTime ? Math.min((startTime - absoluteMin) / timeSpan, 1) : 0,
-      right: haveRecords && endTime < Infinity ? (endTime - absoluteMin) / timeSpan : 1
-    };
-  }
-
   resetCanvas() {
     this._canvas.width = this.element.clientWidth * window.devicePixelRatio;
     this._canvas.height = this.element.clientHeight * window.devicePixelRatio;
   }
 };