DevTools: remove unnecessary asynchrony from isolated filesystem.

third_party/WebKit/Source/devtools/front_end/workspace/IsolatedFileSystem.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 21 matching lines @@
  * @constructor
  * @param {!WebInspector.IsolatedFileSystemManager} manager
  * @param {string} path
  * @param {string} name
  * @param {string} rootURL
  */
 WebInspector.IsolatedFileSystem = function(manager, path, name, rootURL)
 {
     this._manager = manager;
     this._path = path;
-    this._name = name;
-    this._rootURL = rootURL;
+    this._domFileSystem = InspectorFrontendHost.isolatedFileSystem(name, rootURL);
 }
 
 /**
  * @param {!FileError} error
  * @return {string}
  */
 WebInspector.IsolatedFileSystem.errorMessage = function(error)
 {
     return WebInspector.UIString("File system error: %s", error.message);
 }
@@ skipping 23 matching lines @@
      */
     normalizedPath: function()
     {
         if (this._normalizedPath)
             return this._normalizedPath;
         this._normalizedPath = WebInspector.IsolatedFileSystem.normalizePath(this._path);
         return this._normalizedPath;
     },
 
     /**
-     * @return {string}
-     */
-    name: function()
-    {
-        return this._name;
-    },
-
-    /**
-     * @return {string}
-     */
-    rootURL: function()
-    {
-        return this._rootURL;
-    },
-
-    /**
-     * @param {function(?DOMFileSystem)} callback
-     */
-    _requestFileSystem: function(callback)
-    {
-        this._manager.requestDOMFileSystem(this._path, callback);
-    },
-
-    /**
      * @param {string} path
      * @param {function(string)} fileCallback
      * @param {function()=} finishedCallback
      */
     requestFilesRecursive: function(path, fileCallback, finishedCallback)
     {
-        var domFileSystem;
-        var pendingRequests = 0;
-        this._requestFileSystem(fileSystemLoaded.bind(this));
-        /**
-         * @param {?DOMFileSystem} fs
-         * @this {WebInspector.IsolatedFileSystem}
-         */
-        function fileSystemLoaded(fs)
-        {
-            domFileSystem = /** @type {!DOMFileSystem} */ (fs);
-            console.assert(domFileSystem);
-            ++pendingRequests;
-            this._requestEntries(domFileSystem, path, innerCallback.bind(this));
-        }
+        var pendingRequests = 1;
+        this._requestEntries(path, innerCallback.bind(this));
 
         /**
          * @param {!Array.<!FileEntry>} entries
          * @this {WebInspector.IsolatedFileSystem}
          */
         function innerCallback(entries)
         {
             for (var i = 0; i < entries.length; ++i) {
                 var entry = entries[i];
                 if (!entry.isDirectory) {
                     if (this._manager.excludedFolderManager().isFileExcluded(this._path, entry.fullPath))
                         continue;
                     fileCallback(entry.fullPath.substr(1));
                 }
                 else {
                     if (this._manager.excludedFolderManager().isFileExcluded(this._path, entry.fullPath + "/"))
                         continue;
                     ++pendingRequests;
-                    this._requestEntries(domFileSystem, entry.fullPath, innerCallback.bind(this));
+                    this._requestEntries(entry.fullPath, innerCallback.bind(this));
                 }
             }
             if (finishedCallback && (--pendingRequests === 0))
                 finishedCallback();
         }
     },
 
     /**
      * @param {string} path
      * @param {?string} name
      * @param {function(?string)} callback
      */
     createFile: function(path, name, callback)
     {
-        this._requestFileSystem(fileSystemLoaded.bind(this));
         var newFileIndex = 1;
         if (!name)
             name = "NewFile";
         var nameCandidate;
 
-        /**
-         * @param {?DOMFileSystem} fs
-         * @this {WebInspector.IsolatedFileSystem}
-         */
-        function fileSystemLoaded(fs)
-        {
-            var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
-            console.assert(domFileSystem);
-            domFileSystem.root.getDirectory(path, null, dirEntryLoaded.bind(this), errorHandler.bind(this));
-        }
+        this._domFileSystem.root.getDirectory(path, null, dirEntryLoaded.bind(this), errorHandler.bind(this));
 
         /**
          * @param {!DirectoryEntry} dirEntry
          * @this {WebInspector.IsolatedFileSystem}
          */
         function dirEntryLoaded(dirEntry)
         {
             var nameCandidate = name;
             if (newFileIndex > 1)
                 nameCandidate += newFileIndex;
@@ skipping 33 matching lines @@
             console.error(errorMessage + " when getting content for file '" + (filePath) + "'");
             callback(null);
         }
     },
 
     /**
      * @param {string} path
      */
     deleteFile: function(path)
     {
-        this._requestFileSystem(fileSystemLoaded.bind(this));
-
-        /**
-         * @param {?DOMFileSystem} fs
-         * @this {WebInspector.IsolatedFileSystem}
-         */
-        function fileSystemLoaded(fs)
-        {
-            var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
-            console.assert(domFileSystem);
-            domFileSystem.root.getFile(path, null, fileEntryLoaded.bind(this), errorHandler.bind(this));
-        }
+        this._domFileSystem.root.getFile(path, null, fileEntryLoaded.bind(this), errorHandler.bind(this));
 
         /**
          * @param {!FileEntry} fileEntry
          * @this {WebInspector.IsolatedFileSystem}
          */
         function fileEntryLoaded(fileEntry)
         {
             fileEntry.remove(fileEntryRemoved, errorHandler.bind(this));
         }
 
@@ skipping 11 matching lines @@
             console.error(errorMessage + " when deleting file '" + (this._path + "/" + path) + "'");
         }
     },
 
     /**
      * @param {string} path
      * @param {function(?Date, ?number)} callback
      */
     requestMetadata: function(path, callback)
     {
-        this._requestFileSystem(fileSystemLoaded);
-
-        /**
-         * @param {?DOMFileSystem} fs
-         */
-        function fileSystemLoaded(fs)
-        {
-            var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
-            console.assert(domFileSystem);
-            domFileSystem.root.getFile(path, null, fileEntryLoaded, errorHandler);
-        }
+        this._domFileSystem.root.getFile(path, null, fileEntryLoaded, errorHandler);
 
         /**
          * @param {!FileEntry} entry
          */
         function fileEntryLoaded(entry)
         {
             entry.getMetadata(successHandler, errorHandler);
         }
 
         /**
@@ skipping 12 matching lines @@
             callback(null, null);
         }
     },
 
     /**
      * @param {string} path
      * @param {function(?string)} callback
      */
     requestFileContent: function(path, callback)
     {
-        this._requestFileSystem(fileSystemLoaded.bind(this));
-
-        /**
-         * @param {?DOMFileSystem} fs
-         * @this {WebInspector.IsolatedFileSystem}
-         */
-        function fileSystemLoaded(fs)
-        {
-            var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
-            console.assert(domFileSystem);
-            domFileSystem.root.getFile(path, null, fileEntryLoaded.bind(this), errorHandler.bind(this));
-        }
+        this._domFileSystem.root.getFile(path, null, fileEntryLoaded.bind(this), errorHandler.bind(this));
 
         /**
          * @param {!FileEntry} entry
          * @this {WebInspector.IsolatedFileSystem}
          */
         function fileEntryLoaded(entry)
         {
             entry.file(fileLoaded, errorHandler.bind(this));
         }
 
@@ skipping 38 matching lines @@
         }
     },
 
     /**
      * @param {string} path
      * @param {string} content
      * @param {function()} callback
      */
     setFileContent: function(path, content, callback)
     {
-        this._requestFileSystem(fileSystemLoaded.bind(this));
         WebInspector.userMetrics.actionTaken(WebInspector.UserMetrics.Action.FileSavedInWorkspace);
-
-        /**
-         * @param {?DOMFileSystem} fs
-         * @this {WebInspector.IsolatedFileSystem}
-         */
-        function fileSystemLoaded(fs)
-        {
-            var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
-            console.assert(domFileSystem);
-            domFileSystem.root.getFile(path, { create: true }, fileEntryLoaded.bind(this), errorHandler.bind(this));
-        }
+        this._domFileSystem.root.getFile(path, { create: true }, fileEntryLoaded.bind(this), errorHandler.bind(this));
 
         /**
          * @param {!FileEntry} entry
          * @this {WebInspector.IsolatedFileSystem}
          */
         function fileEntryLoaded(entry)
         {
             entry.createWriter(fileWriterCreated.bind(this), errorHandler.bind(this));
         }
 
@@ skipping 33 matching lines @@
      */
     renameFile: function(path, newName, callback)
     {
         newName = newName ? newName.trim() : newName;
         if (!newName || newName.indexOf("/") !== -1) {
             callback(false);
             return;
         }
         var fileEntry;
         var dirEntry;
-        this._requestFileSystem(fileSystemLoaded.bind(this));
 
-        /**
-         * @param {?DOMFileSystem} fs
-         * @this {WebInspector.IsolatedFileSystem}
-         */
-        function fileSystemLoaded(fs)
-        {
-            var domFileSystem = /** @type {!DOMFileSystem} */ (fs);
-            console.assert(domFileSystem);
-            domFileSystem.root.getFile(path, null, fileEntryLoaded.bind(this), errorHandler.bind(this));
-        }
+        this._domFileSystem.root.getFile(path, null, fileEntryLoaded.bind(this), errorHandler.bind(this));
 
         /**
          * @param {!FileEntry} entry
          * @this {WebInspector.IsolatedFileSystem}
          */
         function fileEntryLoaded(entry)
         {
             if (entry.name === newName) {
                 callback(false);
                 return;
@@ skipping 80 matching lines @@
 
         function errorHandler(error)
         {
             var errorMessage = WebInspector.IsolatedFileSystem.errorMessage(error);
             console.error(errorMessage + " when reading directory '" + dirEntry.fullPath + "'");
             callback([]);
         }
     },
 
     /**
-     * @param {!DOMFileSystem} domFileSystem
      * @param {string} path
      * @param {function(!Array.<!FileEntry>)} callback
      */
-    _requestEntries: function(domFileSystem, path, callback)
+    _requestEntries: function(path, callback)
     {
-        domFileSystem.root.getDirectory(path, null, innerCallback.bind(this), errorHandler);
+        this._domFileSystem.root.getDirectory(path, null, innerCallback.bind(this), errorHandler);
 
         /**
          * @param {!DirectoryEntry} dirEntry
          * @this {WebInspector.IsolatedFileSystem}
          */
         function innerCallback(dirEntry)
         {
             this._readDirectory(dirEntry, callback);
         }
 
         function errorHandler(error)
         {
             var errorMessage = WebInspector.IsolatedFileSystem.errorMessage(error);
             console.error(errorMessage + " when requesting entry '" + path + "'");
             callback([]);
         }
     }
 }