DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/source_frame/SourceFrame.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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * 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.
  */
 /**
- * @implements {WebInspector.Searchable}
- * @implements {WebInspector.Replaceable}
- * @implements {WebInspector.SourcesTextEditorDelegate}
+ * @implements {UI.Searchable}
+ * @implements {UI.Replaceable}
+ * @implements {SourceFrame.SourcesTextEditorDelegate}
  * @unrestricted
  */
-WebInspector.SourceFrame = class extends WebInspector.SimpleView {
+SourceFrame.SourceFrame = class extends UI.SimpleView {
   /**
    * @param {string} url
    * @param {function(): !Promise<?string>} lazyContent
    */
   constructor(url, lazyContent) {
-    super(WebInspector.UIString('Source'));
+    super(Common.UIString('Source'));
 
     this._url = url;
     this._lazyContent = lazyContent;
 
-    this._textEditor = new WebInspector.SourcesTextEditor(this);
+    this._textEditor = new SourceFrame.SourcesTextEditor(this);
 
     this._currentSearchResultIndex = -1;
     this._searchResults = [];
 
     this._textEditor.addEventListener(
-        WebInspector.SourcesTextEditor.Events.EditorFocused, this._resetCurrentSearchResultIndex, this);
+        SourceFrame.SourcesTextEditor.Events.EditorFocused, this._resetCurrentSearchResultIndex, this);
     this._textEditor.addEventListener(
-        WebInspector.SourcesTextEditor.Events.SelectionChanged, this._updateSourcePosition, this);
+        SourceFrame.SourcesTextEditor.Events.SelectionChanged, this._updateSourcePosition, this);
     this._textEditor.addEventListener(
-        WebInspector.SourcesTextEditor.Events.TextChanged,
+        SourceFrame.SourcesTextEditor.Events.TextChanged,
         event => this.onTextChanged(event.data.oldRange, event.data.newRange));
 
     this._shortcuts = {};
     this.element.addEventListener('keydown', this._handleKeyDown.bind(this), false);
 
-    this._sourcePosition = new WebInspector.ToolbarText();
+    this._sourcePosition = new UI.ToolbarText();
 
     /**
-     * @type {?WebInspector.SearchableView}
+     * @type {?UI.SearchableView}
      */
     this._searchableView = null;
     this._editable = false;
   }
 
   /**
    * @param {boolean} editable
    */
   setEditable(editable) {
     this._editable = editable;
@@ skipping 29 matching lines @@
    * @override
    */
   willHide() {
     super.willHide();
 
     this._clearPositionToReveal();
   }
 
   /**
    * @override
-   * @return {!Array<!WebInspector.ToolbarItem>}
+   * @return {!Array<!UI.ToolbarItem>}
    */
   syncToolbarItems() {
     return [this._sourcePosition];
   }
 
   get loaded() {
     return this._loaded;
   }
 
   get textEditor() {
@@ skipping 52 matching lines @@
         delete this._lineToScrollTo;
       }
     }
   }
 
   _clearLineToScrollTo() {
     delete this._lineToScrollTo;
   }
 
   /**
-   * @return {!WebInspector.TextRange}
+   * @return {!Common.TextRange}
    */
   selection() {
     return this.textEditor.selection();
   }
 
   /**
-   * @param {!WebInspector.TextRange} textRange
+   * @param {!Common.TextRange} textRange
    */
   setSelection(textRange) {
     this._selectionToSet = textRange;
     this._innerSetSelectionIfNeeded();
   }
 
   _innerSetSelectionIfNeeded() {
     if (this._selectionToSet && this.loaded && this.isEditorShowing()) {
       this._textEditor.setSelection(this._selectionToSet);
       delete this._selectionToSet;
     }
   }
 
   _clearSelectionToSet() {
     delete this._selectionToSet;
   }
 
   _wasShownOrLoaded() {
     this._innerRevealPositionIfNeeded();
     this._innerSetSelectionIfNeeded();
     this._innerScrollToLineIfNeeded();
   }
 
   /**
-   * @param {!WebInspector.TextRange} oldRange
-   * @param {!WebInspector.TextRange} newRange
+   * @param {!Common.TextRange} oldRange
+   * @param {!Common.TextRange} newRange
    */
   onTextChanged(oldRange, newRange) {
     if (this._searchConfig && this._searchableView)
       this.performSearch(this._searchConfig, false, false);
   }
 
   /**
    * @param {string} content
    * @param {string} mimeType
    * @return {string}
@@ skipping 47 matching lines @@
       this._delayedFindSearchMatches();
       delete this._delayedFindSearchMatches;
     }
     this.onTextEditorContentSet();
   }
 
   onTextEditorContentSet() {
   }
 
   /**
-   * @param {?WebInspector.SearchableView} view
+   * @param {?UI.SearchableView} view
    */
   setSearchableView(view) {
     this._searchableView = view;
   }
 
   /**
-   * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
+   * @param {!UI.SearchableView.SearchConfig} searchConfig
    * @param {boolean} shouldJump
    * @param {boolean} jumpBackwards
    */
   _doFindSearchMatches(searchConfig, shouldJump, jumpBackwards) {
     this._currentSearchResultIndex = -1;
     this._searchResults = [];
 
     var regex = searchConfig.toSearchRegex();
     this._searchRegex = regex;
     this._searchResults = this._collectRegexMatches(regex);
 
     if (this._searchableView)
       this._searchableView.updateSearchMatchesCount(this._searchResults.length);
 
     if (!this._searchResults.length)
       this._textEditor.cancelSearchResultsHighlight();
     else if (shouldJump && jumpBackwards)
       this.jumpToPreviousSearchResult();
     else if (shouldJump)
       this.jumpToNextSearchResult();
     else
       this._textEditor.highlightSearchResults(regex, null);
   }
 
   /**
    * @override
-   * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
+   * @param {!UI.SearchableView.SearchConfig} searchConfig
    * @param {boolean} shouldJump
    * @param {boolean=} jumpBackwards
    */
   performSearch(searchConfig, shouldJump, jumpBackwards) {
     if (this._searchableView)
       this._searchableView.updateSearchMatchesCount(0);
 
     this._resetSearch();
     this._searchConfig = searchConfig;
     if (this.loaded)
@@ skipping 47 matching lines @@
 
   jumpToLastSearchResult() {
     this.jumpToSearchResult(this._searchResults.length - 1);
   }
 
   /**
    * @return {number}
    */
   _searchResultIndexForCurrentSelection() {
     return this._searchResults.lowerBound(
-        this._textEditor.selection().collapseToEnd(), WebInspector.TextRange.comparator);
+        this._textEditor.selection().collapseToEnd(), Common.TextRange.comparator);
   }
 
   /**
    * @override
    */
   jumpToNextSearchResult() {
     var currentIndex = this._searchResultIndexForCurrentSelection();
     var nextIndex = this._currentSearchResultIndex === -1 ? currentIndex : currentIndex + 1;
     this.jumpToSearchResult(nextIndex);
   }
