DevTools: Display product information in ConsoleContextSelector

third_party/WebKit/Source/devtools/front_end/ui/ListControl.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.
 
 /**
  * @template T
  * @interface
  */
 UI.ListDelegate = function() {};
 
@@ skipping 106 matching lines @@
 
   /**
    * @param {number} index
    * @param {T} item
    */
   insertItemAtIndex(index, item) {
     this.replaceItemsInRange(index, index, [item]);
   }
 
   /**
+   * @param {T} item
+   * @param {function(T, T):number} comparator
+   */
+  insertItemWithComparator(item, comparator) {
+    var index = this._items.lowerBound(item, comparator);
+    this.insertItemAtIndex(index, item);
+  }
+
+  /**
+   * @param {T} item
+   * @return {number}
+   */
+  indexOfItem(item) {
+    return this._items.indexOf(item);
+  }
+
+  /**
    * @param {number} index
    * @return {T}
    */
   removeItemAtIndex(index) {
     var result = this._items[index];
     this.replaceItemsInRange(index, index + 1, []);
     return result;
   }
 
   /**
    * @param {T} item
    */
   removeItem(item) {
     var index = this._items.indexOf(item);
-    if (index === -1)
-      throw 'Attempt to remove non-existing item';
+    if (index === -1) {
+      console.error('Attempt to remove non-existing item');
+      return;
+    }
     this.removeItemAtIndex(index);
   }
 
   /**
    * @param {number} from
    * @param {number} to
    * @param {!Array<T>} items
    */
   replaceItemsInRange(from, to, items) {
     var oldSelectedItem = this._selectedIndex !== -1 ? this._items[this._selectedIndex] : null;
@@ skipping 21 matching lines @@
     }
   }
 
   /**
    * @param {!Array<T>} items
    */
   replaceAllItems(items) {
     this.replaceItemsInRange(0, this._items.length, items);
   }
 
+  refreshAllItems() {
+    this.refreshItemsInRange(0, this._items.length);
+  }
+
   /**
    * @param {number} from
    * @param {number} to
+   */
+  refreshItemsInRange(from, to) {
+    for (var i = from; i < to; i++)
+      this._itemToElement.delete(this._items[i]);
+    this.invalidateRange(from, to);
+    if (this._selectedIndex !== -1)
+      this._select(this._selectedIndex, null, null);
+  }
+
+  /**
+   * @param {number} from
+   * @param {number} to
    */
   invalidateRange(from, to) {
     this._invalidate(from, to, to - from);
   }
 
   viewportResized() {
     if (this._mode === UI.ListMode.NonViewport)
       return;
     // TODO(dgozman): try to keep visible scrollTop the same.
     var scrollTop = this.element.scrollTop;
     var viewportHeight = this.element.offsetHeight;
     this._clearViewport();
     this._updateViewport(Number.constrain(scrollTop, 0, this._totalHeight() - viewportHeight), viewportHeight);
   }
 
   invalidateItemHeight() {
-    if (this._mode !== UI.ListMode.EqualHeightItems)
-      throw 'Only supported in equal height items mode';
+    if (this._mode !== UI.ListMode.EqualHeightItems) {
+      console.error('Only supported in equal height items mode');
+      return;
+    }
     this._fixedHeight = 0;
     if (this._items.length) {
       this._itemToElement.clear();
       this._invalidate(0, this._items.length, this._items.length);
     }
   }
 
   /**
    * @param {?Node} node
    * @return {?T}
    */
   itemForNode(node) {
     while (node && node.parentNodeOrShadowHost() !== this.element)
       node = node.parentNodeOrShadowHost();
     if (!node)
       return null;
     var element = /** @type {!Element} */ (node);
     var index = this._items.findIndex(item => this._itemToElement.get(item) === element);
     return index !== -1 ? this._items[index] : null;
   }
 
   /**
    * @param {T} item
    * @param {boolean=} center
    */
   scrollItemIntoView(item, center) {
     var index = this._items.indexOf(item);
-    if (index === -1)
-      throw 'Attempt to scroll onto missing item';
+    if (index === -1) {
+      console.error('Attempt to scroll onto missing item');
+      return;
+    }
     this._scrollIntoView(index, center);
   }
 
   /**
    * @return {?T}
    */
   selectedItem() {
     return this._selectedIndex === -1 ? null : this._items[this._selectedIndex];
   }
 
   /**
+   * @return {number}
+   */
+  selectedIndex() {
+    return this._selectedIndex;
+  }
+
+  /**
    * @param {?T} item
    * @param {boolean=} center
+   * @param {boolean=} dontScroll
    */
