DevTools: kill WI.IsolatedFileSystemManager FileSystemsLoaded event

third_party/WebKit/Source/devtools/front_end/workspace/IsolatedFileSystemManager.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 23 matching lines @@
  */
 WebInspector.IsolatedFileSystemManager = function()
 {
     /** @type {!Map<string, !WebInspector.IsolatedFileSystem>} */
     this._fileSystems = new Map();
     /** @type {!Map<number, function(!Array.<string>)>} */
     this._callbacks = new Map();
     /** @type {!Map<number, !WebInspector.Progress>} */
     this._progresses = new Map();
 
-    InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.FileSystemsLoaded, this._onFileSystemsLoaded, this);
     InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.FileSystemRemoved, this._onFileSystemRemoved, this);
     InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.FileSystemAdded, this._onFileSystemAdded, this);
     InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.FileSystemFilesChanged, this._onFileSystemFilesChanged, this);
     InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.IndexingTotalWorkCalculated, this._onIndexingTotalWorkCalculated, this);
     InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.IndexingWorked, this._onIndexingWorked, this);
     InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.IndexingDone, this._onIndexingDone, this);
     InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.SearchCompleted, this._onSearchCompleted, this);
 
     this._initExcludePatterSetting();
+
+    this._fileSystemsLoadedPromise = this._requestFileSystems();
 }
 
 /** @typedef {!{fileSystemName: string, rootURL: string, fileSystemPath: string}} */
 WebInspector.IsolatedFileSystemManager.FileSystem;
 
 /** @enum {symbol} */
 WebInspector.IsolatedFileSystemManager.Events = {
     FileSystemAdded: Symbol("FileSystemAdded"),
     FileSystemRemoved: Symbol("FileSystemRemoved"),
-    FileSystemsLoaded: Symbol("FileSystemsLoaded"),
     FileSystemFilesChanged: Symbol("FileSystemFilesChanged"),
     ExcludedFolderAdded: Symbol("ExcludedFolderAdded"),
     ExcludedFolderRemoved: Symbol("ExcludedFolderRemoved")
 }
 
 WebInspector.IsolatedFileSystemManager._lastRequestId = 0;
 
 /**
  * @param {string} fileSystemPath
  * @return {string}
  */
 WebInspector.IsolatedFileSystemManager.normalizePath = function(fileSystemPath)
 {
     fileSystemPath = fileSystemPath.replace(/\\/g, "/");
     if (!fileSystemPath.startsWith("file://")) {
         if (fileSystemPath.startsWith("/"))
             fileSystemPath = "file://" + fileSystemPath;
         else
             fileSystemPath = "file:///" + fileSystemPath;
     }
     return fileSystemPath;
 }
 
 WebInspector.IsolatedFileSystemManager.prototype = {
     /**
-     * @param {function()} callback
+     * @return {!Promise<!Array<!WebInspector.IsolatedFileSystem>>}
      */
-    initialize: function(callback)
+    _requestFileSystems: function()
     {
-        this._initializeCallback = callback;
+        var fulfill;
+        var promise = new Promise(f => fulfill = f);
         InspectorFrontendHost.requestFileSystems();
+        InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.FileSystemsLoaded, onFileSystemsLoaded, this);
+        return promise;
+
+        /**
+         * @param {!WebInspector.Event} event
+         * @this {WebInspector.IsolatedFileSystemManager}
+         */
+        function onFileSystemsLoaded(event)
+        {
+            var fileSystems = /** @type {!Array.<!WebInspector.IsolatedFileSystemManager.FileSystem>} */ (event.data);
+            var promises = [];
+            for (var i = 0; i < fileSystems.length; ++i)
+                promises.push(this._innerAddFileSystem(fileSystems[i], false));
+            Promise.all(promises).then(fileSystems => fulfill(fileSystems.filter(fs => !!fs)));

[dgozman, 2016/08/31 20:28:46]

style: no nested arrow functions please

[lushnikov, 2016/08/31 21:46:01]

yikes. done.

+        }
     },
 
     addFileSystem: function()
     {
         InspectorFrontendHost.addFileSystem("");
     },
 
     /**
      * @param {!WebInspector.IsolatedFileSystem} fileSystem
      */
     removeFileSystem: function(fileSystem)
     {
-
         InspectorFrontendHost.removeFileSystem(fileSystem.embedderPath());
     },
 
     /**
-     * @param {!WebInspector.Event} event
+     * @return {!Promise<!Array<!WebInspector.IsolatedFileSystem>>}
      */
