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 = opt_OnError || function(error) {
+    // 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;
 
   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);
+    };
+    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);
   }
 };