DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/workspace/Workspace.js

 /*
  * Copyright (C) 2012 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 12 matching lines @@
  * 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.
  */
 /**
  * @interface
  */
-WebInspector.ProjectSearchConfig = function() {};
+Workspace.ProjectSearchConfig = function() {};
 
-WebInspector.ProjectSearchConfig.prototype = {
+Workspace.ProjectSearchConfig.prototype = {
   /**
    * @return {string}
    */
   query: function() {},
 
   /**
    * @return {boolean}
    */
   ignoreCase: function() {},
 
@@ skipping 10 matching lines @@
   /**
    * @param {string} filePath
    * @return {boolean}
    */
   filePathMatchesFileQuery: function(filePath) {}
 };
 
 /**
  * @interface
  */
-WebInspector.Project = function() {};
+Workspace.Project = function() {};
 
 /**
- * @param {!WebInspector.Project} project
+ * @param {!Workspace.Project} project
  * @return {boolean}
  */
-WebInspector.Project.isServiceProject = function(project) {
-  return project.type() === WebInspector.projectTypes.Debugger ||
-      project.type() === WebInspector.projectTypes.Formatter || project.type() === WebInspector.projectTypes.Service;
+Workspace.Project.isServiceProject = function(project) {
+  return project.type() === Workspace.projectTypes.Debugger ||
+      project.type() === Workspace.projectTypes.Formatter || project.type() === Workspace.projectTypes.Service;
 };
 
-WebInspector.Project.prototype = {
+Workspace.Project.prototype = {
   /**
-   * @return {!WebInspector.Workspace}
+   * @return {!Workspace.Workspace}
    */
   workspace: function() {},
 
   /**
    * @return {string}
    */
   id: function() {},
 
   /**
    * @return {string}
    */
   type: function() {},
 
   /**
    * @return {string}
    */
   displayName: function() {},
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
-   * @return {!Promise<?WebInspector.UISourceCodeMetadata>}
+   * @param {!Workspace.UISourceCode} uiSourceCode
+   * @return {!Promise<?Workspace.UISourceCodeMetadata>}
    */
   requestMetadata: function(uiSourceCode) {},
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {function(?string)} callback
    */
   requestFileContent: function(uiSourceCode, callback) {},
 
   /**
    * @return {boolean}
    */
   canSetFileContent: function() {},
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {string} newContent
    * @param {function(?string)} callback
    */
   setFileContent: function(uiSourceCode, newContent, callback) {},
 
   /**
    * @return {boolean}
    */
   canRename: function() {},
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {string} newName
-   * @param {function(boolean, string=, string=, !WebInspector.ResourceType=)} callback
+   * @param {function(boolean, string=, string=, !Common.ResourceType=)} callback
    */
   rename: function(uiSourceCode, newName, callback) {},
 
   /**
    * @param {string} path
    */
   excludeFolder: function(path) {},
 
   /**
    * @param {string} path
    * @param {?string} name
    * @param {string} content
-   * @param {function(?WebInspector.UISourceCode)} callback
+   * @param {function(?Workspace.UISourceCode)} callback
    */
   createFile: function(path, name, content, callback) {},
 
   /**
    * @param {string} path
    */
   deleteFile: function(path) {},
 
   remove: function() {},
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {string} query
    * @param {boolean} caseSensitive
    * @param {boolean} isRegex
-   * @param {function(!Array.<!WebInspector.ContentProvider.SearchMatch>)} callback
+   * @param {function(!Array.<!Common.ContentProvider.SearchMatch>)} callback
    */
   searchInFileContent: function(uiSourceCode, query, caseSensitive, isRegex, callback) {},
 
   /**
-   * @param {!WebInspector.ProjectSearchConfig} searchConfig
+   * @param {!Workspace.ProjectSearchConfig} searchConfig
    * @param {!Array.<string>} filesMathingFileQuery
-   * @param {!WebInspector.Progress} progress
+   * @param {!Common.Progress} progress
    * @param {function(!Array.<string>)} callback
    */
   findFilesMatchingSearchRequest: function(searchConfig, filesMathingFileQuery, progress, callback) {},
 
   /**
-   * @param {!WebInspector.Progress} progress
+   * @param {!Common.Progress} progress
    */
   indexContent: function(progress) {},
 
   /**
    * @param {string} url
-   * @return {?WebInspector.UISourceCode}
+   * @return {?Workspace.UISourceCode}
    */
   uiSourceCodeForURL: function(url) {},
 
   /**
-   * @return {!Array.<!WebInspector.UISourceCode>}
+   * @return {!Array.<!Workspace.UISourceCode>}
    */
   uiSourceCodes: function() {}
 };
 
 /**
  * @enum {string}
  */
-WebInspector.projectTypes = {
+Workspace.projectTypes = {
   Debugger: 'debugger',
   Formatter: 'formatter',
   Network: 'network',
   Snippets: 'snippets',
   FileSystem: 'filesystem',
   ContentScripts: 'contentscripts',
   Service: 'service'
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ProjectStore = class {
+Workspace.ProjectStore = class {
   /**
-   * @param {!WebInspector.Workspace} workspace
+   * @param {!Workspace.Workspace} workspace
    * @param {string} id
-   * @param {!WebInspector.projectTypes} type
+   * @param {!Workspace.projectTypes} type
    * @param {string} displayName
    */
   constructor(workspace, id, type, displayName) {
     this._workspace = workspace;
     this._id = id;
     this._type = type;
     this._displayName = displayName;
 
-    /** @type {!Map.<string, !{uiSourceCode: !WebInspector.UISourceCode, index: number}>} */
+    /** @type {!Map.<string, !{uiSourceCode: !Workspace.UISourceCode, index: number}>} */
     this._uiSourceCodesMap = new Map();
-    /** @type {!Array.<!WebInspector.UISourceCode>} */
+    /** @type {!Array.<!Workspace.UISourceCode>} */
     this._uiSourceCodesList = [];
 
-    this._project = /** @type {!WebInspector.Project} */ (this);
+    this._project = /** @type {!Workspace.Project} */ (this);
   }
 
   /**
    * @return {string}
    */
   id() {
     return this._id;
   }
 
   /**
    * @return {string}
    */
   type() {
     return this._type;
   }
 
   /**
    * @return {string}
    */
   displayName() {
     return this._displayName;
   }
 
   /**
-   * @return {!WebInspector.Workspace}
+   * @return {!Workspace.Workspace}
    */
   workspace() {
     return this._workspace;
   }
 
   /**
    * @param {string} url
-   * @param {!WebInspector.ResourceType} contentType
-   * @return {!WebInspector.UISourceCode}
+   * @param {!Common.ResourceType} contentType
+   * @return {!Workspace.UISourceCode}
    */
   createUISourceCode(url, contentType) {
-    return new WebInspector.UISourceCode(this._project, url, contentType);
+    return new Workspace.UISourceCode(this._project, url, contentType);
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {boolean=} replace
    * @return {boolean}
    */
   addUISourceCode(uiSourceCode, replace) {
     var url = uiSourceCode.url();
     if (this.uiSourceCodeForURL(url)) {
       if (replace)
         this.removeUISourceCode(url);
       else
         return false;
     }
     this._uiSourceCodesMap.set(url, {uiSourceCode: uiSourceCode, index: this._uiSourceCodesList.length});
     this._uiSourceCodesList.push(uiSourceCode);
-    this._workspace.dispatchEventToListeners(WebInspector.Workspace.Events.UISourceCodeAdded, uiSourceCode);
+    this._workspace.dispatchEventToListeners(Workspace.Workspace.Events.UISourceCodeAdded, uiSourceCode);
     return true;
   }
 
   /**
    * @param {string} url
    */
   removeUISourceCode(url) {
     var uiSourceCode = this.uiSourceCodeForURL(url);
     if (!uiSourceCode)
       return;
 
     var entry = this._uiSourceCodesMap.get(url);
     var movedUISourceCode = this._uiSourceCodesList[this._uiSourceCodesList.length - 1];
     this._uiSourceCodesList[entry.index] = movedUISourceCode;
     var movedEntry = this._uiSourceCodesMap.get(movedUISourceCode.url());
     movedEntry.index = entry.index;
     this._uiSourceCodesList.splice(this._uiSourceCodesList.length - 1, 1);
     this._uiSourceCodesMap.delete(url);
-    this._workspace.dispatchEventToListeners(WebInspector.Workspace.Events.UISourceCodeRemoved, entry.uiSourceCode);
+    this._workspace.dispatchEventToListeners(Workspace.Workspace.Events.UISourceCodeRemoved, entry.uiSourceCode);
   }
 
   removeProject() {
     this._workspace._removeProject(this._project);
     this._uiSourceCodesMap = new Map();
     this._uiSourceCodesList = [];
   }
 
   /**
    * @param {string} url
-   * @return {?WebInspector.UISourceCode}
+   * @return {?Workspace.UISourceCode}
    */
   uiSourceCodeForURL(url) {
     var entry = this._uiSourceCodesMap.get(url);
     return entry ? entry.uiSourceCode : null;
   }
 
   /**
-   * @return {!Array.<!WebInspector.UISourceCode>}
+   * @return {!Array.<!Workspace.UISourceCode>}
    */
   uiSourceCodes() {
     return this._uiSourceCodesList;
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {string} newName
    */
   renameUISourceCode(uiSourceCode, newName) {
     var oldPath = uiSourceCode.url();
     var newPath = uiSourceCode.parentURL() ? uiSourceCode.parentURL() + '/' + newName : newName;
     var value =
-        /** @type {!{uiSourceCode: !WebInspector.UISourceCode, index: number}} */ (this._uiSourceCodesMap.get(oldPath));
+        /** @type {!{uiSourceCode: !Workspace.UISourceCode, index: number}} */ (this._uiSourceCodesMap.get(oldPath));
     this._uiSourceCodesMap.set(newPath, value);
     this._uiSourceCodesMap.delete(oldPath);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.Workspace = class extends WebInspector.Object {
+Workspace.Workspace = class extends Common.Object {
   constructor() {
     super();
-    /** @type {!Map<string, !WebInspector.Project>} */
+    /** @type {!Map<string, !Workspace.Project>} */
     this._projects = new Map();
     this._hasResourceContentTrackingExtensions = false;
   }
 
   /**
    * @param {string} projectId
    * @param {string} url
-   * @return {?WebInspector.UISourceCode}
+   * @return {?Workspace.UISourceCode}
    */
   uiSourceCode(projectId, url) {
     var project = this._projects.get(projectId);
     return project ? project.uiSourceCodeForURL(url) : null;
   }
 
   /**
    * @param {string} url
-   * @return {?WebInspector.UISourceCode}
+   * @return {?Workspace.UISourceCode}
    */
   uiSourceCodeForURL(url) {
     for (var project of this._projects.values()) {
       var uiSourceCode = project.uiSourceCodeForURL(url);
       if (uiSourceCode)
         return uiSourceCode;
     }
     return null;
   }
 
   /**
    * @param {string} type
-   * @return {!Array.<!WebInspector.UISourceCode>}
+   * @return {!Array.<!Workspace.UISourceCode>}
    */
   uiSourceCodesForProjectType(type) {
     var result = [];
     for (var project of this._projects.values()) {
       if (project.type() === type)
         result = result.concat(project.uiSourceCodes());
     }
     return result;
   }
 
   /**
-   * @param {!WebInspector.Project} project
+   * @param {!Workspace.Project} project
    */
   addProject(project) {
     console.assert(!this._projects.has(project.id()), `A project with id ${project.id()} already exists!`);
     this._projects.set(project.id(), project);
-    this.dispatchEventToListeners(WebInspector.Workspace.Events.ProjectAdded, project);
+    this.dispatchEventToListeners(Workspace.Workspace.Events.ProjectAdded, project);
   }
 
   /**
-   * @param {!WebInspector.Project} project
+   * @param {!Workspace.Project} project
    */
   _removeProject(project) {
     this._projects.delete(project.id());
-    this.dispatchEventToListeners(WebInspector.Workspace.Events.ProjectRemoved, project);
+    this.dispatchEventToListeners(Workspace.Workspace.Events.ProjectRemoved, project);
   }
 
   /**
    * @param {string} projectId
-   * @return {?WebInspector.Project}
+   * @return {?Workspace.Project}
    */
   project(projectId) {
     return this._projects.get(projectId) || null;
   }
 
   /**
-   * @return {!Array.<!WebInspector.Project>}
+   * @return {!Array.<!Workspace.Project>}
    */
   projects() {
     return this._projects.valuesArray();
   }
 
   /**
    * @param {string} type
-   * @return {!Array.<!WebInspector.Project>}
+   * @return {!Array.<!Workspace.Project>}
    */
   projectsForType(type) {
     function filterByType(project) {
       return project.type() === type;
     }
     return this.projects().filter(filterByType);
   }
 
   /**
-   * @return {!Array.<!WebInspector.UISourceCode>}
+   * @return {!Array.<!Workspace.UISourceCode>}
    */
   uiSourceCodes() {
     var result = [];
     for (var project of this._projects.values())
       result = result.concat(project.uiSourceCodes());
     return result;
   }
 
   /**
    * @param {boolean} hasExtensions
    */
   setHasResourceContentTrackingExtensions(hasExtensions) {
     this._hasResourceContentTrackingExtensions = hasExtensions;
   }
 
   /**
    * @return {boolean}
    */
   hasResourceContentTrackingExtensions() {
     return this._hasResourceContentTrackingExtensions;
   }
 };
 
 /** @enum {symbol} */
-WebInspector.Workspace.Events = {
+Workspace.Workspace.Events = {
   UISourceCodeAdded: Symbol('UISourceCodeAdded'),
   UISourceCodeRemoved: Symbol('UISourceCodeRemoved'),
   WorkingCopyChanged: Symbol('WorkingCopyChanged'),
   WorkingCopyCommitted: Symbol('WorkingCopyCommitted'),
   WorkingCopyCommittedByUser: Symbol('WorkingCopyCommittedByUser'),
   ProjectAdded: Symbol('ProjectAdded'),
   ProjectRemoved: Symbol('ProjectRemoved')
 };
 
 /**
- * @type {!WebInspector.Workspace}
+ * @type {!Workspace.Workspace}
  */
-WebInspector.workspace;
+Workspace.workspace;