Remember current directory for each volume.

chrome/browser/resources/file_manager/js/directory_model.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.
 
 // If directory files changes too often, don't rescan directory more than once
 // per specified interval
 var SIMULTANEOUS_RESCAN_INTERVAL = 1000;
 // Used for operations that require almost instant rescan.
 var SHORT_RESCAN_INTERVAL = 100;
 
@@ skipping 23 matching lines @@
   this.scanFailures_ = 0;
 
   // DirectoryEntry representing the current directory of the dialog.
   this.currentDirEntry_ = root;
 
   this.fileList_.prepareSort = this.prepareSort_.bind(this);
   this.autoSelectIndex_ = 0;
 
   this.rootsList_ = new cr.ui.ArrayDataModel([]);
   this.rootsListSelection_ = new cr.ui.ListSingleSelectionModel();
-  this.rootsListSelection_.addEventListener(
-      'change', this.onRootsSelectionChanged_.bind(this));
+
+  /**
+   * A map root.fullPath -> currentDirectory.fullPath.
+   * @private
+   * @type {Object.<string, string>}
+   */
+  this.currentDirByRoot_ = {};
 
   // The map 'name' -> callback. Callbacks are function(entry) -> boolean.
   this.filters_ = {};
   this.filterHidden = true;
 
   // Readonly status.
   this.readonly_ = false;
   this.currentVolumeMetadata_ = {rootPath: '/'};
   this.offline_ = false;
 }
@@ skipping 43 matching lines @@
   },
 
   /**
    * Selection in the fileList.
    * @type {cr.ui.ListSelectionModel|cr.ui.ListSingleSelectionModel}
    */
   get fileListSelection() {
     return this.fileListSelection_;
   },
 
-  /**
-   * Top level Directories from user perspective.
-   * @type {cr.ui.ArrayDataModel}
-   */
-  get rootsList() {
-    return this.rootsList_;
-  },
-
-  /**
-   * Selection in the rootsList.
-   * @type {cr.ui.ListSingleSelectionModel}
-   */
-  get rootsListSelection() {
-    return this.rootsListSelection_;
-  },
-
-  /**
-   * Root path for the current directory (parent directory is not navigatable
-   * for the user).
-   * @type {string}
-   */
-  get rootPath() {
-    return DirectoryModel.getRootPath(this.currentEntry.fullPath);
-  },
-
   get rootType() {
     return DirectoryModel.getRootType(this.currentEntry.fullPath);
   },
 
   get rootName() {
     return DirectoryModel.getRootName(this.currentEntry.fullPath);
   },
 