-  selectItem(item, center) {
+  selectItem(item, center, dontScroll) {
     var index = -1;
     if (item !== null) {
       index = this._items.indexOf(item);
-      if (index === -1)
-        throw 'Attempt to select missing item';
-      if (!this._delegate.isItemSelectable(item))
-        throw 'Attempt to select non-selectable item';
+      if (index === -1) {
+        console.error('Attempt to select missing item');
+        return;
+      }
+      if (!this._delegate.isItemSelectable(item)) {
+        console.error('Attempt to select non-selectable item');
+        return;
+      }
     }
     if (this._selectedIndex !== index)
       this._select(index);
-    if (index !== -1)
+    if (index !== -1 && !dontScroll)
       this._scrollIntoView(index, center);
   }
 
   /**
    * @param {boolean=} canWrap
    * @param {boolean=} center
    * @return {boolean}
    */
   selectPreviousItem(canWrap, center) {
     if (this._selectedIndex === -1 && !canWrap)
@@ skipping 318 matching lines @@
     var startElement = this._topElement;
     for (var index = 0; index < start; index++)
       startElement = startElement.nextElementSibling;
     while (remove--)
       startElement.nextElementSibling.remove();
     while (add--)
       this.element.insertBefore(this._elementAtIndex(start + add), startElement.nextElementSibling);
   }
 
   _clearViewport() {
-    if (this._mode === UI.ListMode.NonViewport)
-      throw 'There should be no viewport updates in non-viewport mode';
+    if (this._mode === UI.ListMode.NonViewport) {
+      console.error('There should be no viewport updates in non-viewport mode');
+      return;
+    }
     this._firstIndex = 0;
     this._lastIndex = 0;
     this._renderedHeight = 0;
     this._topHeight = 0;
     this._bottomHeight = 0;
     this._clearContents();
   }
 
   _clearContents() {
     // Note: this method should not force layout. Be careful.
     this._topElement.style.height = '0';
     this._bottomElement.style.height = '0';
     this.element.removeChildren();
     this.element.appendChild(this._topElement);
     this.element.appendChild(this._bottomElement);
   }
 
   /**
    * @param {number} scrollTop
    * @param {number} viewportHeight
    */
   _updateViewport(scrollTop, viewportHeight) {
     // Note: this method should not force layout. Be careful.
-    if (this._mode === UI.ListMode.NonViewport)
-      throw 'There should be no viewport updates in non-viewport mode';
-
+    if (this._mode === UI.ListMode.NonViewport) {
+      console.error('There should be no viewport updates in non-viewport mode');
+      return;
+    }
     var totalHeight = this._totalHeight();
     if (!totalHeight) {
       this._firstIndex = 0;
       this._lastIndex = 0;
       this._topHeight = 0;
       this._bottomHeight = 0;
       this._renderedHeight = 0;
       this._topElement.style.height = '0';
       this._bottomElement.style.height = '0';
       return;
@@ skipping 25 matching lines @@
     this._firstIndex = firstIndex;
     this._lastIndex = lastIndex;
     this._topHeight = this._offsetAtIndex(firstIndex);
     this._topElement.style.height = this._topHeight + 'px';
     this._bottomHeight = totalHeight - this._offsetAtIndex(lastIndex);
     this._bottomElement.style.height = this._bottomHeight + 'px';
     this._renderedHeight = totalHeight;
     this.element.scrollTop = scrollTop;
   }
 };