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 21 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.directoryModel_.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 315 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 315 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);
 };
 
 /**
+ * Register a listener for a new root element in left menu.
  * @private
- * @param {Event} event
+ * @param {HTMLElement} li List item representing a volume.
+ * @param {Entry} entry Root directory entry.
  */
-DirectoryModel.prototype.onRootsSelectionChanged_ = function(event) {

[SeRya, 2012/04/20 16:06:46]

What's wrong with onRootsSelectionChanged_? I think DirectoryModel is a wrong
place to handle clicks.

[Oleg Eterevsky, 2012/04/23 10:50:40]

I agree, but this event is not fired when user clicks on the item that is
already selected. So, the click should be handled.

-  var root = this.rootsList.item(this.rootsListSelection.selectedIndex);
-  if (root && this.rootPath != root.fullPath)
-    this.changeDirectory(root.fullPath);
+DirectoryModel.prototype.registerRootClickListener_ = function append(li,
+                                                                      entry) {
+  li.addEventListener('click', this.onRootClick_.bind(this, entry));
+};
+
+/**
+ * Handler for root item being clicked.
+ * @private
+ * @param {Entry} entry Entry to navigate to.
+ * @param {Event} event The event.
+ */
+DirectoryModel.prototype.onRootClick_ = function(entry, event) {
+  var new_path = entry.fullPath;
+  if (entry.fullPath == this.getCurrentRootPath()) {
+    this.changeDirectory(entry.fullPath);
+  } else {
+    this.changeDirectory(this.currentDirByRoot_[entry.fullPath] ||
+                         entry.fullPath);
+  }
 };
 
 /**
  * @private
  */
 DirectoryModel.prototype.updateRootsListSelection_ = function() {
   var roots = this.rootsList_;
-  var rootPath = this.rootPath;
+  var rootPath = this.getCurrentRootPath();
   for (var index = 0; index < roots.length; index++) {
     if (roots.item(index).fullPath == rootPath) {
-      this.rootsListSelection.selectedIndex = index;
+      this.rootsListSelection_.selectedIndex = index;
       return;
     }
   }
-  this.rootsListSelection.selectedIndex = -1;
+  this.rootsListSelection_.selectedIndex = -1;
 };
 
 /**
  * @private
  */
 DirectoryModel.prototype.updateReadonlyStatus_ = function() {
   switch (this.rootType) {
     case DirectoryModel.RootType.REMOVABLE:
       this.readonly_ = !!this.currentVolumeMetadata_.isReadOnly;
       break;
     case DirectoryModel.RootType.ARCHIVE:
       this.readonly_ = true;
       break;
     case DirectoryModel.RootType.DOWNLOADS:
       this.readonly_ = false;
       break;
     case DirectoryModel.RootType.GDATA:
       this.readonly_ = this.offline;
       break;
     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;
             self.updateReadonlyStatus_();
           }
         });
       });
     }
   }
 };
 
 /**
- * @param {string} path
+ * @param {string} path Any path in the file system.
  * @return {string} The root path.
  */
 DirectoryModel.getRootPath = function(path) {
   var type = DirectoryModel.getRootType(path);
 
   if (type == DirectoryModel.RootType.DOWNLOADS)
     return '/' + DirectoryModel.DOWNLOADS_DIRECTORY;
   if (type == DirectoryModel.RootType.GDATA)
     return '/' + DirectoryModel.GDATA_DIRECTORY;
 
@@ skipping 13 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);
   }
 };