DevTools: Display product information in ConsoleContextSelector

third_party/WebKit/Source/devtools/front_end/console/ConsoleContextSelector.js

 // Copyright 2015 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.
 /**
  * @implements {SDK.SDKModelObserver<!SDK.RuntimeModel>}
+ * @implements {UI.ListDelegate<!SDK.ExecutionContext>}
  * @unrestricted
  */
-Console.ConsoleContextSelector = class {
-  /**
-   * @param {!Element} selectElement
-   */
-  constructor(selectElement) {
-    this._selectElement = selectElement;
+Console.ConsoleContextSelector = class extends UI.ToolbarItem {
+  constructor() {
+    super(createElementWithClass('button', 'console-context'));
+    this._titleElement = this.element.createChild('span');
+    this._titleElement.textContent = '';
+    this._titleElement.style.paddingRight = '5px';
+    this._titleElement.style.width = '120px';
+    this._titleElement.style.overflow = 'hidden';
+    this._titleElement.style.textOverflow = 'ellipsis ';
+    this._productRegistry = null;
+
+    ProductRegistry.instance().then(registry => {
+      this._productRegistry = registry;
+      this._list.refreshAllItems();
+    });
+    this.element.classList.add('toolbar-has-dropdown');
+    this.element.tabIndex = 0;
+    this._glassPane = new UI.GlassPane();
+    this._glassPane.setMaxContentSize(new UI.Size(315, 310));
+    this._glassPane.setMarginBehavior(UI.GlassPane.MarginBehavior.NoMargin);
+    this._glassPane.setSizeBehavior(UI.GlassPane.SizeBehavior.SetExactWidthMaxHeight);
+    this._glassPane.setAnchorBehavior(UI.GlassPane.AnchorBehavior.PreferBottom);
+    this._glassPane.setOutsideClickCallback(this._hide.bind(this));
+    /** @type {!Array<!SDK.ExecutionContext>} */
+    this._executionContexts = [];
+    this._list = new UI.ListControl(this, UI.ListMode.NonViewport);
+    this._list.element.classList.add('context-list');
+    this._list.element.tabIndex = -1;
+    var shadowRoot =
+        UI.createShadowRootWithCoreStyles(this._glassPane.contentElement, 'console/consoleContextSelector.css');
+    shadowRoot.appendChild(this._list.element);
+
+    this._canSelect = false;
+    this.element.addEventListener('mousedown', event => {
+      if (this._canSelect)
+        this._hide(event);
+      else
+        this._show(event);
+    }, false);
+    this.element.addEventListener('click', event => {
+      if (!this._canSelect)
+        this._show(event);
+    }, false);
+    this.element.addEventListener('keydown', this._onKeyDown.bind(this), false);
+    this.element.addEventListener('blur', this._hide.bind(this), false);
+    this._list.element.addEventListener('mousedown', event => {
+      this._hide(event);
+      this._updateSelectedContext();
+    }, false);
+    this._list.element.addEventListener('mouseup', event => {
+      if (!this._canSelect)
+        return;
+      this._hide(event);
+      this._updateSelectedContext();
+    }, false);
+
+    var dropdownArrowIcon = UI.Icon.create('smallicon-triangle-down', 'toolbar-dropdown-arrow');
+    this.element.appendChild(dropdownArrowIcon);
+
+
     /**
      * @type {!Map.<!SDK.ExecutionContext, !Element>}
      */
     this._optionByExecutionContext = new Map();
 
     SDK.targetManager.addModelListener(
         SDK.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextCreated, this._onExecutionContextCreated, this);
     SDK.targetManager.addModelListener(
         SDK.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextChanged, this._onExecutionContextChanged, this);
     SDK.targetManager.addModelListener(
         SDK.RuntimeModel, SDK.RuntimeModel.Events.ExecutionContextDestroyed, this._onExecutionContextDestroyed, this);
+    SDK.targetManager.addModelListener(
+        SDK.ResourceTreeModel, SDK.ResourceTreeModel.Events.FrameNavigated, this._frameNavigated, this);
 
-    this._selectElement.addEventListener('change', this._executionContextChanged.bind(this), false);
     UI.context.addFlavorChangeListener(SDK.ExecutionContext, this._executionContextChangedExternally, this);
     UI.context.addFlavorChangeListener(SDK.DebuggerModel.CallFrame, this._callFrameSelectedInUI, this);
     SDK.targetManager.observeModels(SDK.RuntimeModel, this);
     SDK.targetManager.addModelListener(
         SDK.DebuggerModel, SDK.DebuggerModel.Events.CallFrameSelected, this._callFrameSelectedInModel, this);
   }
 
   /**
+   * @param {!Event} event
+   */
+  _show(event) {
+    if (this._glassPane.isShowing())
+      return;
+    this._glassPane.setContentAnchorBox(this.element.boxInWindow());
+    if (this.element.ownerDocument)
+      this._glassPane.show(this.element.ownerDocument);
+    this._list.viewportResized();
+    var selectedItem = this._list.selectedItem();
+    if (selectedItem)
+      this._list.scrollItemIntoView(selectedItem, true);
+    this.element.focus();
+    event.consume(true);
+    setTimeout(() => this._canSelect = true, 200);
+  }
+
+  /**
+   * @param {!Event} event
+   */
+  _hide(event) {
+    setTimeout(() => this._canSelect = false, 200);
+    this._glassPane.hide();
+    SDK.OverlayModel.hideDOMNodeHighlight();
+    event.consume(true);
+  }
+
+  /**
+   * @param {!Event} event
+   */
+  _onKeyDown(event) {
+    var handled = false;
+    switch (event.key) {
+      case 'ArrowUp':
+        handled = this._list.selectPreviousItem(false, false);
+        break;
+      case 'ArrowDown':
+        handled = this._list.selectNextItem(false, false);
+        break;
+      case 'ArrowRight':
+        var currentExecutionContext = this._list.selectedItem();
+        if (!currentExecutionContext)
+          break;
+        var nextExecutionContext =
+            this._executionContexts[this._executionContexts.indexOf(currentExecutionContext) + 1];
+        if (nextExecutionContext && this._depthFor(currentExecutionContext) < this._depthFor(nextExecutionContext))
+          handled = this._list.selectNextItem(false, false);
+        break;
+      case 'ArrowLeft':
+        var currentExecutionContext = this._list.selectedItem();
+        if (!currentExecutionContext)
+          break;
+        var depth = this._depthFor(currentExecutionContext);
+        for (var i = this._executionContexts.indexOf(currentExecutionContext) - 1; i >= 0; i--) {
+          if (this._depthFor(this._executionContexts[i]) < depth) {
+            handled = true;
+            this._list.selectItem(this._executionContexts[i], false);
+            break;
+          }
+        }
+        break;
+      case 'PageUp':
+        handled = this._list.selectItemPreviousPage(false);
+        break;
+      case 'PageDown':
+        handled = this._list.selectItemNextPage(false);
+        break;
+      case 'Escape':
+        if (this._glassPane.isShowing())
+          event.consume(true);
+        this._glassPane.hide();
+        return;
+      case 'Enter':
+        handled = this._glassPane.isShowing();
+        this._glassPane.hide();
+        break;
+      default:
+        if (event.key.length === 1) {
+          var selectedItem = this._list.selectedItem();
+          var selectedIndex = selectedItem ? this._executionContexts.indexOf(selectedItem) : -1;
+          var context =
+              this._executionContexts.slice(selectedIndex + 1)
+                  .find(context => this._titleFor(context).toUpperCase().startsWith(event.key.toUpperCase())) ||
+              this._executionContexts.slice(0, selectedIndex)
+                  .find(context => this._titleFor(context).toUpperCase().startsWith(event.key.toUpperCase()));
+          if (context)
+            this._list.selectItem(context);
+          handled = true;
+        }
+        break;
+    }
+
+    if (handled) {
+      event.consume(true);
+      this._updateSelectedContext();
+    }
+  }
+
+  /**
    * @param {!SDK.ExecutionContext} executionContext
    * @return {string}
    */
   _titleFor(executionContext) {
     var target = executionContext.target();
+    var label = executionContext.label() ? target.decorateLabel(executionContext.label()) : '';
+    if (executionContext.frameId) {
+      var resourceTreeModel = target.model(SDK.ResourceTreeModel);
+      var frame = resourceTreeModel && resourceTreeModel.frameForId(executionContext.frameId);
+      if (frame)
+        label = label || frame.displayName();
+    }
+    label = label || executionContext.origin;
+
+    return label;
+  }
+
+  /**
+   * @param {!SDK.ExecutionContext} executionContext
+   * @return {number}
+   */
+  _depthFor(executionContext) {
+    var target = executionContext.target();
     var depth = 0;
-    var label = executionContext.label() ? target.decorateLabel(executionContext.label()) : '';
     if (!executionContext.isDefault)
       depth++;
     if (executionContext.frameId) {
       var resourceTreeModel = target.model(SDK.ResourceTreeModel);
       var frame = resourceTreeModel && resourceTreeModel.frameForId(executionContext.frameId);
-      if (frame) {
-        label = label || frame.displayName();
-        while (frame.parentFrame) {
-          depth++;
-          frame = frame.parentFrame;
-        }
+      while (frame && frame.parentFrame) {
+        depth++;
+        frame = frame.parentFrame;
       }
     }
-    label = label || executionContext.origin;
     var targetDepth = 0;
     while (target.parentTarget()) {
       if (target.parentTarget().hasJSCapability()) {
         targetDepth++;
       } else {
         // Special casing service workers to be top-level.
         targetDepth = 0;
         break;
       }
       target = target.parentTarget();
     }
-
     depth += targetDepth;
-    var prefix = new Array(4 * depth + 1).join('\u00a0');
-    var maxLength = 50;
-    return (prefix + label).trimMiddle(maxLength);
+    return depth;
   }
 
   /**
    * @param {!SDK.ExecutionContext} executionContext
    */
   _executionContextCreated(executionContext) {
     // FIXME(413886): We never want to show execution context for the main thread of shadow page in service/shared worker frontend.
     // This check could be removed once we do not send this context to frontend.
     if (!executionContext.target().hasJSCapability())
       return;
 
-    var newOption = createElement('option');
-    newOption.__executionContext = executionContext;
-    newOption.text = this._titleFor(executionContext);
-    this._optionByExecutionContext.set(executionContext, newOption);
-    var options = this._selectElement.options;
-    var contexts = Array.prototype.map.call(options, mapping);
-    var index = contexts.lowerBound(executionContext, executionContext.runtimeModel.executionContextComparator());
-    this._selectElement.insertBefore(newOption, options[index]);
+    var index = this._executionContexts.lowerBound(
+        executionContext, executionContext.runtimeModel.executionContextComparator());
+    this._executionContexts.splice(index, 0, executionContext);
+    this._list.insertItemAtIndex(index, executionContext);
 
-    if (executionContext === UI.context.flavor(SDK.ExecutionContext))
-      this._select(newOption);
-    this._updateOptionDisabledState(newOption);
-
-    /**
-     * @param {!Element} option
-     * @return {!SDK.ExecutionContext}
-     */
-    function mapping(option) {
-      return option.__executionContext;
+    if (executionContext === UI.context.flavor(SDK.ExecutionContext)) {
+      this._list.selectItem(executionContext);
+      this._updateSelectedContext();
     }
   }
 
   /**
    * @param {!Common.Event} event
    */
   _onExecutionContextCreated(event) {
     var executionContext = /** @type {!SDK.ExecutionContext} */ (event.data);
     this._executionContextCreated(executionContext);
     this._updateSelectionWarning();
   }
 
   /**
    * @param {!Common.Event} event
    */
   _onExecutionContextChanged(event) {
     var executionContext = /** @type {!SDK.ExecutionContext} */ (event.data);
-    var option = this._optionByExecutionContext.get(executionContext);
-    if (option)
-      option.text = this._titleFor(executionContext);
+    if (this._executionContexts.indexOf(executionContext) === -1)
+      return;
+    this._executionContextDestroyed(executionContext);
+    this._executionContextCreated(executionContext);
     this._updateSelectionWarning();
   }
 
   /**
    * @param {!SDK.ExecutionContext} executionContext
    */
   _executionContextDestroyed(executionContext) {
-    var option = this._optionByExecutionContext.remove(executionContext);
-    option.remove();
+    if (this._executionContexts.remove(executionContext, true))
+      this._list.removeItem(executionContext);
   }
 
   /**
    * @param {!Common.Event} event
    */
   _onExecutionContextDestroyed(event) {
     var executionContext = /** @type {!SDK.ExecutionContext} */ (event.data);
     this._executionContextDestroyed(executionContext);
     this._updateSelectionWarning();
   }
 
   /**
    * @param {!Common.Event} event
    */
   _executionContextChangedExternally(event) {
     var executionContext = /** @type {?SDK.ExecutionContext} */ (event.data);
-    if (!executionContext)
+    if (!executionContext || this._executionContexts.indexOf(executionContext) === -1)
       return;
-
-    var options = this._selectElement.options;
-    for (var i = 0; i < options.length; ++i) {
-      if (options[i].__executionContext === executionContext)
-        this._select(options[i]);
-    }
-  }
-
-  _executionContextChanged() {
-    var option = this._selectedOption();
-    var newContext = option ? option.__executionContext : null;
-    UI.context.setFlavor(SDK.ExecutionContext, newContext);
-    this._updateSelectionWarning();
+    this._list.selectItem(executionContext);
+    this._updateSelectedContext();
   }
 
   _updateSelectionWarning() {
     var executionContext = UI.context.flavor(SDK.ExecutionContext);
-    this._selectElement.parentElement.classList.toggle(
-        'warning', !this._isTopContext(executionContext) && this._hasTopContext());
+    this.element.classList.toggle('warning', !this._isTopContext(executionContext) && this._hasTopContext());
   }
 
   /**
    * @param {?SDK.ExecutionContext} executionContext
    * @return {boolean}
    */
   _isTopContext(executionContext) {
     if (!executionContext || !executionContext.isDefault)
       return false;
     var resourceTreeModel = executionContext.target().model(SDK.ResourceTreeModel);
     var frame = executionContext.frameId && resourceTreeModel && resourceTreeModel.frameForId(executionContext.frameId);
     if (!frame)
       return false;
     return frame.isMainFrame();
   }
 
   /**
    * @return {boolean}
    */
   _hasTopContext() {
-    var options = this._selectElement.options;
-    for (var i = 0; i < options.length; i++) {
-      if (this._isTopContext(options[i].__executionContext))
-        return true;
-    }
-    return false;
+    return !!this._executionContexts.find(executionContext => this._isTopContext(executionContext));
   }
 
   /**
    * @override
    * @param {!SDK.RuntimeModel} runtimeModel
    */
   modelAdded(runtimeModel) {
     runtimeModel.executionContexts().forEach(this._executionContextCreated, this);
   }
 
   /**
    * @override
    * @param {!SDK.RuntimeModel} runtimeModel
    */
   modelRemoved(runtimeModel) {
     var executionContexts = this._optionByExecutionContext.keysArray();
     for (var i = 0; i < executionContexts.length; ++i) {
       if (executionContexts[i].runtimeModel === runtimeModel)
         this._executionContextDestroyed(executionContexts[i]);
     }
   }
 
   /**
-   * @param {!Element} option
+   * @param {!SDK.ExecutionContext} executionContext
    */
-  _select(option) {
-    this._selectElement.selectedIndex = Array.prototype.indexOf.call(/** @type {?} */ (this._selectElement), option);
+  _onSelect(executionContext) {
+  }
+
+  /**
+   * @override
+   * @param {!SDK.ExecutionContext} item
+   * @return {!Element}
+   */
+  createElementForItem(item) {
+    var element = createElementWithClass('div', 'context');
+    element.style.paddingLeft = (8 + this._depthFor(item) * 15) + 'px';
+    element.createChild('div', 'title').textContent = this._titleFor(item);
+    element.createChild('div', 'subtitle').textContent = this._subtitleFor(item);
+    element.addEventListener('mousemove', e => {
+      if (e.movementX || e.movementY)
+        this._list.selectItem(item, false, /* Don't scroll */ true);
+    });
+    element.classList.toggle('disabled', !this.isItemSelectable(item));
+    return element;
+  }
+
+  /**
+   * @param {!SDK.ExecutionContext} executionContext
+   * @return {string}
+   */
+  _subtitleFor(executionContext) {
+    var target = executionContext.target();
+    if (executionContext.frameId) {
+      var resourceTreeModel = target.model(SDK.ResourceTreeModel);
+      var frame = resourceTreeModel && resourceTreeModel.frameForId(executionContext.frameId);
+    }
+    if (executionContext.origin.startsWith('chrome-extension://'))
+      return Common.UIString('Extension');
+    if (!frame || !frame.parentFrame || frame.parentFrame.securityOrigin !== executionContext.origin) {
+      var url = executionContext.origin.asParsedURL();
+      if (url) {
+        if (this._productRegistry) {
+          var product = this._productRegistry.nameForUrl(url);
+          if (product)
+            return product;
+        }
+        return url.domain();
+      }
+    }
+
+    if (frame) {
+      var stackTrace = frame.creationStackTrace();
+      while (stackTrace) {
+        for (var stack of stackTrace.callFrames) {
+          if (stack.url) {
+            var url = new Common.ParsedURL(stack.url);
+            if (this._productRegistry) {
+              var product = this._productRegistry.nameForUrl(url);
+              if (product)
+                return product;
+            }
+            return url.domain();
+          }
+        }
+        stackTrace = frame.parent;
+      }
+    }
+    return '';
+  }
+
+  /**
+   * @override
+   * @param {!SDK.ExecutionContext} item
+   * @return {number}
+   */
+  heightForItem(item) {
+    return 20;
+  }
+
+  /**
+   * @override
+   * @param {!SDK.ExecutionContext} item
+   * @return {boolean}
+   */
+  isItemSelectable(item) {
+    var callFrame = item.debuggerModel.selectedCallFrame();
+    var callFrameContext = callFrame && callFrame.script.executionContext();
+    return !callFrameContext || item === callFrameContext;
+  }
+
+  /**
+   * @override
+   * @param {?SDK.ExecutionContext} from
+   * @param {?SDK.ExecutionContext} to
+   * @param {?Element} fromElement
+   * @param {?Element} toElement
+   */
+  selectedItemChanged(from, to, fromElement, toElement) {
+    if (fromElement)
+      fromElement.classList.remove('selected');
+    if (toElement)
+      toElement.classList.add('selected');
+    SDK.OverlayModel.hideDOMNodeHighlight();
+    if (to && to.frameId) {
+      var resourceTreeModel = to.target().model(SDK.ResourceTreeModel);
+      if (resourceTreeModel)
+        resourceTreeModel.domModel().overlayModel().highlightFrame(to.frameId);
+    }
+  }
+
+  _updateSelectedContext() {
+    var context = this._list.selectedItem();
+    if (context)
+      this._titleElement.textContent = this._titleFor(context);
+    else
+      this._titleElement.textContent = '';
+    UI.context.setFlavor(SDK.ExecutionContext, context);
     this._updateSelectionWarning();
   }
 
-  /**
-   * @return {?Element}
-   */
-  _selectedOption() {
-    if (this._selectElement.selectedIndex >= 0)
-      return this._selectElement[this._selectElement.selectedIndex];
-    return null;
-  }
-
-  /**
-   * @param {!Common.Event} event
-   */
-  _callFrameSelectedInModel(event) {
-    var debuggerModel = /** @type {!SDK.DebuggerModel} */ (event.data);
-    var options = this._selectElement.options;
-    for (var i = 0; i < options.length; i++) {
-      if (options[i].__executionContext.debuggerModel === debuggerModel)
-        this._updateOptionDisabledState(options[i]);
-    }
-  }
-
-  /**
-   * @param {!Element} option
-   */
-  _updateOptionDisabledState(option) {
-    var executionContext = option.__executionContext;
-    var callFrame = executionContext.debuggerModel.selectedCallFrame();
-    var callFrameContext = callFrame && callFrame.script.executionContext();
-    option.disabled = callFrameContext && executionContext !== callFrameContext;
-  }
-
   _callFrameSelectedInUI() {
     var callFrame = UI.context.flavor(SDK.DebuggerModel.CallFrame);
     var callFrameContext = callFrame && callFrame.script.executionContext();
     if (callFrameContext)
       UI.context.setFlavor(SDK.ExecutionContext, callFrameContext);
   }
+
+  /**
+   * @param {!Common.Event} event
+   */
+  _callFrameSelectedInModel(event) {
+    var debuggerModel = /** @type {!SDK.DebuggerModel} */ (event.data);
+    for (var i = 0; i < this._executionContexts.length; i++) {
+      if (this._executionContexts[i].debuggerModel === debuggerModel)
+        this._list.refreshItemsInRange(i, i + 1);
+    }
+  }
+
+  /**
+   * @param {!Common.Event} event
+   */
+  _frameNavigated(event) {
+    var frameId = event.data.id;
+    for (var i = 0; i < this._executionContexts.length; i++) {
+      if (frameId === this._executionContexts[i].frameId)
+        this._list.refreshItemsInRange(i, i + 1);
+    }
+  }
 };