src/third_party/WebKit/Source/devtools/front_end/sdk/FileUtils.js

   1 /*
   2  * Copyright (C) 2012 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 /**
  32  * @interface
  33  */
  34 WebInspector.OutputStreamDelegate = function()
  35 {
  36 }
  37
  38 WebInspector.OutputStreamDelegate.prototype = {
  39     onTransferStarted: function() { },
  40
  41     onTransferFinished: function() { },
  42
  43     /**
  44      * @param {!WebInspector.ChunkedReader} reader
  45      */
  46     onChunkTransferred: function(reader) { },
  47
  48     /**
  49      * @param {!WebInspector.ChunkedReader} reader
  50      * @param {!Event} event
  51      */
  52     onError: function(reader, event) { },
  53 }
  54
  55 /**
  56  * @interface
  57  */
  58 WebInspector.OutputStream = function()
  59 {
  60 }
  61
  62 WebInspector.OutputStream.prototype = {
  63     /**
  64      * @param {string} data
  65      * @param {function(!WebInspector.OutputStream)=} callback
  66      */
  67     write: function(data, callback) { },
  68
  69     close: function() { }
  70 }
  71
  72 /**
  73  * @interface
  74  */
  75 WebInspector.ChunkedReader = function()
  76 {
  77 }
  78
  79 WebInspector.ChunkedReader.prototype = {
  80     /**
  81      * @return {number}
  82      */
  83     fileSize: function() { },
  84
  85     /**
  86      * @return {number}
  87      */
  88     loadedSize: function() { },
  89
  90     /**
  91      * @return {string}
  92      */
  93     fileName: function() { },
  94
  95     cancel: function() { }
  96 }
  97
  98 /**
  99  * @constructor
 100  * @implements {WebInspector.ChunkedReader}
 101  * @param {!File} file
 102  * @param {number} chunkSize
 103  * @param {!WebInspector.OutputStreamDelegate} delegate
 104  */
 105 WebInspector.ChunkedFileReader = function(file, chunkSize, delegate)
 106 {
 107     this._file = file;
 108     this._fileSize = file.size;
 109     this._loadedSize = 0;
 110     this._chunkSize = chunkSize;
 111     this._delegate = delegate;
 112     this._isCanceled = false;
 113 }
 114
 115 WebInspector.ChunkedFileReader.prototype = {
 116     /**
 117      * @param {!WebInspector.OutputStream} output
 118      */
 119     start: function(output)
 120     {
 121         this._output = output;
 122
 123         this._reader = new FileReader();
 124         this._reader.onload = this._onChunkLoaded.bind(this);
 125         this._reader.onerror = this._delegate.onError.bind(this._delegate, this);
 126         this._delegate.onTransferStarted();
 127         this._loadChunk();
 128     },
 129
 130     cancel: function()
 131     {
 132         this._isCanceled = true;
 133     },
 134
 135     /**
 136      * @return {number}
 137      */
 138     loadedSize: function()
 139     {
 140         return this._loadedSize;
 141     },
 142
 143     /**
 144      * @return {number}
 145      */
 146     fileSize: function()
 147     {
 148         return this._fileSize;
 149     },
 150
 151     /**
 152      * @return {string}
 153      */
 154     fileName: function()
 155     {
 156         return this._file.name;
 157     },
 158
 159     /**
 160      * @param {?Event} event
 161      */
 162     _onChunkLoaded: function(event)
 163     {
 164         if (this._isCanceled)
 165             return;
 166
 167         if (event.target.readyState !== FileReader.DONE)
 168             return;
 169
 170         var data = event.target.result;
 171         this._loadedSize += data.length;
 172
 173         this._output.write(data);
 174         if (this._isCanceled)
 175             return;
 176         this._delegate.onChunkTransferred(this);
 177
 178         if (this._loadedSize === this._fileSize) {
 179             this._file = null;
 180             this._reader = null;
 181             this._output.close();
 182             this._delegate.onTransferFinished();
 183             return;
 184         }
 185
 186         this._loadChunk();
 187     },
 188
 189     _loadChunk: function()
 190     {
 191         var chunkStart = this._loadedSize;
 192         var chunkEnd = Math.min(this._fileSize, chunkStart + this._chunkSize)
 193         var nextPart = this._file.slice(chunkStart, chunkEnd);
 194         this._reader.readAsText(nextPart);
 195     }
 196 }
 197
 198 /**
 199  * @constructor
 200  * @implements {WebInspector.ChunkedReader}
 201  * @param {string} url
 202  * @param {!WebInspector.OutputStreamDelegate} delegate
 203  */
 204 WebInspector.ChunkedXHRReader = function(url, delegate)
 205 {
 206     this._url = url;
 207     this._delegate = delegate;
 208     this._fileSize = 0;
 209     this._loadedSize = 0;
 210     this._isCanceled = false;
 211 }
 212
 213 WebInspector.ChunkedXHRReader.prototype = {
 214     /**
 215      * @param {!WebInspector.OutputStream} output
 216      */
 217     start: function(output)
 218     {
 219         this._output = output;
 220
 221         this._xhr = new XMLHttpRequest();
 222         this._xhr.open("GET", this._url, true);
 223         this._xhr.onload = this._onLoad.bind(this);
 224         this._xhr.onprogress = this._onProgress.bind(this);
 225         this._xhr.onerror = this._delegate.onError.bind(this._delegate, this);
 226         this._xhr.send(null);
 227
 228         this._delegate.onTransferStarted();
 229     },
 230
 231     cancel: function()
 232     {
 233         this._isCanceled = true;
 234         this._xhr.abort();
 235     },
 236
 237     /**
 238      * @return {number}
 239      */
 240     loadedSize: function()
 241     {
 242         return this._loadedSize;
 243     },
 244
 245     /**
 246      * @return {number}
 247      */
 248     fileSize: function()
 249     {
 250         return this._fileSize;
 251     },
 252
 253     /**
 254      * @return {string}
 255      */
 256     fileName: function()
 257     {
 258         return this._url;
 259     },
 260
 261     /**
 262      * @param {?Event} event
 263      */
 264     _onProgress: function(event)
 265     {
 266         if (this._isCanceled)
 267             return;
 268
 269         if (event.lengthComputable)
 270             this._fileSize = event.total;
 271
 272         var data = this._xhr.responseText.substring(this._loadedSize);
 273         if (!data.length)
 274             return;
 275
 276         this._loadedSize += data.length;
 277         this._output.write(data);
 278         if (this._isCanceled)
 279             return;
 280         this._delegate.onChunkTransferred(this);
 281     },
 282
 283     /**
 284      * @param {?Event} event
 285      */
 286     _onLoad: function(event)
 287     {
 288         this._onProgress(event);
 289
 290         if (this._isCanceled)
 291             return;
 292
 293         this._output.close();
 294         this._delegate.onTransferFinished();
 295     }
 296 }
 297
 298 /**
 299  * @param {function(!File)} callback
 300  * @return {!Node}
 301  */
 302 WebInspector.createFileSelectorElement = function(callback) {
 303     var fileSelectorElement = document.createElement("input");
 304     fileSelectorElement.type = "file";
 305     fileSelectorElement.style.display = "none";
 306     fileSelectorElement.setAttribute("tabindex", -1);
 307     fileSelectorElement.onchange = onChange;
 308     function onChange(event)
 309     {
 310         callback(fileSelectorElement.files[0]);
 311     };
 312     return fileSelectorElement;
 313 }
 314
 315 /**
 316  * @constructor
 317  * @implements {WebInspector.OutputStream}
 318  */
 319 WebInspector.FileOutputStream = function()
 320 {
 321 }
 322
 323 WebInspector.FileOutputStream.prototype = {
 324     /**
 325      * @param {string} fileName
 326      * @param {function(boolean)} callback
 327      */
 328     open: function(fileName, callback)
 329     {
 330         this._closed = false;
 331         this._writeCallbacks = [];
 332         this._fileName = fileName;
 333
 334         /**
 335          * @param {boolean} accepted
 336          * @this {WebInspector.FileOutputStream}
 337          */
 338         function callbackWrapper(accepted)
 339         {
 340             if (accepted)
 341                 WebInspector.fileManager.addEventListener(WebInspector.FileManager.EventTypes.AppendedToURL, this._onAppendDone, this);
 342             callback(accepted);
 343         }
 344         WebInspector.fileManager.save(this._fileName, "", true, callbackWrapper.bind(this));
 345     },
 346
 347     /**
 348      * @param {string} data
 349      * @param {function(!WebInspector.OutputStream)=} callback
 350      */
 351     write: function(data, callback)
 352     {
 353         this._writeCallbacks.push(callback);
 354         WebInspector.fileManager.append(this._fileName, data);
 355     },
 356
 357     close: function()
 358     {
 359         this._closed = true;
 360         if (this._writeCallbacks.length)
 361             return;
 362         WebInspector.fileManager.removeEventListener(WebInspector.FileManager.EventTypes.AppendedToURL, this._onAppendDone, this);
 363         WebInspector.fileManager.close(this._fileName);
 364     },
 365
 366     /**
 367      * @param {!WebInspector.Event} event
 368      */
 369     _onAppendDone: function(event)
 370     {
 371         if (event.data !== this._fileName)
 372             return;
 373         var callback = this._writeCallbacks.shift();
 374         if (callback)
 375             callback(this);
 376         if (!this._writeCallbacks.length) {
 377             if (this._closed) {
 378                 WebInspector.fileManager.removeEventListener(WebInspector.FileManager.EventTypes.AppendedToURL, this._onAppendDone, this);
 379                 WebInspector.fileManager.close(this._fileName);
 380             }
 381         }
 382     }
 383 }