DevTools: extract modules (non-extensions)

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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @unrestricted
  */
-UI.TimelineOverviewPane = class extends UI.VBox {
+PerfUI.TimelineOverviewPane = class extends UI.VBox {
   /**
    * @param {string} prefix
    */
   constructor(prefix) {
     super();
     this.element.id = prefix + '-overview-pane';
 
-    this._overviewCalculator = new UI.TimelineOverviewCalculator();
-    this._overviewGrid = new UI.OverviewGrid(prefix);
+    this._overviewCalculator = new PerfUI.TimelineOverviewCalculator();
+    this._overviewGrid = new PerfUI.OverviewGrid(prefix);
     this.element.appendChild(this._overviewGrid.element);
     this._cursorArea = this._overviewGrid.element.createChild('div', 'overview-grid-cursor-area');
     this._cursorElement = this._overviewGrid.element.createChild('div', 'overview-grid-cursor-position');
     this._cursorArea.addEventListener('mousemove', this._onMouseMove.bind(this), true);
     this._cursorArea.addEventListener('mouseleave', this._hideCursor.bind(this), true);
 
     this._overviewGrid.setResizeEnabled(false);
-    this._overviewGrid.addEventListener(UI.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
+    this._overviewGrid.addEventListener(PerfUI.OverviewGrid.Events.WindowChanged, this._onWindowChanged, this);
     this._overviewGrid.setClickHandler(this._onClick.bind(this));
     this._overviewControls = [];
     this._markers = new Map();
 
     this._popoverHelper = new UI.PopoverHelper(this._cursorArea);
     this._popoverHelper.initializeCallbacks(
         this._getPopoverAnchor.bind(this), this._showPopover.bind(this), this._onHidePopover.bind(this));
     this._popoverHelper.setTimeout(0);
 
     this._updateThrottler = new Common.Throttler(100);
@@ skipping 12 matching lines @@
     return this._cursorArea;
   }
 
   /**
    * @param {!Element} anchor
    * @param {!UI.Popover} popover
    */
   _showPopover(anchor, popover) {
     this._buildPopoverContents().then(maybeShowPopover.bind(this));
     /**
-     * @this {UI.TimelineOverviewPane}
+     * @this {PerfUI.TimelineOverviewPane}
      * @param {!DocumentFragment} fragment
      */
     function maybeShowPopover(fragment) {
       if (!fragment.firstChild)
         return;
-      var content = new UI.TimelineOverviewPane.PopoverContents();
+      var content = new PerfUI.TimelineOverviewPane.PopoverContents();
       this._popoverContents = content.contentElement.createChild('div');
       this._popoverContents.appendChild(fragment);
       this._popover = popover;
       popover.showView(content, this._cursorElement);
     }
   }
 
   _onHidePopover() {
     this._popover = null;
     this._popoverContents = null;
   }
 
   /**
    * @param {!Event} event
    */
   _onMouseMove(event) {
     if (!this._cursorEnabled)
       return;
     this._cursorPosition = event.offsetX + event.target.offsetLeft;
     this._cursorElement.style.left = this._cursorPosition + 'px';
     this._cursorElement.style.visibility = 'visible';
     if (!this._popover)
       return;
     this._buildPopoverContents().then(updatePopover.bind(this));
     this._popover.positionElement(this._cursorElement);
 
     /**
      * @param {!DocumentFragment} fragment
-     * @this {UI.TimelineOverviewPane}
+     * @this {PerfUI.TimelineOverviewPane}
      */
     function updatePopover(fragment) {
       if (!this._popoverContents)
         return;
       this._popoverContents.removeChildren();
       this._popoverContents.appendChild(fragment);
     }
   }
 
   /**
@@ skipping 40 matching lines @@
    */
   onResize() {
     var width = this.element.offsetWidth;
     if (width === this._lastWidth)
       return;
     this._lastWidth = width;
     this.scheduleUpdate();
   }
 
   /**
-   * @param {!Array.<!UI.TimelineOverview>} overviewControls
+   * @param {!Array.<!PerfUI.TimelineOverview>} overviewControls
    */
   setOverviewControls(overviewControls) {
     for (var i = 0; i < this._overviewControls.length; ++i)
       this._overviewControls[i].dispose();
 
     for (var i = 0; i < overviewControls.length; ++i) {
       overviewControls[i].setCalculator(this._overviewCalculator);
       overviewControls[i].show(this._overviewGrid.element);
     }
     this._overviewControls = overviewControls;
     this._update();
   }
 
   /**
    * @param {number} minimumBoundary
    * @param {number} maximumBoundary
    */
   setBounds(minimumBoundary, maximumBoundary) {
     this._overviewCalculator.setBounds(minimumBoundary, maximumBoundary);
     this._overviewGrid.setResizeEnabled(true);
     this._cursorEnabled = true;
   }
 
   scheduleUpdate() {
     this._updateThrottler.schedule(process.bind(this));
     /**
-     * @this {UI.TimelineOverviewPane}
+     * @this {PerfUI.TimelineOverviewPane}
      * @return {!Promise.<undefined>}
      */
     function process() {
       this._update();
       return Promise.resolve();
     }
   }
 
   _update() {
     if (!this.isShowing())
@@ skipping 63 matching lines @@
   _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());
     this._windowStartTime = windowTimes.startTime;
     this._windowEndTime = windowTimes.endTime;
-    this.dispatchEventToListeners(UI.TimelineOverviewPane.Events.WindowChanged, windowTimes);
+    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(
-        UI.TimelineOverviewPane.Events.WindowChanged, {startTime: startTime, endTime: endTime});
+        PerfUI.TimelineOverviewPane.Events.WindowChanged, {startTime: startTime, endTime: endTime});
   }
 
   _updateWindow() {
     if (!this._overviewControls.length)
       return;
     var windowBoundaries = this._overviewControls[0].windowBoundaries(this._windowStartTime, this._windowEndTime);
     this._muteOnWindowChanged = true;
     this._overviewGrid.setWindow(windowBoundaries.left, windowBoundaries.right);
     this._muteOnWindowChanged = false;
   }
 };
 
 /** @enum {symbol} */
