DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/components/HandlerRegistry.js

 /*
  * Copyright (C) 2011 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.HandlerRegistry = class extends WebInspector.Object {
+Components.HandlerRegistry = class extends Common.Object {
   constructor(setting) {
     super();
     this._handlers = {};
     this._setting = setting;
     this._activeHandler = this._setting.get();
   }
 
   get handlerNames() {
     return Object.getOwnPropertyNames(this._handlers);
   }
@@ skipping 21 matching lines @@
    * @return {boolean}
    */
   dispatchToHandler(name, data) {
     var handler = this._handlers[name];
     var result = handler && handler(data);
     return !!result;
   }
 
   registerHandler(name, handler) {
     this._handlers[name] = handler;
-    this.dispatchEventToListeners(WebInspector.HandlerRegistry.Events.HandlersUpdated);
+    this.dispatchEventToListeners(Components.HandlerRegistry.Events.HandlersUpdated);
   }
 
   unregisterHandler(name) {
     delete this._handlers[name];
-    this.dispatchEventToListeners(WebInspector.HandlerRegistry.Events.HandlersUpdated);
+    this.dispatchEventToListeners(Components.HandlerRegistry.Events.HandlersUpdated);
   }
 
   /**
    * @param {string} url
    */
   _openInNewTab(url) {
     InspectorFrontendHost.openInNewTab(url);
   }
 
   /**
-   * @param {!WebInspector.ContextMenu} contextMenu
+   * @param {!UI.ContextMenu} contextMenu
    * @param {!Object} target
    */
   _appendContentProviderItems(contextMenu, target) {
-    if (!(target instanceof WebInspector.UISourceCode || target instanceof WebInspector.Resource ||
-          target instanceof WebInspector.NetworkRequest))
+    if (!(target instanceof Workspace.UISourceCode || target instanceof SDK.Resource ||
+          target instanceof SDK.NetworkRequest))
       return;
-    var contentProvider = /** @type {!WebInspector.ContentProvider} */ (target);
+    var contentProvider = /** @type {!Common.ContentProvider} */ (target);
     if (!contentProvider.contentURL())
       return;
 
     contextMenu.appendItem(
-        WebInspector.openLinkExternallyLabel(), this._openInNewTab.bind(this, contentProvider.contentURL()));
+        UI.openLinkExternallyLabel(), this._openInNewTab.bind(this, contentProvider.contentURL()));
     // Skip 0th handler, as it's 'Use default panel' one.
     for (var i = 1; i < this.handlerNames.length; ++i) {
       var handler = this.handlerNames[i];
       contextMenu.appendItem(
-          WebInspector.UIString.capitalize('Open ^using %s', handler),
+          Common.UIString.capitalize('Open ^using %s', handler),
           this.dispatchToHandler.bind(this, handler, {url: contentProvider.contentURL()}));
     }
 