@@ skipping 30 matching lines @@
     if (!this.loaded || !this._searchResults.length)
       return;
     this._currentSearchResultIndex = (index + this._searchResults.length) % this._searchResults.length;
     if (this._searchableView)
       this._searchableView.updateCurrentMatchIndex(this._currentSearchResultIndex);
     this._textEditor.highlightSearchResults(this._searchRegex, this._searchResults[this._currentSearchResultIndex]);
   }
 
   /**
    * @override
-   * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
+   * @param {!UI.SearchableView.SearchConfig} searchConfig
    * @param {string} replacement
    */
   replaceSelectionWith(searchConfig, replacement) {
     var range = this._searchResults[this._currentSearchResultIndex];
     if (!range)
       return;
     this._textEditor.highlightSearchResults(this._searchRegex, null);
 
     var oldText = this._textEditor.text(range);
     var regex = searchConfig.toSearchRegex();
     var text;
     if (regex.__fromRegExpQuery)
       text = oldText.replace(regex, replacement);
     else
       text = oldText.replace(regex, function() {
         return replacement;
       });
 
     var newRange = this._textEditor.editRange(range, text);
     this._textEditor.setSelection(newRange.collapseToEnd());
   }
 
   /**
    * @override
-   * @param {!WebInspector.SearchableView.SearchConfig} searchConfig
+   * @param {!UI.SearchableView.SearchConfig} searchConfig
    * @param {string} replacement
    */
   replaceAllWith(searchConfig, replacement) {
     this._resetCurrentSearchResultIndex();
 
     var text = this._textEditor.text();
     var range = this._textEditor.fullRange();
 
     var regex = searchConfig.toSearchRegex(true);
     if (regex.__fromRegExpQuery)
       text = text.replace(regex, replacement);
     else
       text = text.replace(regex, function() {
         return replacement;
       });
 
     var ranges = this._collectRegexMatches(regex);
     if (!ranges.length)
       return;
 
     // Calculate the position of the end of the last range to be edited.
-    var currentRangeIndex = ranges.lowerBound(this._textEditor.selection(), WebInspector.TextRange.comparator);
+    var currentRangeIndex = ranges.lowerBound(this._textEditor.selection(), Common.TextRange.comparator);
     var lastRangeIndex = mod(currentRangeIndex - 1, ranges.length);
     var lastRange = ranges[lastRangeIndex];
     var replacementLineEndings = replacement.computeLineEndings();
     var replacementLineCount = replacementLineEndings.length;
     var lastLineNumber = lastRange.startLine + replacementLineEndings.length - 1;
     var lastColumnNumber = lastRange.startColumn;
     if (replacementLineEndings.length > 1)
       lastColumnNumber =
           replacementLineEndings[replacementLineCount - 1] - replacementLineEndings[replacementLineCount - 2] - 1;
 
     this._textEditor.editRange(range, text);
     this._textEditor.revealPosition(lastLineNumber, lastColumnNumber);
-    this._textEditor.setSelection(WebInspector.TextRange.createFromLocation(lastLineNumber, lastColumnNumber));
+    this._textEditor.setSelection(Common.TextRange.createFromLocation(lastLineNumber, lastColumnNumber));
   }
 
   _collectRegexMatches(regexObject) {
     var ranges = [];
     for (var i = 0; i < this._textEditor.linesCount; ++i) {
       var line = this._textEditor.line(i);
       var offset = 0;
       do {
         var match = regexObject.exec(line);
         if (match) {
           var matchEndIndex = match.index + Math.max(match[0].length, 1);
           if (match[0].length)
-            ranges.push(new WebInspector.TextRange(i, offset + match.index, i, offset + matchEndIndex));
+            ranges.push(new Common.TextRange(i, offset + match.index, i, offset + matchEndIndex));
           offset += matchEndIndex;
           line = line.substring(matchEndIndex);
         }
       } while (match && line);
     }
     return ranges;
   }
 
   /**
    * @override
@@ skipping 16 matching lines @@
    */
   canEditSource() {
     return this._editable;
   }
 
   _updateSourcePosition() {
     var selections = this._textEditor.selections();
     if (!selections.length)
       return;
     if (selections.length > 1) {
-      this._sourcePosition.setText(WebInspector.UIString('%d selection regions', selections.length));
+      this._sourcePosition.setText(Common.UIString('%d selection regions', selections.length));
       return;
     }
     var textRange = selections[0];
     if (textRange.isEmpty()) {
       this._sourcePosition.setText(
-          WebInspector.UIString('Line %d, Column %d', textRange.endLine + 1, textRange.endColumn + 1));
+          Common.UIString('Line %d, Column %d', textRange.endLine + 1, textRange.endColumn + 1));
       return;
     }
     textRange = textRange.normalize();
 
     var selectedText = this._textEditor.text(textRange);
     if (textRange.startLine === textRange.endLine)
-      this._sourcePosition.setText(WebInspector.UIString('%d characters selected', selectedText.length));
+      this._sourcePosition.setText(Common.UIString('%d characters selected', selectedText.length));
     else
-      this._sourcePosition.setText(WebInspector.UIString(
+      this._sourcePosition.setText(Common.UIString(
           '%d lines, %d characters selected', textRange.endLine - textRange.startLine + 1, selectedText.length));
   }
 
   _handleKeyDown(e) {
-    var shortcutKey = WebInspector.KeyboardShortcut.makeKeyFromEvent(e);
+    var shortcutKey = UI.KeyboardShortcut.makeKeyFromEvent(e);
     var handler = this._shortcuts[shortcutKey];
     if (handler && handler())
       e.consume(true);
   }
 };