Simplify directory initialization in Files app.

chrome/browser/resources/file_manager/foreground/js/file_manager.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 'use strict';
 
 /**
  * FileManager constructor.
  *
  * FileManager objects encapsulate the functionality of the file selector
@@ skipping 28 matching lines @@
   this.selectionHandler_ = null;
 
   /**
    * VolumeInfo of the current volume.
    * @type {VolumeInfo}
    * @private
    */
   this.currentVolumeInfo_ = null;
 }
 
-/**
- * Maximum delay in milliseconds for updating thumbnails in the bottom panel
- * to mitigate flickering. If images load faster then the delay they replace
- * old images smoothly. On the other hand we don't want to keep old images
- * too long.
- *
- * @type {number}
- * @const
- */
-FileManager.THUMBNAIL_SHOW_DELAY = 100;
-
 FileManager.prototype = {
   __proto__: cr.EventTarget.prototype,
   get directoryModel() {
     return this.directoryModel_;
   },
   get navigationList() {
     return this.navigationList_;
   },
   get document() {
     return this.document_;
@@ skipping 506 matching lines @@
 
   /**
    * Initializes general purpose basic things, which are used by other
    * initializing methods.
    *
    * @param {function()} callback Completion callback.
    * @private
    */
   FileManager.prototype.initGeneral_ = function(callback) {
     // Initialize the application state.
+    // TODO(mtomasz): Unify window.appState with location.search format.
     if (window.appState) {
       this.params_ = window.appState.params || {};
-      this.defaultPath = window.appState.defaultPath;
+      this.initCurrentDirectoryPath_ = window.appState.currentDirectoryPath;
+      this.initSelectionPath_ = window.appState.selectionPath;
+      this.initTargetName_ = window.appState.targetName;
     } else {
+      // Used by the select dialog only.
       this.params_ = location.search ?
                      JSON.parse(decodeURIComponent(location.search.substr(1))) :
                      {};
-      this.defaultPath = this.params_.defaultPath;
+      this.initCurrentDirectoryPath_ = this.params_.currentDirectoryPath;
+      this.initSelectionPath_ = this.params_.selectionPath;
+      this.initTargetName_ = this.params_.targetName;
     }
 
     // Initialize the member variables that depend this.params_.
     this.dialogType = this.params_.type || DialogType.FULL_PAGE;
     this.startupPrefName_ = 'file-manager-' + this.dialogType;
     this.fileTypes_ = this.params_.typeList || [];
 
     callback();
   };
 
@@ skipping 783 matching lines @@
    * @private
    */
   FileManager.prototype.onDragEnd_ = function() {
     // On open file dialog, the preview panel is always shown.
     if (DialogType.isOpenDialog(this.dialogType))
       return;
     this.previewPanel_.visibilityType = PreviewPanel.VisibilityType.AUTO;
   };
 
   /**
-   * Restores current directory and may be a selected item after page load (or
-   * reload) or popping a state (after click on back/forward). defaultPath
-   * primarily is used with save/open dialogs.
-   * Default path may also contain a file name. Freshly opened file manager
-   * window has neither.
-   *
+   * Sets up the current directory during initialization.
    * @private
    */
   FileManager.prototype.setupCurrentDirectory_ = function() {
     var tracker = this.directoryModel_.createDirectoryChangeTracker();
     var queue = new AsyncUtil.Queue();
 
     // Wait until the volume manager is initialized.
     queue.run(function(callback) {
       tracker.start();
       this.volumeManager_.ensureInitialized(callback);
     }.bind(this));
 
-    // Obtains the fallback path.
-    var defaultDisplayRoot;
+    var nextCurrentDirEntry;
+    var selectionEntry;
+
+    // Resolve the selectionPath to selectionEntry or to currentDirectoryEntry

[hirono, 2014/01/23 05:35:57]

How about using Promise here? There are many fallback lines in
setupCurrentDirectory_ and Promise makes it easy to handle fallback.

[mtomasz, 2014/01/23 06:27:04]

I think using Promise here would make the code much more complicated than using
a simple Queue. How about trying it in a separate CL? I'm concerned, this CL is
already too big, so I would like to keep it as simple as possible at this
moment.

[hirono, 2014/01/23 06:43:18]

SGTM!

+    // in case of being a display root.
     queue.run(function(callback) {
-      this.volumeManager_.getDefaultDisplayRoot(function(displayRoot) {
-        defaultDisplayRoot = displayRoot;
+      console.log(nextCurrentDirEntry, selectionEntry);

[kinaba, 2014/01/23 04:58:02]

Don't forget to remove these debug logs.

[mtomasz, 2014/01/23 06:27:04]

Done.

+      // TODO(mtomasz): Migrate to URLs, and stop calling resolveAbsolutePath.
+      if (!this.initSelectionPath_) {
+        callback();
+        return;
+      }
+      this.volumeManager_.resolveAbsolutePath(
+          this.initSelectionPath_,
+          function(inEntry) {
+            var locationInfo = this.volumeManager_.getLocationInfo(inEntry);
+            // If the selection is root, then use it as a current directory
+            // instead. This is because, selecting a root entry is done as
+            // opening it.
+            console.log(locationInfo);
+            if (locationInfo && locationInfo.isRootEntry)
+              nextCurrentDirEntry = inEntry;
+            else
+              selectionEntry = inEntry;
+            callback();
+          }.bind(this), callback);
+    }.bind(this));
+    // Resolve the currentDirectoryPath to currentDirectoryEntry (if not done
+    // by the previous step).
+    queue.run(function(callback) {
+      console.log(nextCurrentDirEntry, selectionEntry);
+      if (nextCurrentDirEntry || !this.initCurrentDirectoryPath_) {
+        callback();
+        return;
+      }
+      // TODO(mtomasz): Migrate to URLs, and stop calling resolveAbsolutePath.
+      this.volumeManager_.resolveAbsolutePath(
+          this.initCurrentDirectoryPath_,
+          function(inEntry) {
+            nextCurrentDirEntry = inEntry;
+            callback();
+          }, callback);
+      // TODO(mtomasz): Implement reopening on special search, when fake
+      // entries are converted to directory providers.
+    }.bind(this));
+
+    // If the directory to be changed to is not available, then first fallback
+    // to the parent of the selection entry.
+    queue.run(function(callback) {
+      console.log(nextCurrentDirEntry, selectionEntry);
+      if (nextCurrentDirEntry || !selectionEntry) {
+        callback();
+        return;
+      }
+      selectionEntry.getParent(function(inEntry) {
+        nextCurrentDirEntry = inEntry;
         callback();
       }.bind(this));
     }.bind(this));
 
-    // Resolve the default path.
-    var defaultFullPath;
-    var candidateFullPath;
-    var candidateEntry;
+    // If the directory to be changed to is still not resolved, then fallback
+    // to the default display root.
     queue.run(function(callback) {
-      // Cancel this sequence if the current directory has already changed.
-      if (tracker.hasChanged) {
+      console.log(nextCurrentDirEntry, selectionEntry);
+      if (nextCurrentDirEntry) {
         callback();
         return;
       }
-
-      // Resolve the absolute path in case only the file name or an empty string
-      // is passed.
-      if (!this.defaultPath) {
-        // TODO(mtomasz): that in this case we can directly jump to #1540
-        // and avoid fullPath conversion -> Entry.
-        defaultFullPath = defaultDisplayRoot.fullPath;
-      } else if (this.defaultPath.indexOf('/') === -1) {
-        // Path is a file name.
-        defaultFullPath = defaultDisplayRoot.fullPath + '/' + this.defaultPath;
-      } else {
-        defaultFullPath = this.defaultPath;
-      }
-
-      // If Drive is disabled but the path points to Drive's entry, fallback to
-      // defaultDisplayRootPath.
-      if (PathUtil.isDriveBasedPath(defaultFullPath) &&
-          !this.volumeManager_.getVolumeInfo(RootDirectory.DRIVE)) {
-        candidateFullPath = defaultDisplayRoot.fullPath + '/' +
-            PathUtil.basename(defaultFullPath);
-      } else {
-        candidateFullPath = defaultFullPath;
-      }
-
-      // If the path points a fake entry, use the entry directly.
-      // TODO(hirono): Obtains proper volume.
-      var volumeInfo = this.volumeManager_.getCurrentProfileVolumeInfo(
-          util.VolumeType.DRIVE);
-      if (volumeInfo) {
-        for (var name in volumeInfo.fakeEntries) {
-          var fakeEntry = volumeInfo.fakeEntries[name];
-          // Skip the drive root fake entry, because we can need actual drive
-          // root to list its files.
-          if (fakeEntry.rootType === RootType.DRIVE)
-            continue;
-          if (candidateFullPath === fakeEntry.fullPath) {
-            candidateEntry = fakeEntry;
-            callback();
-            return;
-          }
-        }
-      }
-
-      // Convert the path to the directory entry and an optional selection
-      // entry.
-      // TODO(hirono): There may be a race here. The path on Drive, may not
-      // be available yet.
-      this.volumeManager_.resolveAbsolutePath(candidateFullPath,
-                                              function(inEntry) {
-        candidateEntry = inEntry;
+      this.volumeManager_.getDefaultDisplayRoot(function(displayRoot) {
+        nextCurrentDirEntry = displayRoot;
         callback();
-      }, function() {
-        callback();
-      });
+      }.bind(this));
     }.bind(this));
 
-    // Check the obtained entry.
-    var nextCurrentDirEntry;
-    var selectionEntry = null;
-    var suggestedName = null;
-    var error = null;
+    // If selection failed to be resolved (eg. didn't exist, in case of saving
+    // a file, or in case of a fallback of the current directory, then try to
+    // resolve again using the target name.
     queue.run(function(callback) {
-      // Cancel this sequence if the current directory has already changed.
-      if (tracker.hasChanged) {
+      console.log(nextCurrentDirEntry, selectionEntry);
+      if (selectionEntry || !nextCurrentDirEntry || !this.initTargetName_) {
         callback();
         return;
       }
-
-      if (candidateEntry) {
-        // The entry is directory. Use it.
-        if (candidateEntry.isDirectory) {
-          nextCurrentDirEntry = candidateEntry;
-          callback();
-          return;
-        }
-        // The entry exists, but it is not a directory. Therefore use a
-        // parent.
-        candidateEntry.getParent(function(parentEntry) {
-          nextCurrentDirEntry = parentEntry;
-          selectionEntry = candidateEntry;
-          callback();
-        }, function() {
-          error = new Error('Unable to resolve parent for: ' +
-              candidateEntry.fullPath);
-          callback();
-        });
-        return;
-      }
-
-      // If the entry doesn't exist, most probably because the path contains a
-      // suggested name. Therefore try to open its parent. However, the parent
-      // may also not exist. In such situation, fallback.
-      var pathNodes = candidateFullPath.split('/');
-      var baseName = pathNodes.pop();
-      var parentPath = pathNodes.join('/');
-      this.volumeManager_.resolveAbsolutePath(
-          parentPath,
-          function(parentEntry) {
-            nextCurrentDirEntry = parentEntry;
-            suggestedName = baseName;
+      // Try to resolve as a file first. If it fails, then as a directory.
+      nextCurrentDirEntry.getFile(
+          this.initTargetName_,
+          {},
+          function(targetEntry) {
+            selectionEntry = targetEntry;
             callback();
-          },
-          callback);  // In case of an error, continue.
+          }, function() {
+            // Failed to resolve as a file
+            nextCurrentDirEntry.getDirectory(
+              this.initTargetName_,
+              {},
+              function(targetEntry) {
+                selectionEntry = targetEntry;
+                callback();
+              }, function() {
+                // Failed to resolve as either file or directory.
+                callback();
+              });
+          }.bind(this));
     }.bind(this));
 
-    // If the directory is not set at this stage, fallback to the default
-    // mount point.
+
+    // Finalize.
     queue.run(function(callback) {
-      // Check error.
-      if (error) {
-        callback();
-        throw error;
-      }
+      console.log(nextCurrentDirEntry, selectionEntry);
       // Check directory change.
       tracker.stop();
       if (tracker.hasChanged) {
         callback();
         return;
       }
       // Finish setup current directory.
       this.finishSetupCurrentDirectory_(
-          nextCurrentDirEntry || defaultDisplayRoot,
+          nextCurrentDirEntry,
           selectionEntry,
-          suggestedName);
+          this.initTargetName_);
       callback();
     }.bind(this));
   };
 
   /**
    * @param {DirectoryEntry} directoryEntry Directory to be opened.
    * @param {Entry=} opt_selectionEntry Entry to be selected.
    * @param {string=} opt_suggestedName Suggested name for a non-existing\
    *     selection.
    * @private
@@ skipping 11 matching lines @@
     }
 
     if (this.dialogType === DialogType.FULL_PAGE) {
       // In the FULL_PAGE mode if the restored path points to a file we might
       // have to invoke a task after selecting it.
       if (this.params_.action === 'select')
         return;
 
       var task = null;
       // Handle restoring after crash, or the gallery action.
+      // TODO(mtomasz): Use the gallery action instead of just the gallery
+      //     field.
       if (this.params_.gallery || this.params_.action === 'gallery') {
         if (!opt_selectionEntry) {
           // Non-existent file or a directory.
           // Reloading while the Gallery is open with empty or multiple
           // selection. Open the Gallery when the directory is scanned.
           task = function() {
             new FileTasks(this, this.params_).openGallery([]);
           }.bind(this);
         } else {
           // The file or the directory exists.
           task = function() {
-            // TODO(mtomasz): Replace the url with an entry.
             new FileTasks(this, this.params_).openGallery([opt_selectionEntry]);
           }.bind(this);
         }
       } else {
         // TODO(mtomasz): Implement remounting archives after crash.
         //                See: crbug.com/333139
       }
 
       // If there is a task to be run, run it after the scan is completed.
       if (task) {
         var listener = function() {
+          if (!util.isSameEntry(this.directoryModel_.getCurrentDirEntry(),
+                               directoryEntry)) {
+            // Opened on a different path. Probably fallbacked. Therefore,
+            // do not invoke a task.
+            return;
+          }
           this.directoryModel_.removeEventListener(
               'scan-completed', listener);
           task();
         }.bind(this);
         this.directoryModel_.addEventListener('scan-completed', listener);
       }
     } else if (this.dialogType === DialogType.SELECT_SAVEAS_FILE) {
       this.filenameInput_.value = opt_suggestedName || '';
-      this.selectDefaultPathInFilenameInput_();
+      this.selectTargetNameInFilenameInput_();
     }
   };
 
   /**
    * @private
    */
   FileManager.prototype.refreshCurrentDirectoryMetadata_ = function() {
     var entries = this.directoryModel_.getFileList().slice();
     var directoryEntry = this.directoryModel_.getCurrentDirEntry();
     if (!directoryEntry)
@@ skipping 406 matching lines @@
   FileManager.prototype.blinkListItem_ = function(listItem) {
     listItem.classList.add('blink');
     setTimeout(function() {
       listItem.classList.remove('blink');
     }, 100);
   };
 
   /**
    * @private
    */
-  FileManager.prototype.selectDefaultPathInFilenameInput_ = function() {
+  FileManager.prototype.selectTargetNameInFilenameInput_ = function() {
     var input = this.filenameInput_;
     input.focus();
     var selectionEnd = input.value.lastIndexOf('.');
     if (selectionEnd == -1) {
       input.select();
     } else {
       input.selectionStart = 0;
       input.selectionEnd = selectionEnd;
     }
-    // Clear, so we never do this again.
-    this.defaultPath = '';
   };
 
   /**
    * Handles mouse click or tap.
    *
    * @param {Event} event The click event.
    * @private
    */
   FileManager.prototype.onDetailClick_ = function(event) {
     if (this.isRenamingInProgress()) {
@@ skipping 185 matching lines @@
   /**
    * Update the UI when the current directory changes.
    *
    * @param {Event} event The directory-changed event.
    * @private
    */
   FileManager.prototype.onDirectoryChanged_ = function(event) {
     this.selectionHandler_.onFileSelectionChanged();
     this.ui_.searchBox.clear();
     // TODO(mtomasz): Use Entry.toURL() instead of fullPath.
+    // TODO(mtomasz): Consider remembering the selection.
     util.updateAppState(
-        this.getCurrentDirectoryEntry() &&
-        this.getCurrentDirectoryEntry().fullPath, '' /* opt_param */);
+        this.getCurrentDirectoryEntry() ?
+        this.getCurrentDirectoryEntry().fullPath : '',
+        '' /* selectionPath */,
+        '' /* opt_param */);
 
     // If the current directory is moved from the device's volume, do not
     // automatically close the window on device removal.
     if (event.previousDirEntry &&
         PathUtil.getRootPath(event.previousDirEntry.fullPath) !=
             PathUtil.getRootPath(event.newDirEntry.fullPath))
       this.closeOnUnmount_ = false;
 
     if (this.commandHandler)
       this.commandHandler.updateAvailability();
@@ skipping 1373 matching lines @@
       callback(this.preferences_);
       return;
     }
 
     chrome.fileBrowserPrivate.getPreferences(function(prefs) {
       this.preferences_ = prefs;
       callback(prefs);
     }.bind(this));
   };
 })();