-    if (!contentProvider.contentURL() || contentProvider instanceof WebInspector.NetworkRequest)
+    if (!contentProvider.contentURL() || contentProvider instanceof SDK.NetworkRequest)
       return;
 
     contextMenu.appendItem(
-        WebInspector.copyLinkAddressLabel(),
+        UI.copyLinkAddressLabel(),
         InspectorFrontendHost.copyText.bind(InspectorFrontendHost, contentProvider.contentURL()));
 
     if (!contentProvider.contentType().isDocumentOrScriptOrStyleSheet())
       return;
 
     /**
      * @param {boolean} forceSaveAs
      * @param {?string} content
      */
     function doSave(forceSaveAs, content) {
       var url = contentProvider.contentURL();
-      WebInspector.fileManager.save(url, /** @type {string} */ (content), forceSaveAs);
-      WebInspector.fileManager.close(url);
+      Workspace.fileManager.save(url, /** @type {string} */ (content), forceSaveAs);
+      Workspace.fileManager.close(url);
     }
 
     /**
      * @param {boolean} forceSaveAs
      */
     function save(forceSaveAs) {
-      if (contentProvider instanceof WebInspector.UISourceCode) {
-        var uiSourceCode = /** @type {!WebInspector.UISourceCode} */ (contentProvider);
+      if (contentProvider instanceof Workspace.UISourceCode) {
+        var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (contentProvider);
         if (forceSaveAs)
           uiSourceCode.saveAs();
         else
           uiSourceCode.commitWorkingCopy();
         return;
       }
       contentProvider.requestContent().then(doSave.bind(null, forceSaveAs));
     }
 
     contextMenu.appendSeparator();
-    contextMenu.appendItem(WebInspector.UIString('Save'), save.bind(null, false));
+    contextMenu.appendItem(Common.UIString('Save'), save.bind(null, false));
 
-    if (contentProvider instanceof WebInspector.UISourceCode) {
-      var uiSourceCode = /** @type {!WebInspector.UISourceCode} */ (contentProvider);
-      if (uiSourceCode.project().type() !== WebInspector.projectTypes.FileSystem &&
-          uiSourceCode.project().type() !== WebInspector.projectTypes.Snippets)
-        contextMenu.appendItem(WebInspector.UIString.capitalize('Save ^as...'), save.bind(null, true));
+    if (contentProvider instanceof Workspace.UISourceCode) {
+      var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (contentProvider);
+      if (uiSourceCode.project().type() !== Workspace.projectTypes.FileSystem &&
+          uiSourceCode.project().type() !== Workspace.projectTypes.Snippets)
+        contextMenu.appendItem(Common.UIString.capitalize('Save ^as...'), save.bind(null, true));
     }
   }
 
   /**
-   * @param {!WebInspector.ContextMenu} contextMenu
+   * @param {!UI.ContextMenu} contextMenu
    * @param {!Object} target
    */
   _appendHrefItems(contextMenu, target) {
     if (!(target instanceof Node))
       return;
     var targetNode = /** @type {!Node} */ (target);
 
     var anchorElement = targetNode.enclosingNodeOrSelfWithClass('webkit-html-resource-link') ||
         targetNode.enclosingNodeOrSelfWithClass('webkit-html-external-link');
     if (!anchorElement)
       return;
 
-    var uiLocation = WebInspector.Linkifier.uiLocationByAnchor(anchorElement);
+    var uiLocation = Components.Linkifier.uiLocationByAnchor(anchorElement);
     var resourceURL = uiLocation ? uiLocation.uiSourceCode.contentURL() : anchorElement.href;
     var uiSourceCode = uiLocation ?
         uiLocation.uiSourceCode :
-        (resourceURL ? WebInspector.networkMapping.uiSourceCodeForURLForAnyTarget(resourceURL) : null);
+        (resourceURL ? Bindings.networkMapping.uiSourceCodeForURLForAnyTarget(resourceURL) : null);
     function open() {
-      WebInspector.Revealer.reveal(uiSourceCode);
+      Common.Revealer.reveal(uiSourceCode);
     }
     if (uiSourceCode)
       contextMenu.appendItem('Open', open);
 
     if (!resourceURL)
       return;
     // Add resource-related actions.
-    contextMenu.appendItem(WebInspector.openLinkExternallyLabel(), this._openInNewTab.bind(this, resourceURL));
+    contextMenu.appendItem(UI.openLinkExternallyLabel(), this._openInNewTab.bind(this, resourceURL));
 
     /**
      * @param {string} resourceURL
      */
     function openInResourcesPanel(resourceURL) {
-      var resource = WebInspector.resourceForURL(resourceURL);
+      var resource = Bindings.resourceForURL(resourceURL);
       if (resource)
-        WebInspector.Revealer.reveal(resource);
+        Common.Revealer.reveal(resource);
       else
         InspectorFrontendHost.openInNewTab(resourceURL);
     }
     if (!targetNode.enclosingNodeOrSelfWithClassList(['resources', 'panel']) &&
-        WebInspector.resourceForURL(resourceURL))
+        Bindings.resourceForURL(resourceURL))
       contextMenu.appendItem(
-          WebInspector.UIString.capitalize('Open ^link in Application ^panel'),
+          Common.UIString.capitalize('Open ^link in Application ^panel'),
           openInResourcesPanel.bind(null, resourceURL));
 
     contextMenu.appendItem(
-        WebInspector.copyLinkAddressLabel(), InspectorFrontendHost.copyText.bind(InspectorFrontendHost, resourceURL));
+        UI.copyLinkAddressLabel(), InspectorFrontendHost.copyText.bind(InspectorFrontendHost, resourceURL));
   }
 };
 
 /** @enum {symbol} */
