DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/workspace/UISourceCode.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.ContentProvider}
+ * @implements {Common.ContentProvider}
  * @unrestricted
  */
-WebInspector.UISourceCode = class extends WebInspector.Object {
+Workspace.UISourceCode = class extends Common.Object {
   /**
-   * @param {!WebInspector.Project} project
+   * @param {!Workspace.Project} project
    * @param {string} url
-   * @param {!WebInspector.ResourceType} contentType
+   * @param {!Common.ResourceType} contentType
    */
   constructor(project, url, contentType) {
     super();
     this._project = project;
     this._url = url;
 
     var parsedURL = url.asParsedURL();
     if (parsedURL) {
       this._origin = parsedURL.securityOrigin();
       this._parentURL = this._origin + parsedURL.folderPathComponents;
       this._name = parsedURL.lastPathComponent;
       if (parsedURL.queryParams)
         this._name += '?' + parsedURL.queryParams;
     } else {
       this._origin = '';
       this._parentURL = '';
       this._name = url;
     }
 
     this._contentType = contentType;
     /** @type {?function(?string)} */
     this._requestContentCallback = null;
     /** @type {?Promise<?string>} */
     this._requestContentPromise = null;
-    /** @type {!Map<string, !Map<number, !WebInspector.UISourceCode.LineMarker>>} */
+    /** @type {!Map<string, !Map<number, !Workspace.UISourceCode.LineMarker>>} */
     this._lineDecorations = new Map();
 
-    /** @type {!Array.<!WebInspector.Revision>} */
+    /** @type {!Array.<!Workspace.Revision>} */
     this.history = [];
 
-    /** @type {!Array<!WebInspector.UISourceCode.Message>} */
+    /** @type {!Array<!Workspace.UISourceCode.Message>} */
     this._messages = [];
   }
 
   /**
-   * @return {!Promise<?WebInspector.UISourceCodeMetadata>}
+   * @return {!Promise<?Workspace.UISourceCodeMetadata>}
    */
   requestMetadata() {
     return this._project.requestMetadata(this);
   }
 
   /**
    * @return {string}
    */
   name() {
     return this._name;
@@ skipping 31 matching lines @@
     }
     return parentPath + '/' + this.displayName(true);
   }
 
   /**
    * @param {boolean=} skipTrim
    * @return {string}
    */
   displayName(skipTrim) {
     if (!this._name)
-      return WebInspector.UIString('(index)');
+      return Common.UIString('(index)');
     var name = this._name;
     try {
       name = decodeURI(name);
     } catch (e) {
     }
     return skipTrim ? name : name.trimEnd(100);
   }
 
   /**
    * @return {boolean}
    */
   isFromServiceProject() {
-    return WebInspector.Project.isServiceProject(this._project);
+    return Workspace.Project.isServiceProject(this._project);
   }
 
   /**
    * @return {boolean}
    */
   canRename() {
     return this._project.canRename();
   }
 
   /**
    * @param {string} newName
    * @param {function(boolean)} callback
    */
   rename(newName, callback) {
     this._project.rename(this, newName, innerCallback.bind(this));
 
     /**
      * @param {boolean} success
      * @param {string=} newName
      * @param {string=} newURL
-     * @param {!WebInspector.ResourceType=} newContentType
-     * @this {WebInspector.UISourceCode}
+     * @param {!Common.ResourceType=} newContentType
+     * @this {Workspace.UISourceCode}
      */
     function innerCallback(success, newName, newURL, newContentType) {
       if (success)
         this._updateName(
             /** @type {string} */ (newName), /** @type {string} */ (newURL),
-            /** @type {!WebInspector.ResourceType} */ (newContentType));
+            /** @type {!Common.ResourceType} */ (newContentType));
       callback(success);
     }
   }
 
   remove() {
     this._project.deleteFile(this.url());
   }
 
   /**
    * @param {string} name
    * @param {string} url
-   * @param {!WebInspector.ResourceType=} contentType
+   * @param {!Common.ResourceType=} contentType
    */
   _updateName(name, url, contentType) {
     var oldURL = this.url();
     this._url = this._url.substring(0, this._url.length - this._name.length) + name;
     this._name = name;
     if (url)
       this._url = url;
     if (contentType)
       this._contentType = contentType;
-    this.dispatchEventToListeners(WebInspector.UISourceCode.Events.TitleChanged, oldURL);
+    this.dispatchEventToListeners(Workspace.UISourceCode.Events.TitleChanged, oldURL);
   }
 
   /**
    * @override
    * @return {string}
    */
   contentURL() {
     return this.url();
   }
 
   /**
    * @override
-   * @return {!WebInspector.ResourceType}
+   * @return {!Common.ResourceType}
    */
   contentType() {
     return this._contentType;
   }
 
   /**
-   * @return {!WebInspector.Project}
+   * @return {!Workspace.Project}
    */
   project() {
     return this._project;
   }
 
   /**
    * @override
    * @return {!Promise<?string>}
    */
   requestContent() {
@@ skipping 46 matching lines @@
     this._pushCheckContentUpdatedCallback(callback);
 
     if (this._checkingContent)
       return;
 
     this._checkingContent = true;
     this._project.requestFileContent(this, contentLoaded.bind(this));
 
     /**
      * @param {?string} updatedContent
-     * @this {WebInspector.UISourceCode}
+     * @this {Workspace.UISourceCode}
      */
     function contentLoaded(updatedContent) {
       if (updatedContent === null) {
         var workingCopy = this.workingCopy();
         this._contentCommitted('', false);
         this.setWorkingCopy(workingCopy);
         this._terminateContentCheck();
         return;
       }
       if (typeof this._lastAcceptedContent === 'string' && this._lastAcceptedContent === updatedContent) {
         this._terminateContentCheck();
         return;
       }
 
       if (this._content === updatedContent) {
         delete this._lastAcceptedContent;
         this._terminateContentCheck();
         return;
       }
 
       if (!this.isDirty() || this._workingCopy === updatedContent) {
         this._contentCommitted(updatedContent, false);
         this._terminateContentCheck();
         return;
       }
 
       var shouldUpdate =
-          window.confirm(WebInspector.UIString('This file was changed externally. Would you like to reload it?'));
+          window.confirm(Common.UIString('This file was changed externally. Would you like to reload it?'));
       if (shouldUpdate)
         this._contentCommitted(updatedContent, false);
       else
         this._lastAcceptedContent = updatedContent;
       this._terminateContentCheck();
     }
   }
 
   forceLoadOnCheckContent() {
     this._forceLoadOnCheckContent = true;
   }
 
   /**
    * @return {!Promise<?string>}
    */
   requestOriginalContent() {
     var callback;
     var promise = new Promise(fulfill => callback = fulfill);
     this._project.requestFileContent(this, callback);
     return promise;
   }
 
   /**
    * @param {string} content
    */
   _commitContent(content) {
     if (this._project.canSetFileContent()) {
       this._project.setFileContent(this, content, function() {});
-    } else if (this._url && WebInspector.fileManager.isURLSaved(this._url)) {
-      WebInspector.fileManager.save(this._url, content, false, function() {});
-      WebInspector.fileManager.close(this._url);
+    } else if (this._url && Workspace.fileManager.isURLSaved(this._url)) {
+      Workspace.fileManager.save(this._url, content, false, function() {});
+      Workspace.fileManager.close(this._url);
     }
     this._contentCommitted(content, true);
   }
 
   /**
    * @param {string} content
    * @param {boolean} committedByUser
    */
   _contentCommitted(content, committedByUser) {
     delete this._lastAcceptedContent;
     this._content = content;
     this._contentLoaded = true;
 
     var lastRevision = this.history.length ? this.history[this.history.length - 1] : null;
     if (!lastRevision || lastRevision._content !== this._content) {
-      var revision = new WebInspector.Revision(this, this._content, new Date());
+      var revision = new Workspace.Revision(this, this._content, new Date());
       this.history.push(revision);
     }
 
     this._innerResetWorkingCopy();
-    this.dispatchEventToListeners(WebInspector.UISourceCode.Events.WorkingCopyCommitted, {content: content});
+    this.dispatchEventToListeners(Workspace.UISourceCode.Events.WorkingCopyCommitted, {content: content});
     this._project.workspace().dispatchEventToListeners(
-        WebInspector.Workspace.Events.WorkingCopyCommitted, {uiSourceCode: this, content: content});
+        Workspace.Workspace.Events.WorkingCopyCommitted, {uiSourceCode: this, content: content});
     if (committedByUser)
       this._project.workspace().dispatchEventToListeners(
-          WebInspector.Workspace.Events.WorkingCopyCommittedByUser, {uiSourceCode: this, content: content});
+          Workspace.Workspace.Events.WorkingCopyCommittedByUser, {uiSourceCode: this, content: content});
   }
 
   saveAs() {
-    WebInspector.fileManager.save(this._url, this.workingCopy(), true, callback.bind(this));
-    WebInspector.fileManager.close(this._url);
+    Workspace.fileManager.save(this._url, this.workingCopy(), true, callback.bind(this));
+    Workspace.fileManager.close(this._url);
 
     /**
      * @param {boolean} accepted
-     * @this {WebInspector.UISourceCode}
+     * @this {Workspace.UISourceCode}
      */
     function callback(accepted) {
       if (accepted)
         this._contentCommitted(this.workingCopy(), true);
     }
   }
 
   /**
    * @param {string} content
    */
   addRevision(content) {
     this._commitContent(content);
   }
 
   /**
    * @return {!Promise}
    */
   revertToOriginal() {
     /**
-     * @this {WebInspector.UISourceCode}
+     * @this {Workspace.UISourceCode}
      * @param {?string} content
      */
     function callback(content) {
       if (typeof content !== 'string')
         return;
 
       this.addRevision(content);
     }
 
-    WebInspector.userMetrics.actionTaken(WebInspector.UserMetrics.Action.RevisionApplied);
+    Host.userMetrics.actionTaken(Host.UserMetrics.Action.RevisionApplied);
     return this.requestOriginalContent().then(callback.bind(this));
   }
 
   /**
-   * @param {function(!WebInspector.UISourceCode)} callback
+   * @param {function(!Workspace.UISourceCode)} callback
    */
   revertAndClearHistory(callback) {
     /**
-     * @this {WebInspector.UISourceCode}
+     * @this {Workspace.UISourceCode}
      * @param {?string} content
      */
     function revert(content) {
       if (typeof content !== 'string')
         return;
 
       this.addRevision(content);
       this.history = [];
       callback(this);
     }
 
-    WebInspector.userMetrics.actionTaken(WebInspector.UserMetrics.Action.RevisionApplied);
+    Host.userMetrics.actionTaken(Host.UserMetrics.Action.RevisionApplied);
     this.requestOriginalContent().then(revert.bind(this));
   }
 
   /**
    * @return {string}
    */
   workingCopy() {
     if (this._workingCopyGetter) {
       this._workingCopy = this._workingCopyGetter();
       delete this._workingCopyGetter;
     }
     if (this.isDirty())
       return this._workingCopy;
     return this._content;
   }
 
   resetWorkingCopy() {
     this._innerResetWorkingCopy();
-    this.dispatchEventToListeners(WebInspector.UISourceCode.Events.WorkingCopyChanged);
+    this.dispatchEventToListeners(Workspace.UISourceCode.Events.WorkingCopyChanged);
   }
 
   _innerResetWorkingCopy() {
     delete this._workingCopy;
     delete this._workingCopyGetter;
   }
 
   /**
    * @param {string} newWorkingCopy
    */
   setWorkingCopy(newWorkingCopy) {
     this._workingCopy = newWorkingCopy;
     delete this._workingCopyGetter;
-    this.dispatchEventToListeners(WebInspector.UISourceCode.Events.WorkingCopyChanged);
+    this.dispatchEventToListeners(Workspace.UISourceCode.Events.WorkingCopyChanged);
     this._project.workspace().dispatchEventToListeners(
-        WebInspector.Workspace.Events.WorkingCopyChanged, {uiSourceCode: this});
+        Workspace.Workspace.Events.WorkingCopyChanged, {uiSourceCode: this});
   }
 
   setWorkingCopyGetter(workingCopyGetter) {
     this._workingCopyGetter = workingCopyGetter;
-    this.dispatchEventToListeners(WebInspector.UISourceCode.Events.WorkingCopyChanged);
+    this.dispatchEventToListeners(Workspace.UISourceCode.Events.WorkingCopyChanged);
     this._project.workspace().dispatchEventToListeners(
-        WebInspector.Workspace.Events.WorkingCopyChanged, {uiSourceCode: this});
+        Workspace.Workspace.Events.WorkingCopyChanged, {uiSourceCode: this});
   }
 
   removeWorkingCopyGetter() {
     if (!this._workingCopyGetter)
       return;
     this._workingCopy = this._workingCopyGetter();
     delete this._workingCopyGetter;
   }
 
   commitWorkingCopy() {
     if (this.isDirty())
       this._commitContent(this.workingCopy());
   }
 
   /**
    * @return {boolean}
    */
   isDirty() {
     return typeof this._workingCopy !== 'undefined' || typeof this._workingCopyGetter !== 'undefined';
   }
 
   /**
    * @return {string}
    */
   extension() {
-    return WebInspector.ParsedURL.extractExtension(this._name);
+    return Common.ParsedURL.extractExtension(this._name);
   }
 
   /**
    * @return {?string}
    */
   content() {
     return this._content;
   }
 
   /**
    * @override
    * @param {string} query
    * @param {boolean} caseSensitive
    * @param {boolean} isRegex
-   * @param {function(!Array.<!WebInspector.ContentProvider.SearchMatch>)} callback
+   * @param {function(!Array.<!Common.ContentProvider.SearchMatch>)} callback
    */
   searchInContent(query, caseSensitive, isRegex, callback) {
     var content = this.content();
     if (!content) {
       this._project.searchInFileContent(this, query, caseSensitive, isRegex, callback);
       return;
     }
 
     // searchInContent should call back later.
     setTimeout(doSearch.bind(null, content), 0);
 
     /**
      * @param {string} content
      */
     function doSearch(content) {
-      callback(WebInspector.ContentProvider.performSearchInContent(content, query, caseSensitive, isRegex));
+      callback(Common.ContentProvider.performSearchInContent(content, query, caseSensitive, isRegex));
     }
   }
 
   /**
    * @param {?string} content
    */
   _fireContentAvailable(content) {
     this._contentLoaded = true;
     this._content = content;
 
     var callback = this._requestContentCallback;
     this._requestContentCallback = null;
     this._requestContentPromise = null;
 
     callback.call(null, content);
   }
 
   /**
    * @return {boolean}
    */
   contentLoaded() {
     return this._contentLoaded;
   }
 
   /**
    * @param {number} lineNumber
    * @param {number=} columnNumber
-   * @return {!WebInspector.UILocation}
+   * @return {!Workspace.UILocation}
    */
   uiLocation(lineNumber, columnNumber) {
     if (typeof columnNumber === 'undefined')
       columnNumber = 0;
-    return new WebInspector.UILocation(this, lineNumber, columnNumber);
+    return new Workspace.UILocation(this, lineNumber, columnNumber);
   }
 
   /**
-   * @return {!Array<!WebInspector.UISourceCode.Message>}
+   * @return {!Array<!Workspace.UISourceCode.Message>}
    */
   messages() {
     return this._messages.slice();
   }
 
   /**
-   * @param {!WebInspector.UISourceCode.Message.Level} level
+   * @param {!Workspace.UISourceCode.Message.Level} level
    * @param {string} text
    * @param {number} lineNumber
    * @param {number=} columnNumber
-   * @return {!WebInspector.UISourceCode.Message} message
+   * @return {!Workspace.UISourceCode.Message} message
    */
   addLineMessage(level, text, lineNumber, columnNumber) {
     return this.addMessage(
-        level, text, new WebInspector.TextRange(lineNumber, columnNumber || 0, lineNumber, columnNumber || 0));
+        level, text, new Common.TextRange(lineNumber, columnNumber || 0, lineNumber, columnNumber || 0));
   }
 
   /**
-   * @param {!WebInspector.UISourceCode.Message.Level} level
+   * @param {!Workspace.UISourceCode.Message.Level} level
    * @param {string} text
-   * @param {!WebInspector.TextRange} range
-   * @return {!WebInspector.UISourceCode.Message} message
+   * @param {!Common.TextRange} range
+   * @return {!Workspace.UISourceCode.Message} message
    */
   addMessage(level, text, range) {
-    var message = new WebInspector.UISourceCode.Message(this, level, text, range);
+    var message = new Workspace.UISourceCode.Message(this, level, text, range);
     this._messages.push(message);
-    this.dispatchEventToListeners(WebInspector.UISourceCode.Events.MessageAdded, message);
+    this.dispatchEventToListeners(Workspace.UISourceCode.Events.MessageAdded, message);
     return message;
   }
 
   /**
-   * @param {!WebInspector.UISourceCode.Message} message
+   * @param {!Workspace.UISourceCode.Message} message
    */
   removeMessage(message) {
     if (this._messages.remove(message))
-      this.dispatchEventToListeners(WebInspector.UISourceCode.Events.MessageRemoved, message);
+      this.dispatchEventToListeners(Workspace.UISourceCode.Events.MessageRemoved, message);
   }
 
   removeAllMessages() {
     var messages = this._messages;
     this._messages = [];
     for (var message of messages)
-      this.dispatchEventToListeners(WebInspector.UISourceCode.Events.MessageRemoved, message);
+      this.dispatchEventToListeners(Workspace.UISourceCode.Events.MessageRemoved, message);
   }
 
   /**
    * @param {number} lineNumber
    * @param {string} type
    * @param {?} data
    */
   addLineDecoration(lineNumber, type, data) {
     var markers = this._lineDecorations.get(type);
     if (!markers) {
       markers = new Map();
       this._lineDecorations.set(type, markers);
     }
-    var marker = new WebInspector.UISourceCode.LineMarker(lineNumber, type, data);
+    var marker = new Workspace.UISourceCode.LineMarker(lineNumber, type, data);
     markers.set(lineNumber, marker);
-    this.dispatchEventToListeners(WebInspector.UISourceCode.Events.LineDecorationAdded, marker);
+    this.dispatchEventToListeners(Workspace.UISourceCode.Events.LineDecorationAdded, marker);
   }
 
   /**
    * @param {number} lineNumber
    * @param {string} type
    */
   removeLineDecoration(lineNumber, type) {
     var markers = this._lineDecorations.get(type);
     if (!markers)
       return;
     var marker = markers.get(lineNumber);
     if (!marker)
       return;
     markers.delete(lineNumber);
-    this.dispatchEventToListeners(WebInspector.UISourceCode.Events.LineDecorationRemoved, marker);
+    this.dispatchEventToListeners(Workspace.UISourceCode.Events.LineDecorationRemoved, marker);
     if (!markers.size)
       this._lineDecorations.delete(type);
   }
 
   /**
    * @param {string} type
    */
   removeAllLineDecorations(type) {
     var markers = this._lineDecorations.get(type);
     if (!markers)
       return;
     this._lineDecorations.delete(type);
     markers.forEach(marker => {
-      this.dispatchEventToListeners(WebInspector.UISourceCode.Events.LineDecorationRemoved, marker);
+      this.dispatchEventToListeners(Workspace.UISourceCode.Events.LineDecorationRemoved, marker);
     });
   }
 
   /**
    * @param {string} type
-   * @return {?Map<number, !WebInspector.UISourceCode.LineMarker>}
+   * @return {?Map<number, !Workspace.UISourceCode.LineMarker>}
    */
   lineDecorations(type) {
     return this._lineDecorations.get(type) || null;
   }
 };
 
 /** @enum {symbol} */
