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

   1 /*
   2  * Copyright (C) 2013 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  * @constructor
  33  * @param {!WebInspector.IsolatedFileSystemManager} manager
  34  * @param {string} path
  35  * @param {string} name
  36  * @param {string} rootURL
  37  */
  38 WebInspector.IsolatedFileSystem = function(manager, path, name, rootURL)
  39 {
  40     this._manager = manager;
  41     this._path = path;
  42     this._name = name;
  43     this._rootURL = rootURL;
  44 }
  45
  46 /**
  47  * @param {!FileError} error
  48  * @return {string}
  49  */
  50 WebInspector.IsolatedFileSystem.errorMessage = function(error)
  51 {
  52     return WebInspector.UIString("File system error: %s", error.message);
  53 }
  54
  55 /**
  56  * @param {string} fileSystemPath
  57  * @return {string}
  58  */
  59 WebInspector.IsolatedFileSystem.normalizePath = function(fileSystemPath)
  60 {
  61     if (WebInspector.isWin())
  62         return fileSystemPath.replace(/\\/g, "/");
  63     return fileSystemPath;
  64 }
  65
  66 WebInspector.IsolatedFileSystem.prototype = {
  67     /**
  68      * @return {string}
  69      */
  70     path: function()
  71     {
  72         return this._path;
  73     },
  74
  75     /**
  76      * @return {string}
  77      */
  78     normalizedPath: function()
  79     {
  80         if (this._normalizedPath)
  81             return this._normalizedPath;
  82         this._normalizedPath = WebInspector.IsolatedFileSystem.normalizePath(this._path);
  83         return this._normalizedPath;
  84     },
  85
  86     /**
  87      * @return {string}
  88      */
  89     name: function()
  90     {
  91         return this._name;
  92     },
  93
  94     /**
  95      * @return {string}
  96      */
  97     rootURL: function()
  98     {
  99         return this._rootURL;
 100     },
 101
 102     /**
 103      * @param {function(?DOMFileSystem)} callback
 104      */
 105     _requestFileSystem: function(callback)
 106     {
 107         this._manager.requestDOMFileSystem(this._path, callback);
 108     },
 109
 110     /**
 111      * @param {string} path
 112      * @param {function(string)} fileCallback
 113      * @param {function()=} finishedCallback
 114      */
 115     requestFilesRecursive: function(path, fileCallback, finishedCallback)
 116     {
 117         var domFileSystem;
 118         var pendingRequests = 0;
 119         this._requestFileSystem(fileSystemLoaded.bind(this));
 120         /**
 121          * @param {?DOMFileSystem} fs
 122          * @this {WebInspector.IsolatedFileSystem}
 123          */
 124         function fileSystemLoaded(fs)
 125         {
 126             domFileSystem = /** @type {!DOMFileSystem} */ (fs);
 127             console.assert(domFileSystem);
 128             ++pendingRequests;
 129             this._requestEntries(domFileSystem, path, innerCallback.bind(this));
 130         }
 131
 132         /**
 133          * @param {!Array.<!FileEntry>} entries
 134          * @this {WebInspector.IsolatedFileSystem}
 135          */
 136         function innerCallback(entries)
 137         {
 138             for (var i = 0; i < entries.length; ++i) {
 139                 var entry = entries[i];
 140                 if (!entry.isDirectory) {
 141                     if (this._manager.excludedFolderManager().isFileExcluded(this._path, entry.fullPath))
 142                         continue;
 143                     fileCallback(entry.fullPath.substr(1));
 144                 }
 145                 else {
 146                     if (this._manager.excludedFolderManager().isFileExcluded(this._path, entry.fullPath + "/"))
 147                         continue;
 148                     ++pendingRequests;
 149                     this._requestEntries(domFileSystem, entry.fullPath, innerCallback.bind(this));
 150                 }
 151             }
 152             if (finishedCallback && (--pendingRequests === 0))
 153                 finishedCallback();
 154         }
 155     },
 156
 157     /**
 158      * @param {string} path
 159      * @param {?string} name
 160      * @param {function(?string)} callback
 161      */
 162     createFile: function(path, name, callback)
 163     {
 164         this._requestFileSystem(fileSystemLoaded.bind(this));
 165         var newFileIndex = 1;
 166         if (!name)
 167             name = "NewFile";
 168         var nameCandidate;
 169
 170         /**
 171          * @param {?DOMFileSystem} fs
 172          * @this {WebInspector.IsolatedFileSystem}
 173          */
 174         function fileSystemLoaded(fs)
 175         {
 176             var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
 177             console.assert(domFileSystem);
 178             domFileSystem.root.getDirectory(path, null, dirEntryLoaded.bind(this), errorHandler.bind(this));
 179         }
 180
 181         /**
 182          * @param {!DirectoryEntry} dirEntry
 183          * @this {WebInspector.IsolatedFileSystem}
 184          */
 185         function dirEntryLoaded(dirEntry)
 186         {
 187             var nameCandidate = name;
 188             if (newFileIndex > 1)
 189                 nameCandidate += newFileIndex;
 190             ++newFileIndex;
 191             dirEntry.getFile(nameCandidate, { create: true, exclusive: true }, fileCreated, fileCreationError.bind(this));
 192
 193             function fileCreated(entry)
 194             {
 195                 callback(entry.fullPath.substr(1));
 196             }
 197
 198             /**
 199              * @this {WebInspector.IsolatedFileSystem}
 200              */
 201             function fileCreationError(error)
 202             {
 203                 if (error.code === FileError.INVALID_MODIFICATION_ERR) {
 204                     dirEntryLoaded.call(this, dirEntry);
 205                     return;
 206                 }
 207
 208                 var errorMessage = WebInspector.IsolatedFileSystem.errorMessage(error);
 209                 console.error(errorMessage + " when testing if file exists '" + (this._path + "/" + path + "/" + nameCandidate) + "'");
 210                 callback(null);
 211             }
 212         }
 213
 214         /**
 215          * @this {WebInspector.IsolatedFileSystem}
 216          */
 217         function errorHandler(error)
 218         {
 219             var errorMessage = WebInspector.IsolatedFileSystem.errorMessage(error);
 220             var filePath = this._path + "/" + path;
 221             if (nameCandidate)
 222                 filePath += "/" + nameCandidate;
 223             console.error(errorMessage + " when getting content for file '" + (filePath) + "'");
 224             callback(null);
 225         }
 226     },
 227
 228     /**
 229      * @param {string} path
 230      */
 231     deleteFile: function(path)
 232     {
 233         this._requestFileSystem(fileSystemLoaded.bind(this));
 234
 235         /**
 236          * @param {?DOMFileSystem} fs
 237          * @this {WebInspector.IsolatedFileSystem}
 238          */
 239         function fileSystemLoaded(fs)
 240         {
 241             var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
 242             console.assert(domFileSystem);
 243             domFileSystem.root.getFile(path, null, fileEntryLoaded.bind(this), errorHandler.bind(this));
 244         }
 245
 246         /**
 247          * @param {!FileEntry} fileEntry
 248          * @this {WebInspector.IsolatedFileSystem}
 249          */
 250         function fileEntryLoaded(fileEntry)
 251         {
 252             fileEntry.remove(fileEntryRemoved, errorHandler.bind(this));
 253         }
 254
 255         function fileEntryRemoved()
 256         {
 257         }
 258
 259         /**
 260          * @param {!FileError} error
 261          * @this {WebInspector.IsolatedFileSystem}
 262          */
 263         function errorHandler(error)
 264         {
 265             var errorMessage = WebInspector.IsolatedFileSystem.errorMessage(error);
 266             console.error(errorMessage + " when deleting file '" + (this._path + "/" + path) + "'");
 267         }
 268     },
 269
 270     /**
 271      * @param {string} path
 272      * @param {function(?Date, ?number)} callback
 273      */
 274     requestMetadata: function(path, callback)
 275     {
 276         this._requestFileSystem(fileSystemLoaded);
 277
 278         /**
 279          * @param {?DOMFileSystem} fs
 280          */
 281         function fileSystemLoaded(fs)
 282         {
 283             var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
 284             console.assert(domFileSystem);
 285             domFileSystem.root.getFile(path, null, fileEntryLoaded, errorHandler);
 286         }
 287
 288         /**
 289          * @param {!FileEntry} entry
 290          */
 291         function fileEntryLoaded(entry)
 292         {
 293             entry.getMetadata(successHandler, errorHandler);
 294         }
 295
 296         /**
 297          * @param {!Metadata} metadata
 298          */
 299         function successHandler(metadata)
 300         {
 301             callback(metadata.modificationTime, metadata.size);
 302         }
 303
 304         /**
 305          * @param {!FileError} error
 306          */
 307         function errorHandler(error)
 308         {
 309             callback(null, null);
 310         }
 311     },
 312
 313     /**
 314      * @param {string} path
 315      * @param {function(?string)} callback
 316      */
 317     requestFileContent: function(path, callback)
 318     {
 319         this._requestFileSystem(fileSystemLoaded.bind(this));
 320
 321         /**
 322          * @param {?DOMFileSystem} fs
 323          * @this {WebInspector.IsolatedFileSystem}
 324          */
 325         function fileSystemLoaded(fs)
 326         {
 327             var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
 328             console.assert(domFileSystem);
 329             domFileSystem.root.getFile(path, null, fileEntryLoaded.bind(this), errorHandler.bind(this));
 330         }
 331
 332         /**
 333          * @param {!FileEntry} entry
 334          * @this {WebInspector.IsolatedFileSystem}
 335          */
 336         function fileEntryLoaded(entry)
 337         {
 338             entry.file(fileLoaded, errorHandler.bind(this));
 339         }
 340
 341         /**
 342          * @param {!Blob} file
 343          */
 344         function fileLoaded(file)
 345         {
 346             var reader = new FileReader();
 347             reader.onloadend = readerLoadEnd;
 348             reader.readAsText(file);
 349         }
 350
 351         /**
 352          * @this {!FileReader}
 353          */
 354         function readerLoadEnd()
 355         {
 356             /** @type {?string} */
 357             var string = null;
 358             try {
 359                 string = /** @type {string} */ (this.result);
 360             } catch (e) {
 361                 console.error("Can't read file: " + path + ": " + e);
 362             }
 363             callback(string);
 364         }
 365
 366         /**
 367          * @this {WebInspector.IsolatedFileSystem}
 368          */
 369         function errorHandler(error)
 370         {
 371             if (error.code === FileError.NOT_FOUND_ERR) {
 372                 callback(null);
 373                 return;
 374             }
 375
 376             var errorMessage = WebInspector.IsolatedFileSystem.errorMessage(error);
 377             console.error(errorMessage + " when getting content for file '" + (this._path + "/" + path) + "'");
 378             callback(null);
 379         }
 380     },
 381
 382     /**
 383      * @param {string} path
 384      * @param {string} content
 385      * @param {function()} callback
 386      */
 387     setFileContent: function(path, content, callback)
 388     {
 389         this._requestFileSystem(fileSystemLoaded.bind(this));
 390         WebInspector.userMetrics.FileSavedInWorkspace.record();
 391
 392         /**
 393          * @param {?DOMFileSystem} fs
 394          * @this {WebInspector.IsolatedFileSystem}
 395          */
 396         function fileSystemLoaded(fs)
 397         {
 398             var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
 399             console.assert(domFileSystem);
 400             domFileSystem.root.getFile(path, { create: true }, fileEntryLoaded.bind(this), errorHandler.bind(this));
 401         }
 402
 403         /**
 404          * @param {!FileEntry} entry
 405          * @this {WebInspector.IsolatedFileSystem}
 406          */
 407         function fileEntryLoaded(entry)
 408         {
 409             entry.createWriter(fileWriterCreated.bind(this), errorHandler.bind(this));
 410         }
 411
 412         /**
 413          * @param {!FileWriter} fileWriter
 414          * @this {WebInspector.IsolatedFileSystem}
 415          */
 416         function fileWriterCreated(fileWriter)
 417         {
 418             fileWriter.onerror = errorHandler.bind(this);
 419             fileWriter.onwriteend = fileWritten;
 420             var blob = new Blob([content], { type: "text/plain" });
 421             fileWriter.write(blob);
 422
 423             function fileWritten()
 424             {
 425                 fileWriter.onwriteend = writerEnd;
 426                 fileWriter.truncate(blob.size);
 427             }
 428         }
 429
 430         function writerEnd()
 431         {
 432             callback();
 433         }
 434
 435         /**
 436          * @this {WebInspector.IsolatedFileSystem}
 437          */
 438         function errorHandler(error)
 439         {
 440             var errorMessage = WebInspector.IsolatedFileSystem.errorMessage(error);
 441             console.error(errorMessage + " when setting content for file '" + (this._path + "/" + path) + "'");
 442             callback();
 443         }
 444     },
 445
 446     /**
 447      * @param {string} path
 448      * @param {string} newName
 449      * @param {function(boolean, string=)} callback
 450      */
 451     renameFile: function(path, newName, callback)
 452     {
 453         newName = newName ? newName.trim() : newName;
 454         if (!newName || newName.indexOf("/") !== -1) {
 455             callback(false);
 456             return;
 457         }
 458         var fileEntry;
 459         var dirEntry;
 460         this._requestFileSystem(fileSystemLoaded.bind(this));
 461
 462         /**
 463          * @param {?DOMFileSystem} fs
 464          * @this {WebInspector.IsolatedFileSystem}
 465          */
 466         function fileSystemLoaded(fs)
 467         {
 468             var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
 469             console.assert(domFileSystem);
 470             domFileSystem.root.getFile(path, null, fileEntryLoaded.bind(this), errorHandler.bind(this));
 471         }
 472
 473         /**
 474          * @param {!FileEntry} entry
 475          * @this {WebInspector.IsolatedFileSystem}
 476          */
 477         function fileEntryLoaded(entry)
 478         {
 479             if (entry.name === newName) {
 480                 callback(false);
 481                 return;
 482             }
 483
 484             fileEntry = entry;
 485             fileEntry.getParent(dirEntryLoaded.bind(this), errorHandler.bind(this));
 486         }
 487
 488         /**
 489          * @param {!Entry} entry
 490          * @this {WebInspector.IsolatedFileSystem}
 491          */
 492         function dirEntryLoaded(entry)
 493         {
 494             dirEntry = entry;
 495             dirEntry.getFile(newName, null, newFileEntryLoaded, newFileEntryLoadErrorHandler.bind(this));
 496         }
 497
 498         /**
 499          * @param {!FileEntry} entry
 500          */
 501         function newFileEntryLoaded(entry)
 502         {
 503             callback(false);
 504         }
 505
 506         /**
 507          * @this {WebInspector.IsolatedFileSystem}
 508          */
 509         function newFileEntryLoadErrorHandler(error)
 510         {
 511             if (error.code !== FileError.NOT_FOUND_ERR) {
 512                 callback(false);
 513                 return;
 514             }
 515             fileEntry.moveTo(dirEntry, newName, fileRenamed, errorHandler.bind(this));
 516         }
 517
 518         /**
 519          * @param {!FileEntry} entry
 520          */
 521         function fileRenamed(entry)
 522         {
 523             callback(true, entry.name);
 524         }
 525
 526         /**
 527          * @this {WebInspector.IsolatedFileSystem}
 528          */
 529         function errorHandler(error)
 530         {
 531             var errorMessage = WebInspector.IsolatedFileSystem.errorMessage(error);
 532             console.error(errorMessage + " when renaming file '" + (this._path + "/" + path) + "' to '" + newName + "'");
 533             callback(false);
 534         }
 535     },
 536
 537     /**
 538      * @param {!DirectoryEntry} dirEntry
 539      * @param {function(!Array.<!FileEntry>)} callback
 540      */
 541     _readDirectory: function(dirEntry, callback)
 542     {
 543         var dirReader = dirEntry.createReader();
 544         var entries = [];
 545
 546         function innerCallback(results)
 547         {
 548             if (!results.length)
 549                 callback(entries.sort());
 550             else {
 551                 entries = entries.concat(toArray(results));
 552                 dirReader.readEntries(innerCallback, errorHandler);
 553             }
 554         }
 555
 556         function toArray(list)
 557         {
 558             return Array.prototype.slice.call(list || [], 0);
 559         }
 560
 561         dirReader.readEntries(innerCallback, errorHandler);
 562
 563         function errorHandler(error)
 564         {
 565             var errorMessage = WebInspector.IsolatedFileSystem.errorMessage(error);
 566             console.error(errorMessage + " when reading directory '" + dirEntry.fullPath + "'");
 567             callback([]);
 568         }
 569     },
 570
 571     /**
 572      * @param {!DOMFileSystem} domFileSystem
 573      * @param {string} path
 574      * @param {function(!Array.<!FileEntry>)} callback
 575      */
 576     _requestEntries: function(domFileSystem, path, callback)
 577     {
 578         domFileSystem.root.getDirectory(path, null, innerCallback.bind(this), errorHandler);
 579
 580         /**
 581          * @param {!DirectoryEntry} dirEntry
 582          * @this {WebInspector.IsolatedFileSystem}
 583          */
 584         function innerCallback(dirEntry)
 585         {
 586             this._readDirectory(dirEntry, callback);
 587         }
 588
 589         function errorHandler(error)
 590         {
 591             var errorMessage = WebInspector.IsolatedFileSystem.errorMessage(error);
 592             console.error(errorMessage + " when requesting entry '" + path + "'");
 593             callback([]);
 594         }
 595     }
 596 }