-WebInspector.HandlerRegistry.Events = {
+Components.HandlerRegistry.Events = {
   HandlersUpdated: Symbol('HandlersUpdated')
 };
 
 /**
  * @unrestricted
  */
-WebInspector.HandlerSelector = class {
+Components.HandlerSelector = class {
   constructor(handlerRegistry) {
     this._handlerRegistry = handlerRegistry;
     this.element = createElementWithClass('select', 'chrome-select');
     this.element.addEventListener('change', this._onChange.bind(this), false);
     this._update();
     this._handlerRegistry.addEventListener(
-        WebInspector.HandlerRegistry.Events.HandlersUpdated, this._update.bind(this));
+        Components.HandlerRegistry.Events.HandlersUpdated, this._update.bind(this));
   }
 
   _update() {
     this.element.removeChildren();
     var names = this._handlerRegistry.handlerNames;
     var activeHandler = this._handlerRegistry.activeHandler;
 
     for (var i = 0; i < names.length; ++i) {
       var option = createElement('option');
       option.textContent = names[i];
       option.selected = activeHandler === names[i];
       this.element.appendChild(option);
     }
     this.element.disabled = names.length <= 1;
   }
 
   _onChange(event) {
     var value = event.target.value;
     this._handlerRegistry.activeHandler = value;
   }
 };
 
 /**
- * @implements {WebInspector.ContextMenu.Provider}
+ * @implements {UI.ContextMenu.Provider}
  * @unrestricted
  */
-WebInspector.HandlerRegistry.ContextMenuProvider = class {
+Components.HandlerRegistry.ContextMenuProvider = class {
   /**
    * @override
    * @param {!Event} event
-   * @param {!WebInspector.ContextMenu} contextMenu
+   * @param {!UI.ContextMenu} contextMenu
    * @param {!Object} target
    */
   appendApplicableItems(event, contextMenu, target) {
-    WebInspector.openAnchorLocationRegistry._appendContentProviderItems(contextMenu, target);
-    WebInspector.openAnchorLocationRegistry._appendHrefItems(contextMenu, target);
+    Components.openAnchorLocationRegistry._appendContentProviderItems(contextMenu, target);
+    Components.openAnchorLocationRegistry._appendHrefItems(contextMenu, target);
   }
 };
 
 /**
- * @implements {WebInspector.Linkifier.LinkHandler}
+ * @implements {Components.Linkifier.LinkHandler}
  * @unrestricted
  */
-WebInspector.HandlerRegistry.LinkHandler = class {
+Components.HandlerRegistry.LinkHandler = class {
   /**
    * @override
    * @param {string} url
    * @param {number=} lineNumber
    * @return {boolean}
    */
   handleLink(url, lineNumber) {
-    return WebInspector.openAnchorLocationRegistry.dispatch({url: url, lineNumber: lineNumber});
+    return Components.openAnchorLocationRegistry.dispatch({url: url, lineNumber: lineNumber});
   }
 };
 
 /**
- * @implements {WebInspector.SettingUI}
+ * @implements {UI.SettingUI}
  * @unrestricted
  */
-WebInspector.HandlerRegistry.OpenAnchorLocationSettingUI = class {
+Components.HandlerRegistry.OpenAnchorLocationSettingUI = class {
   /**
    * @override
    * @return {?Element}
    */
   settingElement() {
-    if (!WebInspector.openAnchorLocationRegistry.handlerNames.length)
+    if (!Components.openAnchorLocationRegistry.handlerNames.length)
       return null;
 
-    var handlerSelector = new WebInspector.HandlerSelector(WebInspector.openAnchorLocationRegistry);
-    return WebInspector.SettingsUI.createCustomSetting(
-        WebInspector.UIString('Link handling:'), handlerSelector.element);
+    var handlerSelector = new Components.HandlerSelector(Components.openAnchorLocationRegistry);
+    return UI.SettingsUI.createCustomSetting(
+        Common.UIString('Link handling:'), handlerSelector.element);
   }
 };
 
 /**
- * @type {!WebInspector.HandlerRegistry}
+ * @type {!Components.HandlerRegistry}
  */
-WebInspector.openAnchorLocationRegistry;
+Components.openAnchorLocationRegistry;