Files.app: Add subfolders in the left nav

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 20 matching lines @@
   this.rescanTime_ = null;
   this.scanFailures_ = 0;
   this.driveEnabled_ = isDriveEnabled;
 
   this.currentFileListContext_ = new FileListContext(
       metadataCache, fileList, false);
   this.currentDirContents_ = new DirectoryContentsBasic(
       this.currentFileListContext_, root);
 
   this.rootsList_ = new cr.ui.ArrayDataModel([]);
-  this.rootsListSelection_ = new cr.ui.ListSingleSelectionModel();
-  this.rootsListSelection_.addEventListener(
-      'change', this.onRootChange_.bind(this));
-
-  this.rootsListSelection_.addEventListener(
-      'beforeChange', this.onBeforeRootChange_.bind(this));
-
-  /**
-   * A map root.fullPath -> currentDirectory.fullPath.
-   * @type {Object.<string, string>}
-   * @private
-   */
-  this.currentDirByRoot_ = {};
 
   this.volumeManager_ = volumeManager;
 }
 
 /**
  * Fake entry to be used in currentDirEntry_ when current directory is
  * unmounted DRIVE.
  * @private
  */
 DirectoryModel.fakeDriveEntry_ = {
@@ skipping 270 matching lines @@
 };
 
 /**
  * @return {cr.ui.ArrayDataModel} The list of roots.
  */
 DirectoryModel.prototype.getRootsList = function() {
   return this.rootsList_;
 };
 
 /**
- * @return {cr.ui.ListSingleSelectionModel} Root list selection model.
- */
-DirectoryModel.prototype.getRootsListSelectionModel = function() {
-  return this.rootsListSelection_;
-};
-
-/**
  * Schedule rescan with short delay.
  */
 DirectoryModel.prototype.rescanSoon = function() {
   this.scheduleRescan(SHORT_RESCAN_INTERVAL);
 };
 
 /**
  * Schedule rescan with delay. Designed to handle directory change
  * notification.
  */
@@ skipping 378 matching lines @@
   if (path == '/') {
     successCallback(this.root_);
     return;
   }
 
   this.root_.getDirectory(path, {create: false},
                           successCallback, errorCallback);
 };
 
 /**
- * @return {Entry} Directory entry of the root selected in rootsList.
- * @private
- */
-DirectoryModel.prototype.getSelectedRootDirEntry_ = function() {
-  return this.rootsList_.item(this.rootsListSelection_.selectedIndex);
-};
-
-/**
- * Handler before root item change.
- * @param {Event} event The event.
- * @private
- */
-DirectoryModel.prototype.onBeforeRootChange_ = function(event) {
-  if (event.changes.length == 1 && !event.changes[0].selected)
-    event.preventDefault();
-};
-
-/**
- * Handler for root item being clicked.
- * @param {Event} event The event.
- * @private
- */
-DirectoryModel.prototype.onRootChange_ = function(event) {
-  var newRootDir = this.getSelectedRootDirEntry_();
-  if (newRootDir)
-    this.changeRoot(newRootDir.fullPath);
-};
-
-/**
- * Changes directory. If path points to a root (except current one)
- * then directory changed to the last used one for the root.
- *
- * @param {string} path New current directory path or new root.
- */
-DirectoryModel.prototype.changeRoot = function(path) {
-  var currentDir = this.currentDirByRoot_[path] || path;
-  if (currentDir == this.getCurrentDirPath())
-    return;
-  var onError = path != currentDir && path != this.getCurrentDirPath() ?
-      this.changeDirectory.bind(this, path) : null;
-  this.resolveDirectory(
-      currentDir,
-      this.changeDirectoryEntry_.bind(this, false),
-      onError);
-};
-
-/**
  * @param {DirectoryEntry} dirEntry The absolute path to the new directory.
  * @param {function=} opt_callback Executed if the directory loads successfully.
  * @private
  */
 DirectoryModel.prototype.changeDirectoryEntrySilent_ = function(dirEntry,
                                                                 opt_callback) {
   var onScanComplete = function() {
     if (opt_callback)
       opt_callback();
     // For tests that open the dialog to empty directories, everything
     // is loaded at this point.
     chrome.test.sendMessage('directory-change-complete');
   };
   this.clearAndScan_(new DirectoryContentsBasic(this.currentFileListContext_,
                                                 dirEntry),
                      onScanComplete.bind(this));
-  this.currentDirByRoot_[this.getCurrentRootPath()] = dirEntry.fullPath;
-  this.updateRootsListSelection_();
 };
 
 /**
  * Change the current directory to the directory represented by a
  * DirectoryEntry.
  *
  * Dispatches the 'directory-changed' event when the directory is successfully
  * changed.
  *
  * @param {boolean} initial True if it comes from setupPath and
@@ skipping 267 matching lines @@
                      append.bind(this, 'archives'));
   util.readDirectory(root, RootDirectory.REMOVABLE.substring(1),
                      append.bind(this, 'removables'));
 
   if (this.driveEnabled_) {
     var fake = [DirectoryModel.fakeDriveEntry_];
     if (this.isDriveMounted()) {
       readSingle(RootDirectory.DRIVE.substring(1), 'drive', fake);
     } else {
       groups.drive = fake;
+      done();
     }
     // TODO(haruki): Add DirectoryModel.fakeDriveOfflineEntry_ to show the tab.
   } else {
     groups.drive = [];
+    done();
   }
 };
 
 /**
  * Updates the roots list.
  * @private
  */
 DirectoryModel.prototype.updateRoots_ = function() {
   var self = this;
   this.resolveRoots_(function(rootEntries) {
     var dm = self.rootsList_;
     var args = [0, dm.length].concat(rootEntries);
     dm.splice.apply(dm, args);
-
-    self.updateRootsListSelection_();
   });
 };
 
 /**
- * Find roots list item by root path.
- *
- * @param {string} path Root path.
- * @return {number} Index of the item.
- */
-DirectoryModel.prototype.findRootsListIndex = 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() {
-  var rootPath = this.getCurrentRootPath();
-  this.rootsListSelection_.selectedIndex = this.findRootsListIndex(rootPath);
-};
-
-/**
  * @return {boolean} True if DRIVE is fully mounted.
  */
 DirectoryModel.prototype.isDriveMounted = function() {
   return this.volumeManager_.getDriveStatus() ==
       VolumeManager.DriveStatus.MOUNTED;
 };
 
 /**
  * Handler for the VolumeManager's 'change' event.
  * @private
@@ skipping 150 matching lines @@
   this.onClearSearch_ = onClearSearch;
 
   this.addEventListener('scan-completed', this.onSearchCompleted_);
 
   // If we are offline, let's fallback to file name search inside dir.
   if (this.getCurrentRootType() === RootType.DRIVE && !this.isDriveOffline()) {
     // Drive search is performed over the whole drive, so pass drive root as
     // |directoryEntry|.
     newDirContents = new DirectoryContentsDriveSearch(
         this.currentFileListContext_,
-        this.getSelectedRootDirEntry_(),
+        this.getCurrentDirEntry(),
         this.currentDirContents_.getLastNonSearchDirectoryEntry(),
         query);
   } else {
     newDirContents = new DirectoryContentsLocalSearch(
         this.currentFileListContext_, this.getCurrentDirEntry(), query);
   }
   this.clearAndScan_(newDirContents);
 };
 
 
@@ skipping 176 matching lines @@
         }.bind(this));
   }
 };
 
 /**
  * @return {DirectoryEntry} Current watched directory entry.
  */
 FileWatcher.prototype.getWatchedDirectoryEntry = function() {
   return this.watchedDirectoryEntry_;
 };