DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/bindings/TempFile.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 14 matching lines @@
  * 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.
  */
 window.requestFileSystem = window.requestFileSystem || window.webkitRequestFileSystem;
 
 /**
  * @unrestricted
  */
-WebInspector.TempFile = class {
+Bindings.TempFile = class {
   constructor() {
     this._fileEntry = null;
     this._writer = null;
   }
 
   /**
    * @param {string} dirPath
    * @param {string} name
-   * @return {!Promise.<!WebInspector.TempFile>}
+   * @return {!Promise.<!Bindings.TempFile>}
    */
   static create(dirPath, name) {
-    var file = new WebInspector.TempFile();
+    var file = new Bindings.TempFile();
 
     function requestTempFileSystem() {
       return new Promise(window.requestFileSystem.bind(window, window.TEMPORARY, 10));
     }
 
     /**
      * @param {!FileSystem} fs
      */
     function getDirectoryEntry(fs) {
       return new Promise(fs.root.getDirectory.bind(fs.root, dirPath, {create: true}));
@@ skipping 42 matching lines @@
 
       function onTruncateError(e) {
         writer.onwriteend = null;
         writer.onerror = null;
         throw e;
       }
 
       return new Promise(truncate).then(didTruncate, onTruncateError);
     }
 
-    return WebInspector.TempFile.ensureTempStorageCleared()
+    return Bindings.TempFile.ensureTempStorageCleared()
         .then(requestTempFileSystem)
         .then(getDirectoryEntry)
         .then(getFileEntry)
         .then(createFileWriter)
         .then(truncateFile);
   }
 
   /**
    * @return {!Promise.<undefined>}
    */
   static ensureTempStorageCleared() {
-    if (!WebInspector.TempFile._storageCleanerPromise) {
-      WebInspector.TempFile._storageCleanerPromise =
-          WebInspector.serviceManager.createAppService('utility_shared_worker', 'TempStorage', true).then(service => {
+    if (!Bindings.TempFile._storageCleanerPromise) {
+      Bindings.TempFile._storageCleanerPromise =
+          Services.serviceManager.createAppService('utility_shared_worker', 'TempStorage', true).then(service => {
             if (service)
               return service.send('clear');
           });
     }
-    return WebInspector.TempFile._storageCleanerPromise;
+    return Bindings.TempFile._storageCleanerPromise;
   }
 
   /**
    * @param {!Array.<string>} strings
    * @param {function(number)} callback
    */
   write(strings, callback) {
     var blob = new Blob(strings, {type: 'text/plain'});
     this._writer.onerror = function(e) {
-      WebInspector.console.error('Failed to write into a temp file: ' + e.target.error.message);
+      Common.console.error('Failed to write into a temp file: ' + e.target.error.message);
       callback(-1);
     };
     this._writer.onwriteend = function(e) {
       callback(e.target.length);
     };
     this._writer.write(blob);
   }
 
   finishWriting() {
     this._writer = null;
@@ skipping 20 matching lines @@
 
       if (typeof startOffset === 'number' || typeof endOffset === 'number')
         file = file.slice(/** @type {number} */ (startOffset), /** @type {number} */ (endOffset));
       /**
        * @this {FileReader}
        */
       reader.onloadend = function(e) {
         callback(/** @type {?string} */ (this.result));
       };
       reader.onerror = function(error) {
-        WebInspector.console.error('Failed to read from temp file: ' + error.message);
+        Common.console.error('Failed to read from temp file: ' + error.message);
       };
       reader.readAsText(file);
     }
     function didFailToGetFile(error) {
-      WebInspector.console.error('Failed to load temp file: ' + error.message);
+      Common.console.error('Failed to load temp file: ' + error.message);
       callback(null);
     }
     this._fileEntry.file(didGetFile, didFailToGetFile);
   }
 
   /**
-   * @param {!WebInspector.OutputStream} outputStream
-   * @param {!WebInspector.OutputStreamDelegate} delegate
+   * @param {!Common.OutputStream} outputStream
+   * @param {!Bindings.OutputStreamDelegate} delegate
    */
   copyToOutputStream(outputStream, delegate) {
     /**
      * @param {!File} file
      */
     function didGetFile(file) {
-      var reader = new WebInspector.ChunkedFileReader(file, 10 * 1000 * 1000, delegate);
+      var reader = new Bindings.ChunkedFileReader(file, 10 * 1000 * 1000, delegate);
       reader.start(outputStream);
     }
 
     function didFailToGetFile(error) {
-      WebInspector.console.error('Failed to load temp file: ' + error.message);
+      Common.console.error('Failed to load temp file: ' + error.message);
       outputStream.close();
     }
 
     this._fileEntry.file(didGetFile, didFailToGetFile);
   }
 
   remove() {
     if (this._fileEntry)
       this._fileEntry.remove(function() {});
   }
 };
 
 
 /**
  * @unrestricted
  */
-WebInspector.DeferredTempFile = class {
+Bindings.DeferredTempFile = class {
   /**
    * @param {string} dirPath
    * @param {string} name
    */
   constructor(dirPath, name) {
     /** @type {!Array.<!{strings: !Array.<string>, callback: ?function(number)}>} */
     this._chunks = [];
     this._tempFile = null;
     this._isWriting = false;
     this._finishCallback = null;
     this._finishedWriting = false;
     this._callsPendingOpen = [];
     this._pendingReads = [];
-    WebInspector.TempFile.create(dirPath, name)
+    Bindings.TempFile.create(dirPath, name)
         .then(this._didCreateTempFile.bind(this), this._failedToCreateTempFile.bind(this));
   }
 
   /**
    * @param {!Array.<string>} strings
    * @param {function(number)=} callback
    */
   write(strings, callback) {
     if (this._finishCallback)
       throw new Error('No writes are allowed after close.');
     this._chunks.push({strings: strings, callback: callback || null});
     if (this._tempFile && !this._isWriting)
       this._writeNextChunk();
   }
 
   /**
-   * @param {function(?WebInspector.TempFile)} callback
+   * @param {function(?Bindings.TempFile)} callback
    */
   finishWriting(callback) {
     this._finishCallback = callback;
     if (this._finishedWriting)
       callback(this._tempFile);
     else if (!this._isWriting && !this._chunks.length)
       this._notifyFinished();
   }
 
   /**
    * @param {*} e
    */
   _failedToCreateTempFile(e) {
-    WebInspector.console.error('Failed to create temp file ' + e.code + ' : ' + e.message);
+    Common.console.error('Failed to create temp file ' + e.code + ' : ' + e.message);
     this._notifyFinished();
   }
 
   /**
-   * @param {!WebInspector.TempFile} tempFile
+   * @param {!Bindings.TempFile} tempFile
    */
   _didCreateTempFile(tempFile) {
     this._tempFile = tempFile;
     var callsPendingOpen = this._callsPendingOpen;
     this._callsPendingOpen = null;
     for (var i = 0; i < callsPendingOpen.length; ++i)
       callsPendingOpen[i]();
     if (this._chunks.length)
       this._writeNextChunk();
   }
@@ skipping 56 matching lines @@
       return;
     }
     if (!this._tempFile) {
       callback(null);
       return;
     }
     this._tempFile.readRange(startOffset, endOffset, callback);
   }
 
   /**
-   * @param {!WebInspector.OutputStream} outputStream
-   * @param {!WebInspector.OutputStreamDelegate} delegate
+   * @param {!Common.OutputStream} outputStream
+   * @param {!Bindings.OutputStreamDelegate} delegate
    */
   copyToOutputStream(outputStream, delegate) {
     if (!this._finishedWriting) {
       this._pendingReads.push(this.copyToOutputStream.bind(this, outputStream, delegate));
       return;
     }
     if (this._tempFile)
       this._tempFile.copyToOutputStream(outputStream, delegate);
   }
 
   remove() {
     if (this._callsPendingOpen) {
       this._callsPendingOpen.push(this.remove.bind(this));
       return;
     }
     if (this._tempFile)
       this._tempFile.remove();
     this._tempFile = null;
   }
 };
 
 
 /**
- * @implements {WebInspector.BackingStorage}
+ * @implements {SDK.BackingStorage}
  * @unrestricted
  */
-WebInspector.TempFileBackingStorage = class {
+Bindings.TempFileBackingStorage = class {
   /**
    * @param {string} dirName
    */
   constructor(dirName) {
     this._dirName = dirName;
     this.reset();
   }
 
   /**
    * @override
    * @param {string} string
    */
   appendString(string) {
     this._strings.push(string);
     this._stringsLength += string.length;
     var flushStringLength = 10 * 1024 * 1024;
     if (this._stringsLength > flushStringLength)
       this._flush(false);
   }
 
   /**
    * @override
    * @param {string} string
    * @return {function():!Promise.<?string>}
    */
   appendAccessibleString(string) {
     this._flush(false);
     this._strings.push(string);
-    var chunk = /** @type {!WebInspector.TempFileBackingStorage.Chunk} */ (this._flush(true));
+    var chunk = /** @type {!Bindings.TempFileBackingStorage.Chunk} */ (this._flush(true));
 
     /**
-     * @param {!WebInspector.TempFileBackingStorage.Chunk} chunk
-     * @param {!WebInspector.DeferredTempFile} file
+     * @param {!Bindings.TempFileBackingStorage.Chunk} chunk
+     * @param {!Bindings.DeferredTempFile} file
      * @return {!Promise.<?string>}
      */
     function readString(chunk, file) {
       if (chunk.string)
         return /** @type {!Promise.<?string>} */ (Promise.resolve(chunk.string));
 
       console.assert(chunk.endOffset);
       if (!chunk.endOffset)
         return Promise.reject('Nor string nor offset to the string in the file were found.');
 
       /**
        * @param {function(?string)} fulfill
        * @param {function(*)} reject
        */
       function readRange(fulfill, reject) {
         // FIXME: call reject for null strings.
         file.readRange(chunk.startOffset, chunk.endOffset, fulfill);
       }
 
       return new Promise(readRange);
     }
 
     return readString.bind(null, chunk, this._file);
   }
 
   /**
    * @param {boolean} createChunk
-   * @return {?WebInspector.TempFileBackingStorage.Chunk}
+   * @return {?Bindings.TempFileBackingStorage.Chunk}
    */
   _flush(createChunk) {
     if (!this._strings.length)
       return null;
 
     var chunk = null;
     if (createChunk) {
       console.assert(this._strings.length === 1);
       chunk = {string: this._strings[0], startOffset: 0, endOffset: 0};
     }
 
     /**
-     * @this {WebInspector.TempFileBackingStorage}
-     * @param {?WebInspector.TempFileBackingStorage.Chunk} chunk
+     * @this {Bindings.TempFileBackingStorage}
+     * @param {?Bindings.TempFileBackingStorage.Chunk} chunk
      * @param {number} fileSize
      */
     function didWrite(chunk, fileSize) {
       if (fileSize === -1)
         return;
       if (chunk) {
         chunk.startOffset = this._fileSize;
         chunk.endOffset = fileSize;
         chunk.string = null;
       }
@@ skipping 13 matching lines @@
     this._flush(false);
     this._file.finishWriting(function() {});
   }
 
   /**
    * @override
    */
   reset() {
     if (this._file)
       this._file.remove();
-    this._file = new WebInspector.DeferredTempFile(this._dirName, String(Date.now()));
+    this._file = new Bindings.DeferredTempFile(this._dirName, String(Date.now()));
     /**
      * @type {!Array.<string>}
      */
     this._strings = [];
     this._stringsLength = 0;
     this._fileSize = 0;
   }
 
   /**
-   * @param {!WebInspector.OutputStream} outputStream
-   * @param {!WebInspector.OutputStreamDelegate} delegate
+   * @param {!Common.OutputStream} outputStream
+   * @param {!Bindings.OutputStreamDelegate} delegate
    */
   writeToStream(outputStream, delegate) {
     this._file.copyToOutputStream(outputStream, delegate);
   }
 };
 
 /**
  * @typedef {{
  *      string: ?string,
  *      startOffset: number,
  *      endOffset: number
  * }}
  */
-WebInspector.TempFileBackingStorage.Chunk;
+Bindings.TempFileBackingStorage.Chunk;