DevTools: extract modules (with extensions)

third_party/WebKit/Source/devtools/front_end/network/NetworkLogViewColumns.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.NetworkLogViewColumns = class {
   /**
    * @param {!Network.NetworkLogView} networkLogView
    * @param {!Network.NetworkTransferTimeCalculator} timeCalculator
@@ skipping 28 matching lines @@
     this._calculatorsMap = new Map();
     this._calculatorsMap.set(Network.NetworkLogViewColumns._calculatorTypes.Time, timeCalculator);
     this._calculatorsMap.set(Network.NetworkLogViewColumns._calculatorTypes.Duration, durationCalculator);
 
     this._setupDataGrid();
     this._setupWaterfall();
   }
 
   /**
    * @param {!Network.NetworkLogViewColumns.Descriptor} columnConfig
-   * @return {!UI.DataGrid.ColumnDescriptor}
+   * @return {!DataGrid.DataGrid.ColumnDescriptor}
    */
   static _convertToDataGridDescriptor(columnConfig) {
-    return /** @type {!UI.DataGrid.ColumnDescriptor} */ ({
+    return /** @type {!DataGrid.DataGrid.ColumnDescriptor} */ ({
       id: columnConfig.id,
       title: columnConfig.title,
       sortable: columnConfig.sortable,
       align: columnConfig.align,
       nonSelectable: columnConfig.nonSelectable,
       weight: columnConfig.weight
     });
   }
 
   wasShown() {
@@ skipping 22 matching lines @@
       if (columnConfig.subtitle)
         columnConfig.titleDOMFragment = this._makeHeaderFragment(columnConfig.title, columnConfig.subtitle);
       this._columns.push(columnConfig);
     }
     this._loadColumns();
 
     this._popoverHelper = new UI.PopoverHelper(this._networkLogView.element);
     this._popoverHelper.initializeCallbacks(
         this._getPopoverAnchor.bind(this), this._showPopover.bind(this), this._onHidePopover.bind(this));
 
-    /** @type {!UI.SortableDataGrid<!Network.NetworkNode>} */
+    /** @type {!DataGrid.SortableDataGrid<!Network.NetworkNode>} */
     this._dataGrid =
-        new UI.SortableDataGrid(this._columns.map(Network.NetworkLogViewColumns._convertToDataGridDescriptor));
+        new DataGrid.SortableDataGrid(this._columns.map(Network.NetworkLogViewColumns._convertToDataGridDescriptor));
     this._dataGrid.element.addEventListener('mousedown', event => {
       if (!this._dataGrid.selectedNode && event.button)
         event.consume();
     }, true);
 
     this._dataGridScroller = this._dataGrid.scrollContainer;
 
     this._updateColumns();
-    this._dataGrid.addEventListener(UI.DataGrid.Events.SortingChanged, this._sortHandler, this);
+    this._dataGrid.addEventListener(DataGrid.DataGrid.Events.SortingChanged, this._sortHandler, this);
     this._dataGrid.setHeaderContextMenuCallback(this._innerHeaderContextMenu.bind(this));
 
     this._activeWaterfallSortId = Network.NetworkLogViewColumns.WaterfallSortIds.StartTime;
-    this._dataGrid.markColumnAsSortedBy(Network.NetworkLogViewColumns._initialSortColumn, UI.DataGrid.Order.Ascending);
+    this._dataGrid.markColumnAsSortedBy(
+        Network.NetworkLogViewColumns._initialSortColumn, DataGrid.DataGrid.Order.Ascending);
 
     this._splitWidget = new UI.SplitWidget(true, true, 'networkPanelSplitViewWaterfall', 200);
     var widget = this._dataGrid.asWidget();
     widget.setMinimumSize(150, 0);
     this._splitWidget.setMainWidget(widget);
   }
 
   _setupWaterfall() {
     this._waterfallColumn =
         new Network.NetworkWaterfallColumn(this._networkLogView.rowHeight(), this._networkLogView.calculator());
 
     this._waterfallColumn.element.addEventListener('contextmenu', handleContextMenu.bind(this));
     this._waterfallColumn.element.addEventListener('mousewheel', this._onMouseWheel.bind(this, false), {passive: true});
     this._dataGridScroller.addEventListener('mousewheel', this._onMouseWheel.bind(this, true), true);
 
     this._waterfallScroller = this._waterfallColumn.contentElement.createChild('div', 'network-waterfall-v-scroll');
     this._waterfallScroller.addEventListener('scroll', this._syncScrollers.bind(this), {passive: true});
     this._waterfallScrollerContent = this._waterfallScroller.createChild('div', 'network-waterfall-v-scroll-content');
 
-    this._dataGrid.addEventListener(UI.DataGrid.Events.PaddingChanged, () => {
+    this._dataGrid.addEventListener(DataGrid.DataGrid.Events.PaddingChanged, () => {
       this._waterfallScrollerWidthIsStale = true;
       this._syncScrollers();
     });
     this._dataGrid.addEventListener(
-        UI.ViewportDataGrid.Events.ViewportCalculated, this._redrawWaterfallColumn.bind(this));
+        DataGrid.ViewportDataGrid.Events.ViewportCalculated, this._redrawWaterfallColumn.bind(this));
 
     this._createWaterfallHeader();
     this._waterfallColumn.contentElement.classList.add('network-waterfall-view');
 
     this._waterfallColumn.setMinimumSize(100, 0);
     this._splitWidget.setSidebarWidget(this._waterfallColumn);
 
     this.switchViewMode(false);
 
     /**
@@ skipping 55 matching lines @@
         'contextmenu', event => this._innerHeaderContextMenu(new UI.ContextMenu(event)));
     var innerElement = this._waterfallHeaderElement.createChild('div');
     innerElement.textContent = Common.UIString('Waterfall');
     this._waterfallColumnSortIcon = this._waterfallHeaderElement.createChild('div', 'sort-order-icon-container')
                                         .createChild('div', 'sort-order-icon');
 
     /**
      * @this {Network.NetworkLogViewColumns}
      */
     function waterfallHeaderClicked() {
-      var sortOrders = UI.DataGrid.Order;
+      var sortOrders = DataGrid.DataGrid.Order;
       var sortOrder =
           this._dataGrid.sortOrder() === sortOrders.Ascending ? sortOrders.Descending : sortOrders.Ascending;
       this._dataGrid.markColumnAsSortedBy('waterfall', sortOrder);
       this._sortHandler();
     }
   }
 
   /**
    * @param {!Network.NetworkTimeCalculator} x
    */
@@ skipping 22 matching lines @@
   }
 
   /**
    * @param {!Element} element
    */
   show(element) {
     this._splitWidget.show(element);
   }
 
   /**
-   * @return {!UI.SortableDataGrid<!Network.NetworkNode>} dataGrid
+   * @return {!DataGrid.SortableDataGrid<!Network.NetworkNode>} dataGrid
    */
   dataGrid() {
     return this._dataGrid;
   }
 
   sortByCurrentColumn() {
     this._sortHandler();
   }
 
   _sortHandler() {
     var columnId = this._dataGrid.sortColumnId();
     this._networkLogView.removeAllNodeHighlights();
     if (columnId === 'waterfall') {
       this._waterfallColumnSortIcon.classList.remove('sort-ascending', 'sort-descending');
 
-      if (this._dataGrid.sortOrder() === UI.DataGrid.Order.Ascending)
+      if (this._dataGrid.sortOrder() === DataGrid.DataGrid.Order.Ascending)
         this._waterfallColumnSortIcon.classList.add('sort-ascending');
       else
         this._waterfallColumnSortIcon.classList.add('sort-descending');
 
       this._waterfallRequestsAreStale = true;
       var sortFunction = Network.NetworkRequestNode.RequestPropertyComparator.bind(null, this._activeWaterfallSortId);
       this._dataGrid.sortNodes(sortFunction, !this._dataGrid.isSortOrderAscending());
       this._networkLogView.dataGridSorted();
       return;
     }
@@ skipping 141 matching lines @@
      * @this {Network.NetworkLogViewColumns}
      */
     function setWaterfallMode(sortId) {
       var calculator = this._calculatorsMap.get(Network.NetworkLogViewColumns._calculatorTypes.Time);
       var waterfallSortIds = Network.NetworkLogViewColumns.WaterfallSortIds;
       if (sortId === waterfallSortIds.Duration || sortId === waterfallSortIds.Latency)
         calculator = this._calculatorsMap.get(Network.NetworkLogViewColumns._calculatorTypes.Duration);
       this._networkLogView.setCalculator(calculator);
 
       this._activeWaterfallSortId = sortId;
-      this._dataGrid.markColumnAsSortedBy('waterfall', UI.DataGrid.Order.Ascending);
+      this._dataGrid.markColumnAsSortedBy('waterfall', DataGrid.DataGrid.Order.Ascending);
       this._sortHandler();
     }
   }
 
   _manageCustomHeaderDialog() {
     var customHeaders = [];
     for (var columnConfig of this._columns) {
       if (columnConfig.isResponseHeader)
         customHeaders.push({title: columnConfig.title, editable: columnConfig.isCustomHeader});
     }
@@ skipping 162 matching lines @@
  * @typedef {{
  *     id: string,
  *     title: string,
  *     titleDOMFragment: (!DocumentFragment|undefined),
  *     subtitle: (string|null),
  *     visible: boolean,
  *     weight: number,
  *     hideable: boolean,
  *     nonSelectable: boolean,
  *     sortable: boolean,
- *     align: (?UI.DataGrid.Align|undefined),
+ *     align: (?DataGrid.DataGrid.Align|undefined),
  *     isResponseHeader: boolean,
  *     sortingFunction: (!function(!Network.NetworkNode, !Network.NetworkNode):number|undefined),
  *     isCustomHeader: boolean
  * }}
  */
 Network.NetworkLogViewColumns.Descriptor;
 
 /** @enum {string} */
 Network.NetworkLogViewColumns._calculatorTypes = {
   Duration: 'Duration',
@@ skipping 54 matching lines @@
   },
   {
     id: 'domain',
     title: Common.UIString('Domain'),
     sortingFunction: Network.NetworkRequestNode.RequestPropertyComparator.bind(null, 'domain')
   },
   {
     id: 'remoteaddress',
     title: Common.UIString('Remote Address'),
     weight: 10,
-    align: UI.DataGrid.Align.Right,
+    align: DataGrid.DataGrid.Align.Right,
     sortingFunction: Network.NetworkRequestNode.RemoteAddressComparator
   },
   {
     id: 'type',
     title: Common.UIString('Type'),
     visible: true,
     sortingFunction: Network.NetworkRequestNode.TypeComparator
   },
   {
     id: 'initiator',
     title: Common.UIString('Initiator'),
     visible: true,
     weight: 10,
     sortingFunction: Network.NetworkRequestNode.InitiatorComparator
   },
   {
     id: 'cookies',
     title: Common.UIString('Cookies'),
-    align: UI.DataGrid.Align.Right,
+    align: DataGrid.DataGrid.Align.Right,
     sortingFunction: Network.NetworkRequestNode.RequestCookiesCountComparator
   },
   {
     id: 'setcookies',
     title: Common.UIString('Set Cookies'),
-    align: UI.DataGrid.Align.Right,
+    align: DataGrid.DataGrid.Align.Right,
     sortingFunction: Network.NetworkRequestNode.ResponseCookiesCountComparator
   },
   {
     id: 'size',
     title: Common.UIString('Size'),
     visible: true,
     subtitle: Common.UIString('Content'),
-    align: UI.DataGrid.Align.Right,
+    align: DataGrid.DataGrid.Align.Right,
     sortingFunction: Network.NetworkRequestNode.SizeComparator
   },
   {
     id: 'time',
     title: Common.UIString('Time'),
     visible: true,
     subtitle: Common.UIString('Latency'),
-    align: UI.DataGrid.Align.Right,
+    align: DataGrid.DataGrid.Align.Right,
     sortingFunction: Network.NetworkRequestNode.RequestPropertyComparator.bind(null, 'duration')
   },
   {
     id: 'priority',
     title: Common.UIString('Priority'),
     sortingFunction: Network.NetworkRequestNode.InitialPriorityComparator
   },
   {
     id: 'connectionid',
     title: Common.UIString('Connection ID'),
@@ skipping 14 matching lines @@
   {
     id: 'content-encoding',
     isResponseHeader: true,
     title: Common.UIString('Content-Encoding'),
     sortingFunction: Network.NetworkRequestNode.ResponseHeaderStringComparator.bind(null, 'content-encoding')
   },
   {
     id: 'content-length',
     isResponseHeader: true,
     title: Common.UIString('Content-Length'),
-    align: UI.DataGrid.Align.Right,
+    align: DataGrid.DataGrid.Align.Right,
     sortingFunction: Network.NetworkRequestNode.ResponseHeaderNumberComparator.bind(null, 'content-length')
   },
   {
     id: 'etag',
     isResponseHeader: true,
     title: Common.UIString('ETag'),
     sortingFunction: Network.NetworkRequestNode.ResponseHeaderStringComparator.bind(null, 'etag')
   },
   {
     id: 'keep-alive',
@@ skipping 28 matching lines @@
 /**
  * @enum {string}
  */
 Network.NetworkLogViewColumns.WaterfallSortIds = {
   StartTime: 'startTime',
   ResponseTime: 'responseReceivedTime',
   EndTime: 'endTime',
   Duration: 'duration',
   Latency: 'latency'
 };