DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/sources/SourcesView.js

 // Copyright 2014 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 {WebInspector.TabbedEditorContainerDelegate}
- * @implements {WebInspector.Searchable}
- * @implements {WebInspector.Replaceable}
+ * @implements {Sources.TabbedEditorContainerDelegate}
+ * @implements {UI.Searchable}
+ * @implements {UI.Replaceable}
  * @unrestricted
  */
-WebInspector.SourcesView = class extends WebInspector.VBox {
+Sources.SourcesView = class extends UI.VBox {
   /**
    * @suppressGlobalPropertiesCheck
    */
   constructor() {
     super();
     this.registerRequiredCSS('sources/sourcesView.css');
     this.element.id = 'sources-panel-sources-view';
     this.setMinimumAndPreferredSizes(50, 52, 150, 100);
 
-    var workspace = WebInspector.workspace;
+    var workspace = Workspace.workspace;
 
-    this._searchableView = new WebInspector.SearchableView(this, 'sourcesViewSearchConfig');
+    this._searchableView = new UI.SearchableView(this, 'sourcesViewSearchConfig');
     this._searchableView.setMinimalSearchQuerySize(0);
     this._searchableView.show(this.element);
 
-    /** @type {!Map.<!WebInspector.UISourceCode, !WebInspector.Widget>} */
+    /** @type {!Map.<!Workspace.UISourceCode, !UI.Widget>} */
     this._sourceViewByUISourceCode = new Map();
 
-    var tabbedEditorPlaceholderText = WebInspector.isMac() ? WebInspector.UIString('Hit \u2318+P to open a file') :
-                                                             WebInspector.UIString('Hit Ctrl+P to open a file');
-    this._editorContainer = new WebInspector.TabbedEditorContainer(
-        this, WebInspector.settings.createLocalSetting('previouslyViewedFiles', []), tabbedEditorPlaceholderText);
+    var tabbedEditorPlaceholderText = Host.isMac() ? Common.UIString('Hit \u2318+P to open a file') :
+                                                             Common.UIString('Hit Ctrl+P to open a file');
+    this._editorContainer = new Sources.TabbedEditorContainer(
+        this, Common.settings.createLocalSetting('previouslyViewedFiles', []), tabbedEditorPlaceholderText);
     this._editorContainer.show(this._searchableView.element);
     this._editorContainer.addEventListener(
-        WebInspector.TabbedEditorContainer.Events.EditorSelected, this._editorSelected, this);
+        Sources.TabbedEditorContainer.Events.EditorSelected, this._editorSelected, this);
     this._editorContainer.addEventListener(
-        WebInspector.TabbedEditorContainer.Events.EditorClosed, this._editorClosed, this);
+        Sources.TabbedEditorContainer.Events.EditorClosed, this._editorClosed, this);
 
-    this._historyManager = new WebInspector.EditingLocationHistoryManager(this, this.currentSourceFrame.bind(this));
+    this._historyManager = new Sources.EditingLocationHistoryManager(this, this.currentSourceFrame.bind(this));
 
     this._toolbarContainerElement = this.element.createChild('div', 'sources-toolbar');
-    this._toolbarEditorActions = new WebInspector.Toolbar('', this._toolbarContainerElement);
+    this._toolbarEditorActions = new UI.Toolbar('', this._toolbarContainerElement);
 
-    self.runtime.allInstances(WebInspector.SourcesView.EditorAction).then(appendButtonsForExtensions.bind(this));
+    self.runtime.allInstances(Sources.SourcesView.EditorAction).then(appendButtonsForExtensions.bind(this));
     /**
-     * @param {!Array.<!WebInspector.SourcesView.EditorAction>} actions
-     * @this {WebInspector.SourcesView}
+     * @param {!Array.<!Sources.SourcesView.EditorAction>} actions
+     * @this {Sources.SourcesView}
      */
     function appendButtonsForExtensions(actions) {
       for (var i = 0; i < actions.length; ++i)
         this._toolbarEditorActions.appendToolbarItem(actions[i].button(this));
     }
-    this._scriptViewToolbar = new WebInspector.Toolbar('', this._toolbarContainerElement);
+    this._scriptViewToolbar = new UI.Toolbar('', this._toolbarContainerElement);
     this._scriptViewToolbar.element.style.flex = 'auto';
-    this._bottomToolbar = new WebInspector.Toolbar('', this._toolbarContainerElement);
+    this._bottomToolbar = new UI.Toolbar('', this._toolbarContainerElement);
 
-    WebInspector.startBatchUpdate();
+    UI.startBatchUpdate();
     workspace.uiSourceCodes().forEach(this._addUISourceCode.bind(this));
-    WebInspector.endBatchUpdate();
+    UI.endBatchUpdate();
 
-    workspace.addEventListener(WebInspector.Workspace.Events.UISourceCodeAdded, this._uiSourceCodeAdded, this);
-    workspace.addEventListener(WebInspector.Workspace.Events.UISourceCodeRemoved, this._uiSourceCodeRemoved, this);
-    workspace.addEventListener(WebInspector.Workspace.Events.ProjectRemoved, this._projectRemoved.bind(this), this);
+    workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeAdded, this._uiSourceCodeAdded, this);
+    workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeRemoved, this._uiSourceCodeRemoved, this);
+    workspace.addEventListener(Workspace.Workspace.Events.ProjectRemoved, this._projectRemoved.bind(this), this);
 
     /**
      * @param {!Event} event
      */
     function handleBeforeUnload(event) {
       if (event.returnValue)
         return;
 
       var unsavedSourceCodes = [];
-      var projects = WebInspector.workspace.projectsForType(WebInspector.projectTypes.FileSystem);
+      var projects = Workspace.workspace.projectsForType(Workspace.projectTypes.FileSystem);
       for (var i = 0; i < projects.length; ++i)
         unsavedSourceCodes = unsavedSourceCodes.concat(projects[i].uiSourceCodes().filter(isUnsaved));
 
       if (!unsavedSourceCodes.length)
         return;
 
-      event.returnValue = WebInspector.UIString('DevTools have unsaved changes that will be permanently lost.');
-      WebInspector.viewManager.showView('sources');
+      event.returnValue = Common.UIString('DevTools have unsaved changes that will be permanently lost.');
+      UI.viewManager.showView('sources');
       for (var i = 0; i < unsavedSourceCodes.length; ++i)
-        WebInspector.Revealer.reveal(unsavedSourceCodes[i]);
+        Common.Revealer.reveal(unsavedSourceCodes[i]);
 
       /**
-       * @param {!WebInspector.UISourceCode} sourceCode
+       * @param {!Workspace.UISourceCode} sourceCode
        * @return {boolean}
        */
       function isUnsaved(sourceCode) {
-        var binding = WebInspector.persistence.binding(sourceCode);
+        var binding = Persistence.persistence.binding(sourceCode);
         if (binding)
           return binding.network.isDirty();
         return sourceCode.isDirty();
       }
     }
 
     if (!window.opener)
       window.addEventListener('beforeunload', handleBeforeUnload, true);
 
     this._shortcuts = {};
     this.element.addEventListener('keydown', this._handleKeyDown.bind(this), false);
   }
 
   /**
-   * @param {function(!Array.<!WebInspector.KeyboardShortcut.Descriptor>, function(!Event=):boolean)} registerShortcutDelegate
+   * @param {function(!Array.<!UI.KeyboardShortcut.Descriptor>, function(!Event=):boolean)} registerShortcutDelegate
    */
   registerShortcuts(registerShortcutDelegate) {
     /**
-     * @this {WebInspector.SourcesView}
-     * @param {!Array.<!WebInspector.KeyboardShortcut.Descriptor>} shortcuts
+     * @this {Sources.SourcesView}
+     * @param {!Array.<!UI.KeyboardShortcut.Descriptor>} shortcuts
      * @param {function(!Event=):boolean} handler
      */
     function registerShortcut(shortcuts, handler) {
       registerShortcutDelegate(shortcuts, handler);
       this._registerShortcuts(shortcuts, handler);
     }
 
     registerShortcut.call(
-        this, WebInspector.ShortcutsScreen.SourcesPanelShortcuts.JumpToPreviousLocation,
+        this, Components.ShortcutsScreen.SourcesPanelShortcuts.JumpToPreviousLocation,
         this._onJumpToPreviousLocation.bind(this));
     registerShortcut.call(
-        this, WebInspector.ShortcutsScreen.SourcesPanelShortcuts.JumpToNextLocation,
+        this, Components.ShortcutsScreen.SourcesPanelShortcuts.JumpToNextLocation,
         this._onJumpToNextLocation.bind(this));
     registerShortcut.call(
-        this, WebInspector.ShortcutsScreen.SourcesPanelShortcuts.CloseEditorTab, this._onCloseEditorTab.bind(this));
+        this, Components.ShortcutsScreen.SourcesPanelShortcuts.CloseEditorTab, this._onCloseEditorTab.bind(this));
     registerShortcut.call(
-        this, WebInspector.ShortcutsScreen.SourcesPanelShortcuts.GoToLine, this._showGoToLineDialog.bind(this));
+        this, Components.ShortcutsScreen.SourcesPanelShortcuts.GoToLine, this._showGoToLineDialog.bind(this));
     registerShortcut.call(
-        this, WebInspector.ShortcutsScreen.SourcesPanelShortcuts.GoToMember, this._showOutlineDialog.bind(this));
+        this, Components.ShortcutsScreen.SourcesPanelShortcuts.GoToMember, this._showOutlineDialog.bind(this));
     registerShortcut.call(
-        this, WebInspector.ShortcutsScreen.SourcesPanelShortcuts.ToggleBreakpoint, this._toggleBreakpoint.bind(this));
-    registerShortcut.call(this, WebInspector.ShortcutsScreen.SourcesPanelShortcuts.Save, this._save.bind(this));
-    registerShortcut.call(this, WebInspector.ShortcutsScreen.SourcesPanelShortcuts.SaveAll, this._saveAll.bind(this));
+        this, Components.ShortcutsScreen.SourcesPanelShortcuts.ToggleBreakpoint, this._toggleBreakpoint.bind(this));
+    registerShortcut.call(this, Components.ShortcutsScreen.SourcesPanelShortcuts.Save, this._save.bind(this));
+    registerShortcut.call(this, Components.ShortcutsScreen.SourcesPanelShortcuts.SaveAll, this._saveAll.bind(this));
   }
 
   /**
-   * @return {!WebInspector.Toolbar}
+   * @return {!UI.Toolbar}
    */
   leftToolbar() {
     return this._editorContainer.leftToolbar();
   }
 
   /**
-   * @return {!WebInspector.Toolbar}
+   * @return {!UI.Toolbar}
    */
   rightToolbar() {
     return this._editorContainer.rightToolbar();
   }
 
   /**
-   * @return {!WebInspector.Toolbar}
+   * @return {!UI.Toolbar}
    */
   bottomToolbar() {
     return this._bottomToolbar;
   }
 
   /**
-   * @param {!Array.<!WebInspector.KeyboardShortcut.Descriptor>} keys
+   * @param {!Array.<!UI.KeyboardShortcut.Descriptor>} keys
    * @param {function(!Event=):boolean} handler
    */
   _registerShortcuts(keys, handler) {
     for (var i = 0; i < keys.length; ++i)
       this._shortcuts[keys[i].key] = handler;
   }
 
   _handleKeyDown(event) {
-    var shortcutKey = WebInspector.KeyboardShortcut.makeKeyFromEvent(event);
+    var shortcutKey = UI.KeyboardShortcut.makeKeyFromEvent(event);
     var handler = this._shortcuts[shortcutKey];
     if (handler && handler())
       event.consume(true);
   }
 
   /**
    * @override
    */
   wasShown() {
     super.wasShown();
-    WebInspector.context.setFlavor(WebInspector.SourcesView, this);
+    UI.context.setFlavor(Sources.SourcesView, this);
   }
 
   /**
    * @override
    */
   willHide() {
-    WebInspector.context.setFlavor(WebInspector.SourcesView, null);
+    UI.context.setFlavor(Sources.SourcesView, null);
     super.willHide();
   }
 
   /**
    * @return {!Element}
    */
   toolbarContainerElement() {
     return this._toolbarContainerElement;
   }
 
   /**
-   * @return {!WebInspector.SearchableView}
+   * @return {!UI.SearchableView}
    */
   searchableView() {
     return this._searchableView;
   }
 
   /**
-   * @return {?WebInspector.Widget}
+   * @return {?UI.Widget}
    */
   visibleView() {
     return this._editorContainer.visibleView;
   }
 
   /**
-   * @return {?WebInspector.UISourceCodeFrame}
+   * @return {?Sources.UISourceCodeFrame}
    */
   currentSourceFrame() {
     var view = this.visibleView();
-    if (!(view instanceof WebInspector.UISourceCodeFrame))
+    if (!(view instanceof Sources.UISourceCodeFrame))
       return null;
-    return /** @type {!WebInspector.UISourceCodeFrame} */ (view);
+    return /** @type {!Sources.UISourceCodeFrame} */ (view);
   }
 
   /**
-   * @return {?WebInspector.UISourceCode}
+   * @return {?Workspace.UISourceCode}
    */
   currentUISourceCode() {
     return this._editorContainer.currentFile();
   }
 
   /**
    * @param {!Event=} event
    */
   _onCloseEditorTab(event) {
     var uiSourceCode = this._editorContainer.currentFile();
@@ skipping 13 matching lines @@
 
   /**
    * @param {!Event=} event
    */
   _onJumpToNextLocation(event) {
     this._historyManager.rollover();
     return true;
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _uiSourceCodeAdded(event) {
-    var uiSourceCode = /** @type {!WebInspector.UISourceCode} */ (event.data);
+    var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (event.data);
     this._addUISourceCode(uiSourceCode);
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    */
   _addUISourceCode(uiSourceCode) {
     if (uiSourceCode.isFromServiceProject())
       return;
     this._editorContainer.addUISourceCode(uiSourceCode);
   }
 
   _uiSourceCodeRemoved(event) {
-    var uiSourceCode = /** @type {!WebInspector.UISourceCode} */ (event.data);
+    var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (event.data);
     this._removeUISourceCodes([uiSourceCode]);
   }
 
   /**
-   * @param {!Array.<!WebInspector.UISourceCode>} uiSourceCodes
+   * @param {!Array.<!Workspace.UISourceCode>} uiSourceCodes
    */
   _removeUISourceCodes(uiSourceCodes) {
     this._editorContainer.removeUISourceCodes(uiSourceCodes);
     for (var i = 0; i < uiSourceCodes.length; ++i) {
       this._removeSourceFrame(uiSourceCodes[i]);
       this._historyManager.removeHistoryForSourceCode(uiSourceCodes[i]);
     }
   }
 
   _projectRemoved(event) {
     var project = event.data;
     var uiSourceCodes = project.uiSourceCodes();
     this._removeUISourceCodes(uiSourceCodes);
   }
 
   _updateScriptViewToolbarItems() {
     this._scriptViewToolbar.removeToolbarItems();
     var view = this.visibleView();
-    if (view instanceof WebInspector.SimpleView) {
-      for (var item of (/** @type {?WebInspector.SimpleView} */ (view)).syncToolbarItems())
+    if (view instanceof UI.SimpleView) {
+      for (var item of (/** @type {?UI.SimpleView} */ (view)).syncToolbarItems())
         this._scriptViewToolbar.appendToolbarItem(item);
     }
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {number=} lineNumber 0-based
    * @param {number=} columnNumber
    * @param {boolean=} omitFocus
    * @param {boolean=} omitHighlight
    */
   showSourceLocation(uiSourceCode, lineNumber, columnNumber, omitFocus, omitHighlight) {
     this._historyManager.updateCurrentState();
     this._editorContainer.showFile(uiSourceCode);
     var currentSourceFrame = this.currentSourceFrame();
     if (currentSourceFrame && typeof lineNumber === 'number')
       currentSourceFrame.revealPosition(lineNumber, columnNumber, !omitHighlight);
     this._historyManager.pushNewState();
     if (!omitFocus)
       this.visibleView().focus();
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
-   * @return {!WebInspector.Widget}
+   * @param {!Workspace.UISourceCode} uiSourceCode
+   * @return {!UI.Widget}
    */
   _createSourceView(uiSourceCode) {
     var sourceFrame;
     var sourceView;
     var contentType = uiSourceCode.contentType();
 
     if (contentType.hasScripts())
-      sourceFrame = new WebInspector.JavaScriptSourceFrame(uiSourceCode);
+      sourceFrame = new Sources.JavaScriptSourceFrame(uiSourceCode);
     else if (contentType.isStyleSheet())
-      sourceFrame = new WebInspector.CSSSourceFrame(uiSourceCode);
-    else if (contentType === WebInspector.resourceTypes.Image)
+      sourceFrame = new Sources.CSSSourceFrame(uiSourceCode);
+    else if (contentType === Common.resourceTypes.Image)
       sourceView =
-          new WebInspector.ImageView(WebInspector.NetworkProject.uiSourceCodeMimeType(uiSourceCode), uiSourceCode);
-    else if (contentType === WebInspector.resourceTypes.Font)
+          new SourceFrame.ImageView(Bindings.NetworkProject.uiSourceCodeMimeType(uiSourceCode), uiSourceCode);
+    else if (contentType === Common.resourceTypes.Font)
       sourceView =
-          new WebInspector.FontView(WebInspector.NetworkProject.uiSourceCodeMimeType(uiSourceCode), uiSourceCode);
+          new SourceFrame.FontView(Bindings.NetworkProject.uiSourceCodeMimeType(uiSourceCode), uiSourceCode);
     else
-      sourceFrame = new WebInspector.UISourceCodeFrame(uiSourceCode);
+      sourceFrame = new Sources.UISourceCodeFrame(uiSourceCode);
 
     if (sourceFrame) {
-      sourceFrame.setHighlighterType(WebInspector.NetworkProject.uiSourceCodeMimeType(uiSourceCode));
+      sourceFrame.setHighlighterType(Bindings.NetworkProject.uiSourceCodeMimeType(uiSourceCode));
       this._historyManager.trackSourceFrameCursorJumps(sourceFrame);
     }
-    var widget = /** @type {!WebInspector.Widget} */ (sourceFrame || sourceView);
+    var widget = /** @type {!UI.Widget} */ (sourceFrame || sourceView);
     this._sourceViewByUISourceCode.set(uiSourceCode, widget);
-    uiSourceCode.addEventListener(WebInspector.UISourceCode.Events.TitleChanged, this._uiSourceCodeTitleChanged, this);
+    uiSourceCode.addEventListener(Workspace.UISourceCode.Events.TitleChanged, this._uiSourceCodeTitleChanged, this);
     return widget;
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
-   * @return {!WebInspector.Widget}
+   * @param {!Workspace.UISourceCode} uiSourceCode
+   * @return {!UI.Widget}
    */
   _getOrCreateSourceView(uiSourceCode) {
     return this._sourceViewByUISourceCode.get(uiSourceCode) || this._createSourceView(uiSourceCode);
   }
 
   /**
-   * @param {!WebInspector.UISourceCodeFrame} sourceFrame
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Sources.UISourceCodeFrame} sourceFrame
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @return {boolean}
    */
   _sourceFrameMatchesUISourceCode(sourceFrame, uiSourceCode) {
     if (uiSourceCode.contentType().hasScripts())
-      return sourceFrame instanceof WebInspector.JavaScriptSourceFrame;
+      return sourceFrame instanceof Sources.JavaScriptSourceFrame;
     if (uiSourceCode.contentType().isStyleSheet())
-      return sourceFrame instanceof WebInspector.CSSSourceFrame;
-    return !(sourceFrame instanceof WebInspector.JavaScriptSourceFrame);
+      return sourceFrame instanceof Sources.CSSSourceFrame;
+    return !(sourceFrame instanceof Sources.JavaScriptSourceFrame);
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    */
   _recreateSourceFrameIfNeeded(uiSourceCode) {
     var oldSourceView = this._sourceViewByUISourceCode.get(uiSourceCode);
-    if (!oldSourceView || !(oldSourceView instanceof WebInspector.UISourceCodeFrame))
+    if (!oldSourceView || !(oldSourceView instanceof Sources.UISourceCodeFrame))
       return;
-    var oldSourceFrame = /** @type {!WebInspector.UISourceCodeFrame} */ (oldSourceView);
+    var oldSourceFrame = /** @type {!Sources.UISourceCodeFrame} */ (oldSourceView);
     if (this._sourceFrameMatchesUISourceCode(oldSourceFrame, uiSourceCode)) {
-      oldSourceFrame.setHighlighterType(WebInspector.NetworkProject.uiSourceCodeMimeType(uiSourceCode));
+      oldSourceFrame.setHighlighterType(Bindings.NetworkProject.uiSourceCodeMimeType(uiSourceCode));
     } else {
       this._editorContainer.removeUISourceCode(uiSourceCode);
       this._removeSourceFrame(uiSourceCode);
     }
   }
 
   /**
    * @override
-   * @param {!WebInspector.UISourceCode} uiSourceCode
-   * @return {!WebInspector.Widget}
+   * @param {!Workspace.UISourceCode} uiSourceCode
+   * @return {!UI.Widget}
    */
   viewForFile(uiSourceCode) {
     return this._getOrCreateSourceView(uiSourceCode);
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    */
   _removeSourceFrame(uiSourceCode) {
     var sourceView = this._sourceViewByUISourceCode.get(uiSourceCode);
     this._sourceViewByUISourceCode.remove(uiSourceCode);
     uiSourceCode.removeEventListener(
-        WebInspector.UISourceCode.Events.TitleChanged, this._uiSourceCodeTitleChanged, this);
-    if (sourceView && sourceView instanceof WebInspector.UISourceCodeFrame)
-      /** @type {!WebInspector.UISourceCodeFrame} */ (sourceView).dispose();
+        Workspace.UISourceCode.Events.TitleChanged, this._uiSourceCodeTitleChanged, this);
+    if (sourceView && sourceView instanceof Sources.UISourceCodeFrame)
+      /** @type {!Sources.UISourceCodeFrame} */ (sourceView).dispose();
   }
 
   clearCurrentExecutionLine() {
     if (this._executionSourceFrame)
       this._executionSourceFrame.clearExecutionLine();
     delete this._executionSourceFrame;
   }
 
   /**
-   * @param {!WebInspector.UILocation} uiLocation
+   * @param {!Workspace.UILocation} uiLocation
    */
   setExecutionLocation(uiLocation) {
     var sourceView = this._getOrCreateSourceView(uiLocation.uiSourceCode);
-    if (sourceView instanceof WebInspector.UISourceCodeFrame) {
-      var sourceFrame = /** @type {!WebInspector.UISourceCodeFrame} */ (sourceView);
+    if (sourceView instanceof Sources.UISourceCodeFrame) {
+      var sourceFrame = /** @type {!Sources.UISourceCodeFrame} */ (sourceView);
       sourceFrame.setExecutionLocation(uiLocation);
       this._executionSourceFrame = sourceFrame;
     }
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _editorClosed(event) {
-    var uiSourceCode = /** @type {!WebInspector.UISourceCode} */ (event.data);
+    var uiSourceCode = /** @type {!Workspace.UISourceCode} */ (event.data);
     this._historyManager.removeHistoryForSourceCode(uiSourceCode);
 
     var wasSelected = false;
     if (!this._editorContainer.currentFile())
       wasSelected = true;
 
     // SourcesNavigator does not need to update on EditorClosed.
     this._updateScriptViewToolbarItems();
     this._searchableView.resetSearch();
 
     var data = {};
     data.uiSourceCode = uiSourceCode;
     data.wasSelected = wasSelected;
-    this.dispatchEventToListeners(WebInspector.SourcesView.Events.EditorClosed, data);
+    this.dispatchEventToListeners(Sources.SourcesView.Events.EditorClosed, data);
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _editorSelected(event) {
     var previousSourceFrame =
-        event.data.previousView instanceof WebInspector.UISourceCodeFrame ? event.data.previousView : null;
+        event.data.previousView instanceof Sources.UISourceCodeFrame ? event.data.previousView : null;
     if (previousSourceFrame)
       previousSourceFrame.setSearchableView(null);
     var currentSourceFrame =
-        event.data.currentView instanceof WebInspector.UISourceCodeFrame ? event.data.currentView : null;
+        event.data.currentView instanceof Sources.UISourceCodeFrame ? event.data.currentView : null;
     if (currentSourceFrame)
       currentSourceFrame.setSearchableView(this._searchableView);
 
     this._searchableView.setReplaceable(!!currentSourceFrame && currentSourceFrame.canEditSource());
     this._searchableView.refreshSearch();
     this._updateScriptViewToolbarItems();
 
-    this.dispatchEventToListeners(WebInspector.SourcesView.Events.EditorSelected, this._editorContainer.currentFile());
+    this.dispatchEventToListeners(Sources.SourcesView.Events.EditorSelected, this._editorContainer.currentFile());
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _uiSourceCodeTitleChanged(event) {
-    this._recreateSourceFrameIfNeeded(/** @type {!WebInspector.UISourceCode} */ (event.target));
+    this._recreateSourceFrameIfNeeded(/** @type {!Workspace.UISourceCode} */ (event.target));
   }
 
   /**
    * @override
    */
   searchCanceled() {
     if (this._searchView)
       this._searchView.searchCanceled();
 
     delete this._searchView;
     delete this._searchConfig;
   }
 
   /**
    * @override
-   * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
+   * @param {!UI.SearchableView.SearchConfig} searchConfig
    * @param {boolean} shouldJump
    * @param {boolean=} jumpBackwards
    */
   performSearch(searchConfig, shouldJump, jumpBackwards) {
     var sourceFrame = this.currentSourceFrame();
     if (!sourceFrame)
       return;
 
     this._searchView = sourceFrame;
     this._searchConfig = searchConfig;
@@ skipping 44 matching lines @@
   /**
    * @override
    * @return {boolean}
    */
   supportsRegexSearch() {
     return true;
   }
 
   /**
    * @override
-   * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
+   * @param {!UI.SearchableView.SearchConfig} searchConfig
    * @param {string} replacement
    */
   replaceSelectionWith(searchConfig, replacement) {
     var sourceFrame = this.currentSourceFrame();
     if (!sourceFrame) {
       console.assert(sourceFrame);
       return;
     }
     sourceFrame.replaceSelectionWith(searchConfig, replacement);
   }
 
   /**
    * @override
-   * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
+   * @param {!UI.SearchableView.SearchConfig} searchConfig
    * @param {string} replacement
    */
   replaceAllWith(searchConfig, replacement) {
     var sourceFrame = this.currentSourceFrame();
     if (!sourceFrame) {
       console.assert(sourceFrame);
       return;
     }
     sourceFrame.replaceAllWith(searchConfig, replacement);
   }
 
   /**
    * @param {!Event=} event
    * @return {boolean}
    */
   _showOutlineDialog(event) {
     var uiSourceCode = this._editorContainer.currentFile();
     if (!uiSourceCode)
       return false;
 
     if (uiSourceCode.contentType().hasScripts()) {
-      WebInspector.JavaScriptOutlineDialog.show(uiSourceCode, this.showSourceLocation.bind(this, uiSourceCode));
+      Sources.JavaScriptOutlineDialog.show(uiSourceCode, this.showSourceLocation.bind(this, uiSourceCode));
       return true;
     }
 
     if (uiSourceCode.contentType().isStyleSheet()) {
-      WebInspector.StyleSheetOutlineDialog.show(uiSourceCode, this.showSourceLocation.bind(this, uiSourceCode));
+      Sources.StyleSheetOutlineDialog.show(uiSourceCode, this.showSourceLocation.bind(this, uiSourceCode));
       return true;
     }
 
     // We don't want default browser shortcut to be executed, so pretend to handle this event.
     return true;
   }
 
   /**
    * @param {string=} query
    */
   showOpenResourceDialog(query) {
     var uiSourceCodes = this._editorContainer.historyUISourceCodes();
-    /** @type {!Map.<!WebInspector.UISourceCode, number>} */
+    /** @type {!Map.<!Workspace.UISourceCode, number>} */
     var defaultScores = new Map();
     for (var i = 1; i < uiSourceCodes.length; ++i)  // Skip current element
       defaultScores.set(uiSourceCodes[i], uiSourceCodes.length - i);
     if (!this._openResourceDialogHistory)
       this._openResourceDialogHistory = [];
-    WebInspector.OpenResourceDialog.show(this, query || '', defaultScores, this._openResourceDialogHistory);
+    Sources.OpenResourceDialog.show(this, query || '', defaultScores, this._openResourceDialogHistory);
   }
 
   /**
    * @param {!Event=} event
    * @return {boolean}
    */
   _showGoToLineDialog(event) {
     if (this._editorContainer.currentFile())
       this.showOpenResourceDialog(':');
     return true;
@@ skipping 10 matching lines @@
   /**
    * @return {boolean}
    */
   _saveAll() {
     var sourceFrames = this._editorContainer.fileViews();
     sourceFrames.forEach(this._saveSourceFrame.bind(this));
     return true;
   }
 
   /**
-   * @param {?WebInspector.Widget} sourceFrame
+   * @param {?UI.Widget} sourceFrame
    */
   _saveSourceFrame(sourceFrame) {
-    if (!(sourceFrame instanceof WebInspector.UISourceCodeFrame))
+    if (!(sourceFrame instanceof Sources.UISourceCodeFrame))
       return;
-    var uiSourceCodeFrame = /** @type {!WebInspector.UISourceCodeFrame} */ (sourceFrame);
+    var uiSourceCodeFrame = /** @type {!Sources.UISourceCodeFrame} */ (sourceFrame);
     uiSourceCodeFrame.commitEditing();
   }
 
   /**
    * @return {boolean}
    */
   _toggleBreakpoint() {
     var sourceFrame = this.currentSourceFrame();
     if (!sourceFrame)
       return false;
 
-    if (sourceFrame instanceof WebInspector.JavaScriptSourceFrame) {
-      var javaScriptSourceFrame = /** @type {!WebInspector.JavaScriptSourceFrame} */ (sourceFrame);
+    if (sourceFrame instanceof Sources.JavaScriptSourceFrame) {
+      var javaScriptSourceFrame = /** @type {!Sources.JavaScriptSourceFrame} */ (sourceFrame);
       javaScriptSourceFrame.toggleBreakpointOnCurrentLine();
       return true;
     }
     return false;
   }
 
   /**
    * @param {boolean} active
    */
   toggleBreakpointsActiveState(active) {
     this._editorContainer.view.element.classList.toggle('breakpoints-deactivated', !active);
   }
 };
 
 /** @enum {symbol} */
-WebInspector.SourcesView.Events = {
+Sources.SourcesView.Events = {
   EditorClosed: Symbol('EditorClosed'),
   EditorSelected: Symbol('EditorSelected'),
 };
 
 /**
  * @interface
  */
-WebInspector.SourcesView.EditorAction = function() {};
+Sources.SourcesView.EditorAction = function() {};
 
-WebInspector.SourcesView.EditorAction.prototype = {
+Sources.SourcesView.EditorAction.prototype = {
   /**
-   * @param {!WebInspector.SourcesView} sourcesView
-   * @return {!WebInspector.ToolbarButton}
+   * @param {!Sources.SourcesView} sourcesView
+   * @return {!UI.ToolbarButton}
    */
   button: function(sourcesView) {}
 };
 
 /**
- * @implements {WebInspector.ActionDelegate}
+ * @implements {UI.ActionDelegate}
  * @unrestricted
  */
-WebInspector.SourcesView.SwitchFileActionDelegate = class {
+Sources.SourcesView.SwitchFileActionDelegate = class {
   /**
-   * @param {!WebInspector.UISourceCode} currentUISourceCode
-   * @return {?WebInspector.UISourceCode}
+   * @param {!Workspace.UISourceCode} currentUISourceCode
+   * @return {?Workspace.UISourceCode}
    */
   static _nextFile(currentUISourceCode) {
     /**
      * @param {string} name
      * @return {string}
      */
     function fileNamePrefix(name) {
       var lastDotIndex = name.lastIndexOf('.');
       var namePrefix = name.substr(0, lastDotIndex !== -1 ? lastDotIndex : name.length);
       return namePrefix.toLowerCase();
@@ skipping 13 matching lines @@
     }
     candidates.sort(String.naturalOrderComparator);
     var index = mod(candidates.indexOf(name) + 1, candidates.length);
     var fullURL = (url ? url + '/' : '') + candidates[index];
     var nextUISourceCode = currentUISourceCode.project().uiSourceCodeForURL(fullURL);
     return nextUISourceCode !== currentUISourceCode ? nextUISourceCode : null;
   }
 
   /**
    * @override
-   * @param {!WebInspector.Context} context
+   * @param {!UI.Context} context
    * @param {string} actionId
    * @return {boolean}
    */
   handleAction(context, actionId) {
-    var sourcesView = WebInspector.context.flavor(WebInspector.SourcesView);
+    var sourcesView = UI.context.flavor(Sources.SourcesView);
     var currentUISourceCode = sourcesView.currentUISourceCode();
     if (!currentUISourceCode)
       return false;
-    var nextUISourceCode = WebInspector.SourcesView.SwitchFileActionDelegate._nextFile(currentUISourceCode);
+    var nextUISourceCode = Sources.SourcesView.SwitchFileActionDelegate._nextFile(currentUISourceCode);
     if (!nextUISourceCode)
       return false;
     sourcesView.showSourceLocation(nextUISourceCode);
     return true;
   }
 };
 
 
 /**
- * @implements {WebInspector.ActionDelegate}
+ * @implements {UI.ActionDelegate}
  * @unrestricted
  */
-WebInspector.SourcesView.CloseAllActionDelegate = class {
+Sources.SourcesView.CloseAllActionDelegate = class {
   /**
    * @override
-   * @param {!WebInspector.Context} context
+   * @param {!UI.Context} context
    * @param {string} actionId
    * @return {boolean}
    */
   handleAction(context, actionId) {
-    var sourcesView = WebInspector.context.flavor(WebInspector.SourcesView);
+    var sourcesView = UI.context.flavor(Sources.SourcesView);
     if (!sourcesView)
       return false;
     sourcesView._editorContainer.closeAllFiles();
     return true;
   }
 };