-WebInspector.UISourceCode.Events = {
+Workspace.UISourceCode.Events = {
   WorkingCopyChanged: Symbol('WorkingCopyChanged'),
   WorkingCopyCommitted: Symbol('WorkingCopyCommitted'),
   TitleChanged: Symbol('TitleChanged'),
   SourceMappingChanged: Symbol('SourceMappingChanged'),
   MessageAdded: Symbol('MessageAdded'),
   MessageRemoved: Symbol('MessageRemoved'),
   LineDecorationAdded: Symbol('LineDecorationAdded'),
   LineDecorationRemoved: Symbol('LineDecorationRemoved')
 };
 
 /**
  * @unrestricted
  */
-WebInspector.UILocation = class {
+Workspace.UILocation = class {
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {number} lineNumber
    * @param {number} columnNumber
    */
   constructor(uiSourceCode, lineNumber, columnNumber) {
     this.uiSourceCode = uiSourceCode;
     this.lineNumber = lineNumber;
     this.columnNumber = columnNumber;
   }
 
   /**
@@ skipping 15 matching lines @@
   }
 
   /**
    * @return {string}
    */
   toUIString() {
     return this.uiSourceCode.url() + ':' + (this.lineNumber + 1);
   }
 
   /**
-   * @param {!WebInspector.UILocation} location1
-   * @param {!WebInspector.UILocation} location2
+   * @param {!Workspace.UILocation} location1
+   * @param {!Workspace.UILocation} location2
    * @return {number}
    */
   static comparator(location1, location2) {
     return location1.compareTo(location2);
   }
 
   /**
-   * @param {!WebInspector.UILocation} other
+   * @param {!Workspace.UILocation} other
    * @return {number}
    */
   compareTo(other) {
     if (this.uiSourceCode.url() !== other.uiSourceCode.url())
       return this.uiSourceCode.url() > other.uiSourceCode.url() ? 1 : -1;
     if (this.lineNumber !== other.lineNumber)
       return this.lineNumber - other.lineNumber;
     return this.columnNumber - other.columnNumber;
   }
 };
 
 /**
- * @implements {WebInspector.ContentProvider}
+ * @implements {Common.ContentProvider}
  * @unrestricted
  */
-WebInspector.Revision = class {
+Workspace.Revision = class {
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {?string|undefined} content
    * @param {!Date} timestamp
    */
   constructor(uiSourceCode, content, timestamp) {
     this._uiSourceCode = uiSourceCode;
     this._content = content;
     this._timestamp = timestamp;
   }
 
   /**
-   * @return {!WebInspector.UISourceCode}
+   * @return {!Workspace.UISourceCode}
    */
   get uiSourceCode() {
     return this._uiSourceCode;
   }
 
   /**
    * @return {!Date}
    */
   get timestamp() {
     return this._timestamp;
   }
 
   /**
    * @return {?string}
    */
   get content() {
     return this._content || null;
   }
 
   /**
    * @return {!Promise}
    */
   revertToThis() {
     /**
      * @param {?string} content
-     * @this {WebInspector.Revision}
+     * @this {Workspace.Revision}
      */
     function revert(content) {
       if (content && this._uiSourceCode._content !== content)
         this._uiSourceCode.addRevision(content);
     }
-    WebInspector.userMetrics.actionTaken(WebInspector.UserMetrics.Action.RevisionApplied);
+    Host.userMetrics.actionTaken(Host.UserMetrics.Action.RevisionApplied);
     return this.requestContent().then(revert.bind(this));
   }
 
   /**
    * @override
    * @return {string}
    */
   contentURL() {
     return this._uiSourceCode.url();
   }
 
   /**
    * @override
-   * @return {!WebInspector.ResourceType}
+   * @return {!Common.ResourceType}
    */
   contentType() {
     return this._uiSourceCode.contentType();
   }
 
   /**
    * @override
    * @return {!Promise<?string>}
    */
   requestContent() {
     return Promise.resolve(/** @type {?string} */ (this._content || ''));
   }
 
   /**
    * @override
    * @param {string} query
    * @param {boolean} caseSensitive
    * @param {boolean} isRegex
-   * @param {function(!Array.<!WebInspector.ContentProvider.SearchMatch>)} callback
+   * @param {function(!Array.<!Common.ContentProvider.SearchMatch>)} callback
    */
   searchInContent(query, caseSensitive, isRegex, callback) {
     callback([]);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.UISourceCode.Message = class {
+Workspace.UISourceCode.Message = class {
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
-   * @param {!WebInspector.UISourceCode.Message.Level} level
+   * @param {!Workspace.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode.Message.Level} level
    * @param {string} text
-   * @param {!WebInspector.TextRange} range
+   * @param {!Common.TextRange} range
    */
   constructor(uiSourceCode, level, text, range) {
     this._uiSourceCode = uiSourceCode;
     this._level = level;
     this._text = text;
     this._range = range;
   }
 
   /**
-   * @return {!WebInspector.UISourceCode}
+   * @return {!Workspace.UISourceCode}
    */
   uiSourceCode() {
     return this._uiSourceCode;
   }
 
   /**
-   * @return {!WebInspector.UISourceCode.Message.Level}
+   * @return {!Workspace.UISourceCode.Message.Level}
    */
   level() {
     return this._level;
   }
 
   /**
    * @return {string}
    */
   text() {
     return this._text;
   }
 
   /**
-   * @return {!WebInspector.TextRange}
+   * @return {!Common.TextRange}
    */
   range() {
     return this._range;
   }
 
   /**
    * @return {number}
    */
   lineNumber() {
     return this._range.startLine;
   }
 
   /**
    * @return {(number|undefined)}
    */
   columnNumber() {
     return this._range.startColumn;
   }
 
   /**
-   * @param {!WebInspector.UISourceCode.Message} another
+   * @param {!Workspace.UISourceCode.Message} another
    * @return {boolean}
    */
   isEqual(another) {
     return this._uiSourceCode === another._uiSourceCode && this.text() === another.text() &&
         this.level() === another.level() && this.range().equal(another.range());
   }
 
   remove() {
     this._uiSourceCode.removeMessage(this);
   }
 };
 
 /**
  * @enum {string}
  */
-WebInspector.UISourceCode.Message.Level = {
+Workspace.UISourceCode.Message.Level = {
   Error: 'Error',
   Warning: 'Warning'
 };
 
 /**
  * @unrestricted
  */
-WebInspector.UISourceCode.LineMarker = class {
+Workspace.UISourceCode.LineMarker = class {
   /**
    * @param {number} line
    * @param {string} type
    * @param {?} data
    */
   constructor(line, type, data) {
     this._line = line;
     this._type = type;
     this._data = data;
   }
@@ skipping 16 matching lines @@
    * @return {*}
    */
   data() {
     return this._data;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.UISourceCodeMetadata = class {
+Workspace.UISourceCodeMetadata = class {
   /**
    * @param {?Date} modificationTime
    * @param {?number} contentSize
    */
   constructor(modificationTime, contentSize) {
     this.modificationTime = modificationTime;
     this.contentSize = contentSize;
   }
 };