-UI.TimelineOverviewPane.Events = {
+PerfUI.TimelineOverviewPane.Events = {
   WindowChanged: Symbol('WindowChanged')
 };
 
 /**
  * @unrestricted
  */
-UI.TimelineOverviewPane.PopoverContents = class extends UI.VBox {
+PerfUI.TimelineOverviewPane.PopoverContents = class extends UI.VBox {
   constructor() {
     super(true);
     this.contentElement.classList.add('timeline-overview-popover');
   }
 };
 
 /**
- * @implements {UI.TimelineGrid.Calculator}
+ * @implements {PerfUI.TimelineGrid.Calculator}
  * @unrestricted
  */
-UI.TimelineOverviewCalculator = class {
+PerfUI.TimelineOverviewCalculator = class {
   constructor() {
     this.reset();
   }
 
   /**
    * @override
    * @return {number}
    */
   paddingLeft() {
     return this._paddingLeft;
@@ skipping 77 matching lines @@
    * @return {number}
    */
   boundarySpan() {
     return this._maximumBoundary - this._minimumBoundary;
   }
 };
 
 /**
  * @interface
  */
-UI.TimelineOverview = function() {};
+PerfUI.TimelineOverview = function() {};
 
-UI.TimelineOverview.prototype = {
+PerfUI.TimelineOverview.prototype = {
   /**
    * @param {!Element} parentElement
    * @param {?Element=} insertBefore
    */
   show(parentElement, insertBefore) {},
 
   update() {},
 
   dispose() {},
 
@@ skipping 24 matching lines @@
    * @return {!{left: number, right: number}}
    */
   windowBoundaries(startTime, endTime) {},
 
   timelineStarted() {},
 
   timelineStopped() {},
 };
 
 /**
- * @implements {UI.TimelineOverview}
+ * @implements {PerfUI.TimelineOverview}
  * @unrestricted
  */
-UI.TimelineOverviewBase = class extends UI.VBox {
+PerfUI.TimelineOverviewBase = class extends UI.VBox {
   constructor() {
     super();
-    /** @type {?UI.TimelineOverviewCalculator} */
+    /** @type {?PerfUI.TimelineOverviewCalculator} */
     this._calculator = null;
     this._canvas = this.element.createChild('canvas', 'fill');
     this._context = this._canvas.getContext('2d');
   }
 
   /** @return {number} */
   width() {
     return this._canvas.width;
   }
 
   /** @return {number} */
   height() {
     return this._canvas.height;
   }
 
   /** @return {!CanvasRenderingContext2D} */
   context() {
     return this._context;
   }
 
   /**
    * @protected
-   * @return {?UI.TimelineOverviewCalculator}
+   * @return {?PerfUI.TimelineOverviewCalculator}
    */
   calculator() {
     return this._calculator;
   }
 
   /**
    * @override
    */
   update() {
     this.resetCanvas();
@@ skipping 27 matching lines @@
   timelineStarted() {
   }
 
   /**
    * @override
    */
   timelineStopped() {
   }
 
   /**
-   * @param {!UI.TimelineOverviewCalculator} calculator
+   * @param {!PerfUI.TimelineOverviewCalculator} calculator
    */
   setCalculator(calculator) {
     this._calculator = calculator;
   }
 
   /**
    * @override
    * @param {!Event} event
    * @return {boolean}
    */
@@ skipping 27 matching lines @@
       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;
   }
 };