DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/bindings/FileUtils.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.OutputStreamDelegate = function() {};
+Bindings.OutputStreamDelegate = function() {};
 
-WebInspector.OutputStreamDelegate.prototype = {
+Bindings.OutputStreamDelegate.prototype = {
   onTransferStarted: function() {},
 
   onTransferFinished: function() {},
 
   /**
-   * @param {!WebInspector.ChunkedReader} reader
+   * @param {!Bindings.ChunkedReader} reader
    */
   onChunkTransferred: function(reader) {},
 
   /**
-   * @param {!WebInspector.ChunkedReader} reader
+   * @param {!Bindings.ChunkedReader} reader
    * @param {!Event} event
    */
   onError: function(reader, event) {},
 };
 
 /**
  * @interface
  */
-WebInspector.ChunkedReader = function() {};
+Bindings.ChunkedReader = function() {};
 
-WebInspector.ChunkedReader.prototype = {
+Bindings.ChunkedReader.prototype = {
   /**
    * @return {number}
    */
   fileSize: function() {},
 
   /**
    * @return {number}
    */
   loadedSize: function() {},
 
   /**
    * @return {string}
    */
   fileName: function() {},
 
   cancel: function() {}
 };
 
 /**
- * @implements {WebInspector.ChunkedReader}
+ * @implements {Bindings.ChunkedReader}
  * @unrestricted
  */
-WebInspector.ChunkedFileReader = class {
+Bindings.ChunkedFileReader = class {
   /**
    * @param {!File} file
    * @param {number} chunkSize
-   * @param {!WebInspector.OutputStreamDelegate} delegate
+   * @param {!Bindings.OutputStreamDelegate} delegate
    */
   constructor(file, chunkSize, delegate) {
     this._file = file;
     this._fileSize = file.size;
     this._loadedSize = 0;
     this._chunkSize = chunkSize;
     this._delegate = delegate;
     this._decoder = new TextDecoder();
     this._isCanceled = false;
   }
 
   /**
-   * @param {!WebInspector.OutputStream} output
+   * @param {!Common.OutputStream} output
    */
   start(output) {
     this._output = output;
 
     this._reader = new FileReader();
     this._reader.onload = this._onChunkLoaded.bind(this);
     this._reader.onerror = this._delegate.onError.bind(this._delegate, this);
     this._delegate.onTransferStarted();
     this._loadChunk();
   }
@@ skipping 64 matching lines @@
     var chunkEnd = Math.min(this._fileSize, chunkStart + this._chunkSize);
     var nextPart = this._file.slice(chunkStart, chunkEnd);
     this._reader.readAsArrayBuffer(nextPart);
   }
 };
 
 /**
  * @param {function(!File)} callback
  * @return {!Node}
  */
-WebInspector.createFileSelectorElement = function(callback) {
+Bindings.createFileSelectorElement = function(callback) {
   var fileSelectorElement = createElement('input');
   fileSelectorElement.type = 'file';
   fileSelectorElement.style.display = 'none';
   fileSelectorElement.setAttribute('tabindex', -1);
   fileSelectorElement.onchange = onChange;
   function onChange(event) {
     callback(fileSelectorElement.files[0]);
   }
   return fileSelectorElement;
 };
 
 /**
- * @implements {WebInspector.OutputStream}
+ * @implements {Common.OutputStream}
  * @unrestricted
  */
-WebInspector.FileOutputStream = class {
+Bindings.FileOutputStream = class {
   /**
    * @param {string} fileName
    * @param {function(boolean)} callback
    */
   open(fileName, callback) {
     this._closed = false;
     this._writeCallbacks = [];
     this._fileName = fileName;
 
     /**
      * @param {boolean} accepted
-     * @this {WebInspector.FileOutputStream}
+     * @this {Bindings.FileOutputStream}
      */
     function callbackWrapper(accepted) {
       if (accepted)
-        WebInspector.fileManager.addEventListener(
-            WebInspector.FileManager.Events.AppendedToURL, this._onAppendDone, this);
+        Workspace.fileManager.addEventListener(
+            Workspace.FileManager.Events.AppendedToURL, this._onAppendDone, this);
       callback(accepted);
     }
-    WebInspector.fileManager.save(this._fileName, '', true, callbackWrapper.bind(this));
+    Workspace.fileManager.save(this._fileName, '', true, callbackWrapper.bind(this));
   }
 
   /**
    * @override
    * @param {string} data
-   * @param {function(!WebInspector.OutputStream)=} callback
+   * @param {function(!Common.OutputStream)=} callback
    */
   write(data, callback) {
     this._writeCallbacks.push(callback);
-    WebInspector.fileManager.append(this._fileName, data);
+    Workspace.fileManager.append(this._fileName, data);
   }
 
   /**
    * @override
    */
   close() {
     this._closed = true;
     if (this._writeCallbacks.length)
       return;
-    WebInspector.fileManager.removeEventListener(
-        WebInspector.FileManager.Events.AppendedToURL, this._onAppendDone, this);
-    WebInspector.fileManager.close(this._fileName);
+    Workspace.fileManager.removeEventListener(
+        Workspace.FileManager.Events.AppendedToURL, this._onAppendDone, this);
+    Workspace.fileManager.close(this._fileName);
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _onAppendDone(event) {
     if (event.data !== this._fileName)
       return;
     var callback = this._writeCallbacks.shift();
     if (callback)
       callback(this);
     if (!this._writeCallbacks.length) {
       if (this._closed) {
-        WebInspector.fileManager.removeEventListener(
-            WebInspector.FileManager.Events.AppendedToURL, this._onAppendDone, this);
-        WebInspector.fileManager.close(this._fileName);
+        Workspace.fileManager.removeEventListener(
+            Workspace.FileManager.Events.AppendedToURL, this._onAppendDone, this);
+        Workspace.fileManager.close(this._fileName);
       }
     }
   }
 };