DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/bindings/ContentProviderBasedProject.js

 /*
  * Copyright (C) 2013 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 11 matching lines @@
  * 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.Project}
+ * @implements {Workspace.Project}
  * @unrestricted
  */
-WebInspector.ContentProviderBasedProject = class extends WebInspector.ProjectStore {
+Bindings.ContentProviderBasedProject = class extends Workspace.ProjectStore {
   /**
-   * @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) {
     super(workspace, id, type, displayName);
-    /** @type {!Object.<string, !WebInspector.ContentProvider>} */
+    /** @type {!Object.<string, !Common.ContentProvider>} */
     this._contentProviders = {};
     workspace.addProject(this);
   }
 
   /**
    * @override
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {function(?string)} callback
    */
   requestFileContent(uiSourceCode, callback) {
     var contentProvider = this._contentProviders[uiSourceCode.url()];
     contentProvider.requestContent().then(callback);
   }
 
   /**
    * @override
-   * @param {!WebInspector.UISourceCode} uiSourceCode
-   * @return {!Promise<?WebInspector.UISourceCodeMetadata>}
+   * @param {!Workspace.UISourceCode} uiSourceCode
+   * @return {!Promise<?Workspace.UISourceCodeMetadata>}
    */
   requestMetadata(uiSourceCode) {
-    return Promise.resolve(uiSourceCode[WebInspector.ContentProviderBasedProject._metadata]);
+    return Promise.resolve(uiSourceCode[Bindings.ContentProviderBasedProject._metadata]);
   }
 
   /**
    * @override
    * @return {boolean}
    */
   canSetFileContent() {
     return false;
   }
 
   /**
    * @override
-   * @param {!WebInspector.UISourceCode} uiSourceCode
+   * @param {!Workspace.UISourceCode} uiSourceCode
    * @param {string} newContent
    * @param {function(?string)} callback
    */
   setFileContent(uiSourceCode, newContent, callback) {
     callback(null);
   }
 
   /**
    * @override
    * @return {boolean}
    */
   canRename() {
     return false;
   }
 
   /**
    * @override
-   * @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(uiSourceCode, newName, callback) {
     var path = uiSourceCode.url();
     this.performRename(path, newName, innerCallback.bind(this));
 
     /**
      * @param {boolean} success
      * @param {string=} newName
-     * @this {WebInspector.ContentProviderBasedProject}
+     * @this {Bindings.ContentProviderBasedProject}
      */
     function innerCallback(success, newName) {
       if (success && newName) {
         var copyOfPath = path.split('/');
         copyOfPath[copyOfPath.length - 1] = newName;
         var newPath = copyOfPath.join('/');
         this._contentProviders[newPath] = this._contentProviders[path];
         delete this._contentProviders[path];
         this.renameUISourceCode(uiSourceCode, newName);
       }
       callback(success, newName);
     }
   }
 
   /**
    * @override
    * @param {string} path
    */
   excludeFolder(path) {
   }
 
   /**
    * @override
    * @param {string} path
    * @param {?string} name
    * @param {string} content
-   * @param {function(?WebInspector.UISourceCode)} callback
+   * @param {function(?Workspace.UISourceCode)} callback
    */
   createFile(path, name, content, callback) {
   }
 
   /**
    * @override
    * @param {string} path
    */
   deleteFile(path) {
   }
 
   /**
    * @override
    */
   remove() {
   }
 
   /**
    * @param {string} path
    * @param {string} newName
    * @param {function(boolean, string=)} callback
    */
   performRename(path, newName, callback) {
     callback(false);
   }
 
   /**
    * @override
-   * @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(uiSourceCode, query, caseSensitive, isRegex, callback) {
     var contentProvider = this._contentProviders[uiSourceCode.url()];
     contentProvider.searchInContent(query, caseSensitive, isRegex, callback);
   }
 
   /**
    * @override
-   * @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(searchConfig, filesMathingFileQuery, progress, callback) {
     var result = [];
     var paths = filesMathingFileQuery;
     var totalCount = paths.length;
     if (totalCount === 0) {
       // searchInContent should call back later.
       setTimeout(doneCallback, 0);
       return;
     }
 
     var barrier = new CallbackBarrier();
     progress.setTotalWork(paths.length);
     for (var i = 0; i < paths.length; ++i)
       searchInContent.call(this, paths[i], barrier.createCallback(searchInContentCallback.bind(null, paths[i])));
     barrier.callWhenDone(doneCallback);
 
     /**
      * @param {string} path
      * @param {function(boolean)} callback
-     * @this {WebInspector.ContentProviderBasedProject}
+     * @this {Bindings.ContentProviderBasedProject}
      */
     function searchInContent(path, callback) {
       var queriesToRun = searchConfig.queries().slice();
       searchNextQuery.call(this);
 
       /**
-       * @this {WebInspector.ContentProviderBasedProject}
+       * @this {Bindings.ContentProviderBasedProject}
        */
       function searchNextQuery() {
         if (!queriesToRun.length) {
           callback(true);
           return;
         }
         var query = queriesToRun.shift();
         this._contentProviders[path].searchInContent(
             query, !searchConfig.ignoreCase(), searchConfig.isRegex(), contentCallback.bind(this));
       }
 
       /**
-       * @param {!Array.<!WebInspector.ContentProvider.SearchMatch>} searchMatches
-       * @this {WebInspector.ContentProviderBasedProject}
+       * @param {!Array.<!Common.ContentProvider.SearchMatch>} searchMatches
+       * @this {Bindings.ContentProviderBasedProject}
        */
       function contentCallback(searchMatches) {
         if (!searchMatches.length) {
           callback(false);
           return;
         }
         searchNextQuery.call(this);
       }
     }
 
     /**
      * @param {string} path
      * @param {boolean} matches
      */
     function searchInContentCallback(path, matches) {
       if (matches)
         result.push(path);
       progress.worked(1);
     }
 
     function doneCallback() {
       callback(result);
       progress.done();
     }
   }
 
   /**
    * @override
-   * @param {!WebInspector.Progress} progress
+   * @param {!Common.Progress} progress
    */
   indexContent(progress) {
     setImmediate(progress.done.bind(progress));
   }
 
   /**
-   * @param {!WebInspector.UISourceCode} uiSourceCode
-   * @param {!WebInspector.ContentProvider} contentProvider
-   * @param {?WebInspector.UISourceCodeMetadata} metadata
+   * @param {!Workspace.UISourceCode} uiSourceCode
+   * @param {!Common.ContentProvider} contentProvider
+   * @param {?Workspace.UISourceCodeMetadata} metadata
    */
   addUISourceCodeWithProvider(uiSourceCode, contentProvider, metadata) {
     this._contentProviders[uiSourceCode.url()] = contentProvider;
-    uiSourceCode[WebInspector.ContentProviderBasedProject._metadata] = metadata;
+    uiSourceCode[Bindings.ContentProviderBasedProject._metadata] = metadata;
     this.addUISourceCode(uiSourceCode, true);
   }
 
   /**
    * @param {string} url
-   * @param {!WebInspector.ContentProvider} contentProvider
-   * @return {!WebInspector.UISourceCode}
+   * @param {!Common.ContentProvider} contentProvider
+   * @return {!Workspace.UISourceCode}
    */
   addContentProvider(url, contentProvider) {
     var uiSourceCode = this.createUISourceCode(url, contentProvider.contentType());
     this.addUISourceCodeWithProvider(uiSourceCode, contentProvider, null);
     return uiSourceCode;
   }
 
   /**
    * @param {string} path
    */
   removeFile(path) {
     delete this._contentProviders[path];
     this.removeUISourceCode(path);
   }
 
   reset() {
     this._contentProviders = {};
     this.removeProject();
     this.workspace().addProject(this);
   }
 
   dispose() {
     this._contentProviders = {};
     this.removeProject();
   }
 };
 
-WebInspector.ContentProviderBasedProject._metadata = Symbol('ContentProviderBasedProject.Metadata');
+Bindings.ContentProviderBasedProject._metadata = Symbol('ContentProviderBasedProject.Metadata');