DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/ui/ContextMenu.js

 /*
  * Copyright (C) 2009 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
  */
-WebInspector.ContextMenuItem = class {
+UI.ContextMenuItem = class {
   /**
-   * @param {?WebInspector.ContextMenu} topLevelMenu
+   * @param {?UI.ContextMenu} topLevelMenu
    * @param {string} type
    * @param {string=} label
    * @param {boolean=} disabled
    * @param {boolean=} checked
    */
   constructor(topLevelMenu, type, label, disabled, checked) {
     this._type = type;
     this._label = label;
     this._disabled = disabled;
     this._checked = checked;
@@ skipping 54 matching lines @@
    * @param {string} shortcut
    */
   setShortcut(shortcut) {
     this._shortcut = shortcut;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ContextSubMenuItem = class extends WebInspector.ContextMenuItem {
+UI.ContextSubMenuItem = class extends UI.ContextMenuItem {
   /**
-   * @param {?WebInspector.ContextMenu} topLevelMenu
+   * @param {?UI.ContextMenu} topLevelMenu
    * @param {string=} label
    * @param {boolean=} disabled
    */
   constructor(topLevelMenu, label, disabled) {
     super(topLevelMenu, 'subMenu', label, disabled);
-    /** @type {!Array.<!WebInspector.ContextMenuItem>} */
+    /** @type {!Array.<!UI.ContextMenuItem>} */
     this._items = [];
   }
 
   /**
    * @param {string} label
    * @param {function(?)} handler
    * @param {boolean=} disabled
-   * @return {!WebInspector.ContextMenuItem}
+   * @return {!UI.ContextMenuItem}
    */
   appendItem(label, handler, disabled) {
-    var item = new WebInspector.ContextMenuItem(this._contextMenu, 'item', label, disabled);
+    var item = new UI.ContextMenuItem(this._contextMenu, 'item', label, disabled);
     this._pushItem(item);
     this._contextMenu._setHandler(item.id(), handler);
     return item;
   }
 
   /**
    * @param {!Element} element
-   * @return {!WebInspector.ContextMenuItem}
+   * @return {!UI.ContextMenuItem}
    */
   appendCustomItem(element) {
-    var item = new WebInspector.ContextMenuItem(this._contextMenu, 'item', '<custom>');
+    var item = new UI.ContextMenuItem(this._contextMenu, 'item', '<custom>');
     item._customElement = element;
     this._pushItem(item);
     return item;
   }
 
   /**
    * @param {string} actionId
    * @param {string=} label
-   * @return {!WebInspector.ContextMenuItem}
+   * @return {!UI.ContextMenuItem}
    */
   appendAction(actionId, label) {
-    var action = WebInspector.actionRegistry.action(actionId);
+    var action = UI.actionRegistry.action(actionId);
     if (!label)
       label = action.title();
     var result = this.appendItem(label, action.execute.bind(action));
-    var shortcut = WebInspector.shortcutRegistry.shortcutTitleForAction(actionId);
+    var shortcut = UI.shortcutRegistry.shortcutTitleForAction(actionId);
     if (shortcut)
       result.setShortcut(shortcut);
     return result;
   }
 
   /**
    * @param {string} label
    * @param {boolean=} disabled
    * @param {string=} subMenuId
-   * @return {!WebInspector.ContextSubMenuItem}
+   * @return {!UI.ContextSubMenuItem}
    */
   appendSubMenuItem(label, disabled, subMenuId) {
-    var item = new WebInspector.ContextSubMenuItem(this._contextMenu, label, disabled);
+    var item = new UI.ContextSubMenuItem(this._contextMenu, label, disabled);
     if (subMenuId)
       this._contextMenu._namedSubMenus.set(subMenuId, item);
     this._pushItem(item);
     return item;
   }
 
   /**
    * @param {string} label
    * @param {function()} handler
    * @param {boolean=} checked
    * @param {boolean=} disabled
-   * @return {!WebInspector.ContextMenuItem}
+   * @return {!UI.ContextMenuItem}
    */
   appendCheckboxItem(label, handler, checked, disabled) {
-    var item = new WebInspector.ContextMenuItem(this._contextMenu, 'checkbox', label, disabled, checked);
+    var item = new UI.ContextMenuItem(this._contextMenu, 'checkbox', label, disabled, checked);
     this._pushItem(item);
     this._contextMenu._setHandler(item.id(), handler);
     return item;
   }
 
   appendSeparator() {
     if (this._items.length)
       this._pendingSeparator = true;
   }
 
   /**
-   * @param {!WebInspector.ContextMenuItem} item
+   * @param {!UI.ContextMenuItem} item
    */
   _pushItem(item) {
     if (this._pendingSeparator) {
-      this._items.push(new WebInspector.ContextMenuItem(this._contextMenu, 'separator'));
+      this._items.push(new UI.ContextMenuItem(this._contextMenu, 'separator'));
       delete this._pendingSeparator;
     }
     this._items.push(item);
   }
 
   /**
    * @return {boolean}
    */
   isEmpty() {
     return !this._items.length;
   }
 
   /**
    * @override
    * @return {!InspectorFrontendHostAPI.ContextMenuDescriptor}
    */
   _buildDescriptor() {
     var result = {type: 'subMenu', label: this._label, enabled: !this._disabled, subItems: []};
     for (var i = 0; i < this._items.length; ++i)
       result.subItems.push(this._items[i]._buildDescriptor());
     return result;
   }
 
   /**
    * @param {string} location
    */
   appendItemsAtLocation(location) {
     /**
-     * @param {!WebInspector.ContextSubMenuItem} menu
+     * @param {!UI.ContextSubMenuItem} menu
      * @param {!Runtime.Extension} extension
      */
     function appendExtension(menu, extension) {
       var subMenuId = extension.descriptor()['subMenuId'];
       if (subMenuId) {
         var subMenuItem = menu.appendSubMenuItem(extension.title(), false, subMenuId);
         subMenuItem.appendItemsAtLocation(subMenuId);
       } else {
         menu.appendAction(extension.descriptor()['actionId']);
       }
@@ skipping 28 matching lines @@
         continue;
       group.forEach(appendExtension.bind(null, this));
       this.appendSeparator();
     }
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ContextMenu = class extends WebInspector.ContextSubMenuItem {
+UI.ContextMenu = class extends UI.ContextSubMenuItem {
   /**
    * @param {!Event} event
    * @param {boolean=} useSoftMenu
    * @param {number=} x
    * @param {number=} y
    */
   constructor(event, useSoftMenu, x, y) {
     super(null, '');
     this._contextMenu = this;
-    /** @type {!Array.<!Promise.<!Array.<!WebInspector.ContextMenu.Provider>>>} */
+    /** @type {!Array.<!Promise.<!Array.<!UI.ContextMenu.Provider>>>} */
     this._pendingPromises = [];
     /** @type {!Array<!Object>} */
     this._pendingTargets = [];
     this._event = event;
     this._useSoftMenu = !!useSoftMenu;
     this._x = x === undefined ? event.x : x;
     this._y = y === undefined ? event.y : y;
     this._handlers = {};
     this._id = 0;
-    /** @type {!Map<string, !WebInspector.ContextSubMenuItem>} */
+    /** @type {!Map<string, !UI.ContextSubMenuItem>} */
     this._namedSubMenus = new Map();
   }
 
   static initialize() {
     InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.SetUseSoftMenu, setUseSoftMenu);
     /**
-     * @param {!WebInspector.Event} event
+     * @param {!Common.Event} event
      */
     function setUseSoftMenu(event) {
-      WebInspector.ContextMenu._useSoftMenu = /** @type {boolean} */ (event.data);
+      UI.ContextMenu._useSoftMenu = /** @type {boolean} */ (event.data);
     }
   }
 
   /**
    * @param {!Document} doc
    */
   static installHandler(doc) {
     doc.body.addEventListener('contextmenu', handler, false);
 
     /**
      * @param {!Event} event
      */
     function handler(event) {
-      var contextMenu = new WebInspector.ContextMenu(event);
+      var contextMenu = new UI.ContextMenu(event);
       contextMenu.appendApplicableItems(/** @type {!Object} */ (event.deepElementFromPoint()));
       contextMenu.show();
     }
   }
 
   /**
    * @return {number}
    */
   _nextId() {
     return this._id++;
   }
 
   /**
    * @param {function()} callback
    */
   beforeShow(callback) {
     this._beforeShow = callback;
   }
 
   show() {
     Promise.all(this._pendingPromises).then(populate.bind(this)).then(this._innerShow.bind(this));
-    WebInspector.ContextMenu._pendingMenu = this;
+    UI.ContextMenu._pendingMenu = this;
 
     /**
-     * @param {!Array.<!Array.<!WebInspector.ContextMenu.Provider>>} appendCallResults
-     * @this {WebInspector.ContextMenu}
+     * @param {!Array.<!Array.<!UI.ContextMenu.Provider>>} appendCallResults
+     * @this {UI.ContextMenu}
      */
     function populate(appendCallResults) {
-      if (WebInspector.ContextMenu._pendingMenu !== this)
+      if (UI.ContextMenu._pendingMenu !== this)
         return;
-      delete WebInspector.ContextMenu._pendingMenu;
+      delete UI.ContextMenu._pendingMenu;
 
       for (var i = 0; i < appendCallResults.length; ++i) {
         var providers = appendCallResults[i];
         var target = this._pendingTargets[i];
 
         for (var j = 0; j < providers.length; ++j) {
-          var provider = /** @type {!WebInspector.ContextMenu.Provider} */ (providers[j]);
+          var provider = /** @type {!UI.ContextMenu.Provider} */ (providers[j]);
           this.appendSeparator();
           provider.appendApplicableItems(this._event, this, target);
           this.appendSeparator();
         }
       }
 
       this._pendingPromises = [];
       this._pendingTargets = [];
     }
 
     this._event.consume(true);
   }
 
   discard() {
     if (this._softMenu)
       this._softMenu.discard();
   }
 
   _innerShow() {
     if (typeof this._beforeShow === 'function') {
       this._beforeShow();
       delete this._beforeShow;
     }
 
     var menuObject = this._buildDescriptors();
 
-    WebInspector._contextMenu = this;
-    if (this._useSoftMenu || WebInspector.ContextMenu._useSoftMenu || InspectorFrontendHost.isHostedMode()) {
-      this._softMenu = new WebInspector.SoftContextMenu(menuObject, this._itemSelected.bind(this));
+    UI._contextMenu = this;
+    if (this._useSoftMenu || UI.ContextMenu._useSoftMenu || InspectorFrontendHost.isHostedMode()) {
+      this._softMenu = new UI.SoftContextMenu(menuObject, this._itemSelected.bind(this));
       this._softMenu.show(this._event.target.ownerDocument, this._x, this._y);
     } else {
       InspectorFrontendHost.showContextMenuAtPoint(this._x, this._y, menuObject, this._event.target.ownerDocument);
 
       /**
-       * @this {WebInspector.ContextMenu}
+       * @this {UI.ContextMenu}
        */
       function listenToEvents() {
         InspectorFrontendHost.events.addEventListener(
             InspectorFrontendHostAPI.Events.ContextMenuCleared, this._menuCleared, this);
         InspectorFrontendHost.events.addEventListener(
             InspectorFrontendHostAPI.Events.ContextMenuItemSelected, this._onItemSelected, this);
       }
 
       // showContextMenuAtPoint call above synchronously issues a clear event for previous context menu (if any),
       // so we skip it before subscribing to the clear event.
@@ skipping 14 matching lines @@
    * @return {!Array.<!InspectorFrontendHostAPI.ContextMenuDescriptor>}
    */
   _buildDescriptors() {
     var result = [];
     for (var i = 0; i < this._items.length; ++i)
       result.push(this._items[i]._buildDescriptor());
     return result;
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _onItemSelected(event) {
     this._itemSelected(/** @type {string} */ (event.data));
   }
 
   /**
    * @param {string} id
    */
   _itemSelected(id) {
     if (this._handlers[id])
       this._handlers[id].call(this);
     this._menuCleared();
   }
 
   _menuCleared() {
     InspectorFrontendHost.events.removeEventListener(
         InspectorFrontendHostAPI.Events.ContextMenuCleared, this._menuCleared, this);
     InspectorFrontendHost.events.removeEventListener(
         InspectorFrontendHostAPI.Events.ContextMenuItemSelected, this._onItemSelected, this);
   }
 
   /**
    * @param {!Object} target
    */
   appendApplicableItems(target) {
-    this._pendingPromises.push(self.runtime.allInstances(WebInspector.ContextMenu.Provider, target));
+    this._pendingPromises.push(self.runtime.allInstances(UI.ContextMenu.Provider, target));
     this._pendingTargets.push(target);
   }
 
   /**
    * @param {string} name
-   * @return {?WebInspector.ContextSubMenuItem}
+   * @return {?UI.ContextSubMenuItem}
    */
   namedSubMenu(name) {
     return this._namedSubMenus.get(name) || null;
   }
 };
 
 
 /**
  * @interface
  */
-WebInspector.ContextMenu.Provider = function() {};
+UI.ContextMenu.Provider = function() {};
 
-WebInspector.ContextMenu.Provider.prototype = {
+UI.ContextMenu.Provider.prototype = {
   /**
    * @param {!Event} event
-   * @param {!WebInspector.ContextMenu} contextMenu
+   * @param {!UI.ContextMenu} contextMenu
    * @param {!Object} target
    */
   appendApplicableItems: function(event, contextMenu, target) {}
 };