-    _onFileSystemsLoaded: function(event)
+    waitForFileSystems: function()
     {
-        var fileSystems = /** @type {!Array.<!WebInspector.IsolatedFileSystemManager.FileSystem>} */ (event.data);
-        var promises = [];
-        for (var i = 0; i < fileSystems.length; ++i)
-            promises.push(this._innerAddFileSystem(fileSystems[i]));
-        Promise.all(promises).then(fireFileSystemsLoaded.bind(this));
-
-        /**
-         * @this {WebInspector.IsolatedFileSystemManager}
-         */
-        function fireFileSystemsLoaded()
-        {
-            this._initializeCallback();
-            delete this._initializeCallback;
-            this.dispatchEventToListeners(WebInspector.IsolatedFileSystemManager.Events.FileSystemsLoaded);
-        }
-    },
-
-    /**
-     * @return {boolean}
-     */
-    fileSystemsLoaded: function()
-    {
-        return !this._initializeCallback;
+        return this._fileSystemsLoadedPromise;
     },
 
     /**
      * @param {!WebInspector.IsolatedFileSystemManager.FileSystem} fileSystem
-     * @return {!Promise}
+     * @param {boolean} dispatchEvent
+     * @return {!Promise<?WebInspector.IsolatedFileSystem>}
      */
-    _innerAddFileSystem: function(fileSystem)
+    _innerAddFileSystem: function(fileSystem, dispatchEvent)
     {
         var embedderPath = fileSystem.fileSystemPath;
         var fileSystemPath = WebInspector.IsolatedFileSystemManager.normalizePath(fileSystem.fileSystemPath);
         var promise = WebInspector.IsolatedFileSystem.create(this, fileSystemPath, embedderPath, fileSystem.fileSystemName, fileSystem.rootURL);
         return promise.then(storeFileSystem.bind(this));
 
         /**
          * @param {?WebInspector.IsolatedFileSystem} fileSystem
          * @this {WebInspector.IsolatedFileSystemManager}
          */
         function storeFileSystem(fileSystem)
         {
             if (!fileSystem)
-                return;
+                return null;
             this._fileSystems.set(fileSystemPath, fileSystem);
-            this.dispatchEventToListeners(WebInspector.IsolatedFileSystemManager.Events.FileSystemAdded, fileSystem);
+            if (dispatchEvent)
+                this.dispatchEventToListeners(WebInspector.IsolatedFileSystemManager.Events.FileSystemAdded, fileSystem);
+            return fileSystem;
         }
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _onFileSystemAdded: function(event)
     {
         var errorMessage = /** @type {string} */ (event.data["errorMessage"]);
         var fileSystem = /** @type {?WebInspector.IsolatedFileSystemManager.FileSystem} */ (event.data["fileSystem"]);
         if (errorMessage)
             WebInspector.console.error(errorMessage);
         else if (fileSystem)
-            this._innerAddFileSystem(fileSystem);
+            this._innerAddFileSystem(fileSystem, true);
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _onFileSystemRemoved: function(event)
     {
-        this._fileSystemRemoved(/** @type {string} */ (event.data));
+        var embedderPath = /** @type {string} */ (event.data);
+        var fileSystemPath = WebInspector.IsolatedFileSystemManager.normalizePath(embedderPath);
+        var isolatedFileSystem = this._fileSystems.get(fileSystemPath);
+        if (!isolatedFileSystem)
+            return;
+        this._fileSystems.delete(fileSystemPath);
+        isolatedFileSystem.fileSystemRemoved();
+        this.dispatchEventToListeners(WebInspector.IsolatedFileSystemManager.Events.FileSystemRemoved, isolatedFileSystem);
     },
 
     /**
      * @param {!WebInspector.Event} event
      */
     _onFileSystemFilesChanged: function(event)
     {
         var embedderPaths = /** @type {!Array<string>} */ (event.data);
         var paths = embedderPaths.map(embedderPath => WebInspector.IsolatedFileSystemManager.normalizePath(embedderPath));
         this.dispatchEventToListeners(WebInspector.IsolatedFileSystemManager.Events.FileSystemFilesChanged, paths);
     },
 
     /**
-     * @param {string} embedderPath
-     */
-    _fileSystemRemoved: function(embedderPath)
-    {
-        var fileSystemPath = WebInspector.IsolatedFileSystemManager.normalizePath(embedderPath);
-        var isolatedFileSystem = this._fileSystems.get(fileSystemPath);
-        if (!isolatedFileSystem)
-            return;
-        this._fileSystems.delete(fileSystemPath);
-        isolatedFileSystem.fileSystemRemoved();
-        this.dispatchEventToListeners(WebInspector.IsolatedFileSystemManager.Events.FileSystemRemoved, isolatedFileSystem);
-    },
-
-    /**
      * @return {!Array<!WebInspector.IsolatedFileSystem>}
      */
     fileSystems: function()
     {
         return this._fileSystems.valuesArray();
     },
 
     /**
      * @param {string} fileSystemPath
      * @return {?WebInspector.IsolatedFileSystem}
@@ skipping 135 matching lines @@
         this._callbacks.delete(requestId);
     },
 
     __proto__: WebInspector.Object.prototype
 }
 
 /**
  * @type {!WebInspector.IsolatedFileSystemManager}
  */
 WebInspector.isolatedFileSystemManager;