-  get rootEntry() {
-    return this.rootsList.item(this.rootsListSelection.selectedIndex);
-  },
-
   /**
    * True if current directory is read only.
    * @type {boolean}
    */
   get readonly() {
     return this.readonly_;
   },
 
   get offline() {
     return this.offline_;
@@ skipping 88 matching lines @@
     for (var i = 0; i < this.fileList_.length; i++) {
       if (this.fileList_.item(i).name == value) {
         this.fileListSelection_.leadIndex = i;
         return;
       }
     }
   }
 };
 
 /**
+ * @return {cr.ui.ArrayDataModel} The list of roots.
+ */
+DirectoryModel.prototype.getRootsList = function() {
+  return this.rootsList_;
+};
+
+/**
+ * @return {Entry} Directory entry of the current root.
+ */
+DirectoryModel.prototype.getCurrentRootDirEntry = function() {
+  return this.rootsList_.item(this.rootsListSelection_.selectedIndex);
+};
+
+/**
+ * @return {string} Root path for the current directory (parent directory is
+ *     not navigatable for the user).
+ */
+DirectoryModel.prototype.getCurrentRootPath = function() {
+  return DirectoryModel.getRootPath(this.currentDirEntry_.fullPath);
+};
+
+/**
+ * @return {cr.ui.ListSingleSelectionModel} Root list selection model.
+ */
+DirectoryModel.prototype.getRootsListSelectionModel = function() {
+  return this.rootsListSelection_;
+};
+
+/**
  * Add a filter for directory contents.
  * @param {string} name An identifier of the filter (used when removing it).
  * @param {function(Entry):boolean} filter Hide file if false.
  */
 DirectoryModel.prototype.addFilter = function(name, filter) {
   this.filters_[name] = filter;
   this.rescanSoon();
 };
 
 /**
@@ skipping 60 matching lines @@
     return;
   }
 
   this.runningScan_ = this.createScanner_(fileList, successCallback);
   this.runningScan_.run();
 };
 
 /**
  * @private
  * @param {Array.<Entry>|cr.ui.ArrayDataModel} list
- * @param {function} successCallback
- * @return {DirectoryModel.Scanner}
+ * @param {function} successCallback Callback on success.
+ * @return {DirectoryModel.Scanner} New Scanner instance.
  */
 DirectoryModel.prototype.createScanner_ = function(list, successCallback) {
   var self = this;
   function onSuccess() {
     self.scanFailures_ = 0;
     successCallback();
     if (self.pendingScan_) {
       self.runningScan_ = self.pendingScan_;
       self.pendingScan_ = null;
       self.runningScan_.run();
@@ skipping 253 matching lines @@
   }
 
   this.currentEntry.getDirectory(name, {create: true, exclusive: true},
                                  onSuccess, errorCallback);
 };
 
 /**
  * Changes directory. Causes 'directory-change' event.
  *
  * @param {string} path New current directory path.
+ * @param {function} opt_OnError Called if failed.
  */
-DirectoryModel.prototype.changeDirectory = function(path) {
+DirectoryModel.prototype.changeDirectory = function(path, opt_OnError) {
   var onDirectoryResolved = function(dirEntry) {
     var autoSelect = this.selectIndex.bind(this, this.autoSelectIndex_);
     this.changeDirectoryEntry_(dirEntry, autoSelect, false);
   }.bind(this);
 
   if (this.unmountedGDataEntry_ &&
       DirectoryModel.getRootType(path) == DirectoryModel.RootType.GDATA) {
     // TODO(kaznacheeev): Currently if path points to some GData subdirectory
     // and GData is not mounted we will change to the fake GData root and
     // ignore the rest of the path. Consider remembering the path and
     // changing to it once GDdata is mounted. This is only relevant for cases
     // when we open the File Manager with an URL pointing to GData (e.g. via
     // a bookmark).
     onDirectoryResolved(this.unmountedGDataEntry_);
     return;
   }
 
   if (path == '/') {
     onDirectoryResolved(this.root_);
     return;
   }
 
-  this.root_.getDirectory(
-      path, {create: false},
-      onDirectoryResolved,
-      function(error) {
-        // TODO(serya): We should show an alert.
-        console.error('Error changing directory to: ' + path + ', ' + error);
-      });
+  var onError = function(error) {

[SeRya, 2012/04/23 14:23:43]

var onError = opt_onError || function(error) { ... }

[Oleg Eterevsky, 2012/04/23 14:33:04]

Good idea. Done.

+    if (opt_OnError) {
+      opt_OnError();
+    } else {
+      // TODO(serya): We should show an alert.
+      console.error('Error changing directory to: ' + path + ', ' + error);
+    }
+  };
+
+  this.root_.getDirectory(path, {create: false}, onDirectoryResolved, onError);
 };
 
 /**
  * Change the current directory to the directory represented by a
  * DirectoryEntry.
  *
  * Dispatches the 'directory-changed' event when the directory is successfully
  * changed.
  *
  * @private
@@ skipping 11 matching lines @@
   function onRescanComplete() {
     action();
     // For tests that open the dialog to empty directories, everything
     // is loaded at this point.
     chrome.test.sendMessage('directory-change-complete');
   }
   this.updateReadonlyStatus_();
   this.updateVolumeMetadata_();
   this.updateRootsListSelection_();
   this.scan_(onRescanComplete);
+  this.currentDirByRoot_[this.getCurrentRootPath()] = dirEntry.fullPath;

[SeRya, 2012/04/23 14:23:43]

Is it OK this is a page-wide state, not application-wide?

[Oleg Eterevsky, 2012/04/23 14:33:04]

You mean that we lose the state when we close the given window? If I understand
correctly, that's what we want.

 
   var e = new cr.Event('directory-changed');
   e.previousDirEntry = previous;
   e.newDirEntry = dirEntry;
   e.initial = initial;
   this.dispatchEvent(e);
 };
 
 /**
  * Change the state of the model to reflect the specified path (either a
@@ skipping 283 matching lines @@
   }
 };
 
 /**
 * @param {function} opt_callback Called when all roots are resolved.
 * @param {boolean} opt_resolveGData If true GData should be resolved for real,
 *                                   If false a stub entry should be created.
 */
 DirectoryModel.prototype.updateRoots = function(opt_callback,
                                                 opt_resolveGData) {
-  console.log('resolving roots');
   var self = this;
   this.resolveRoots_(function(rootEntries) {
-    console.log('resolved roots:', rootEntries);
     var dm = self.rootsList_;
     var args = [0, dm.length].concat(rootEntries);
     dm.splice.apply(dm, args);
 
     self.updateRootsListSelection_();
 
     if (opt_callback)
       opt_callback();
   }, opt_resolveGData);
 };
 
 /**
- * @private
- * @param {Event} event
+ * Change root. In case user already opened the root, the last selected
+ * directory will be selected.
+ * @param {string} rootPath The path of the root.
  */
-DirectoryModel.prototype.onRootsSelectionChanged_ = function(event) {
-  var root = this.rootsList.item(this.rootsListSelection.selectedIndex);
-  if (root && this.rootPath != root.fullPath)
-    this.changeDirectory(root.fullPath);
+DirectoryModel.prototype.changeRoot = function(rootPath) {
+  if (this.currentDirByRoot_[rootPath]) {
+    var onFail = function() {
+      this.changeDirectory(rootPath);

[SeRya, 2012/04/23 14:23:43]

The same logic makes sense in setupPath. If user happen to navigate to a deleted
directoy it makes sense to drop her yo the root rather than to the Downloads. I
think error handling logic should be part of changeDirectory. Hardly we need
either handle such an error nor ignore it.

[Oleg Eterevsky, 2012/04/23 14:33:04]

I'm not sure about it. I'd say if user just changes directory and the operation
fails, it shouldn't move him to the root, but rather should leave him in the
current directory and probably give him some error alert.

+    };
+    this.changeDirectory(this.currentDirByRoot_[rootPath], onFail);
+  } else {
+    this.changeDirectory(rootPath);
+  }
 };
 
 /**
  * Find roots list item by root path.
  *
  * @param {string} path Root path.
  * @return {number} Index of the item.
  * @private
  */
 DirectoryModel.prototype.findRootsListItem_ = function(path) {
   var roots = this.rootsList_;
   for (var index = 0; index < roots.length; index++) {
     if (roots.item(index).fullPath == path)
       return index;
   }
   return -1;
 };
 
 /**
  * @private
  */
 DirectoryModel.prototype.updateRootsListSelection_ = function() {
-  this.rootsListSelection.selectedIndex =
+  this.rootsListSelection_.selectedIndex =
       this.findRootsListItem_(this.rootPath);
 };
 
 /**
  * @private
  */
 DirectoryModel.prototype.updateReadonlyStatus_ = function() {
   switch (this.rootType) {
     case DirectoryModel.RootType.REMOVABLE:
       this.readonly_ = !!this.currentVolumeMetadata_.isReadOnly;
@@ skipping 10 matching lines @@
     default:
       this.readonly_ = true;
       break;
   }
 };
 
 /**
  * @private
  */
 DirectoryModel.prototype.updateVolumeMetadata_ = function() {
-  var rootPath = this.rootPath;
+  var rootPath = this.getCurrentRootPath();
   if (this.currentVolumeMetadata_.rootPath != rootPath) {
     var metadata = this.currentVolumeMetadata_ = {rootPath: rootPath};
     if (DirectoryModel.getRootType(rootPath) ==
         DirectoryModel.RootType.REMOVABLE) {
       var self = this;
       this.root_.getDirectory(rootPath, {}, function(entry) {
         chrome.fileBrowserPrivate.getVolumeMetadata(entry.toURL(),
             function(systemMetadata) {
           if (systemMetadata) {
             metadata.isReadOnly = systemMetadata.isReadOnly;
@@ skipping 60 matching lines @@
  * @param {string} path
  * @return {string}
  */
 DirectoryModel.getRootName = function(path) {
   var root = DirectoryModel.getRootPath(path);
   var index = root.lastIndexOf('/');
   return index == -1 ? root : root.substring(index + 1);
 };
 
 /**
- * @param {string} path
- * @return {string}
+ * @param {string} path Path.
+ * @return {string} A root type.
  */
 DirectoryModel.getRootType = function(path) {
   function isTop(dir) {
     return path.substr(1, dir.length) == dir;
   }
 
   if (isTop(DirectoryModel.DOWNLOADS_DIRECTORY))
     return DirectoryModel.RootType.DOWNLOADS;
-  else if (isTop(DirectoryModel.GDATA_DIRECTORY))
+  if (isTop(DirectoryModel.GDATA_DIRECTORY))
     return DirectoryModel.RootType.GDATA;
-  else if (isTop(DirectoryModel.ARCHIVE_DIRECTORY))
+  if (isTop(DirectoryModel.ARCHIVE_DIRECTORY))
     return DirectoryModel.RootType.ARCHIVE;
-  else if (isTop(DirectoryModel.REMOVABLE_DIRECTORY))
+  if (isTop(DirectoryModel.REMOVABLE_DIRECTORY))
     return DirectoryModel.RootType.REMOVABLE;
   return '';
 };
 
 /**
  * @param {string} path
  * @return {boolean}
  */
 DirectoryModel.isRootPath = function(path) {
   if (path[path.length - 1] == '/')
@@ skipping 91 matching lines @@
 /**
  * @private
  */
 DirectoryModel.Scanner.prototype.recordMetrics_ = function() {
   metrics.recordInterval('DirectoryScan');
   if (this.dir_.fullPath ==
       '/' + DirectoryModel.DOWNLOADS_DIRECTORY) {
     metrics.recordMediumCount('DownloadsCount', this.list_.length);
   }
 };