Revert 133666 - Do not auto-select the first file on entering a folder.

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 19 matching lines @@
 
   this.runningScan_ = null;
   this.pendingScan_ = null;
   this.rescanTimeout_ = undefined;
   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();
 
   /**
    * A map root.fullPath -> currentDirectory.fullPath.
    * @private
    * @type {Object.<string, string>}
    */
   this.currentDirByRoot_ = {};
@@ skipping 138 matching lines @@
 };
 
 /**
  * @return {DirectoryEntry} Current directory.
  */
 DirectoryModel.prototype.getCurrentDirEntry = function() {
   return this.currentDirEntry_;
 };
 
 /**
+ * @param {number} value New auto select index.
+ */
+DirectoryModel.prototype.setAutoSelectIndex = function(value) {
+  this.autoSelectIndex_ = value;
+};
+
+/**
  * @private
  * @return {Array.<string>} Names of selected files.
  */
 DirectoryModel.prototype.getSelectedNames_ = function() {
   var indexes = this.fileListSelection_.selectedIndexes;
   var dataModel = this.fileList_;
   if (dataModel) {
     return indexes.map(function(i) {
       return dataModel.item(i).name;
     });
@@ skipping 430 matching lines @@
                                      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, opt_OnError) {
-  var onDirectoryResolved = this.changeDirectoryEntry_.bind(this, false);
+  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_);
@@ skipping 14 matching lines @@
 };
 
 /**
  * Change the current directory to the directory represented by a
  * DirectoryEntry.
  *
  * Dispatches the 'directory-changed' event when the directory is successfully
  * changed.
  *
  * @private
+ * @param {DirectoryEntry} dirEntry The absolute path to the new directory.
+ * @param {function} action Action executed if the directory loads
+ *    successfully.  By default selects the first item (unless it's a save
+ *    dialog).
  * @param {boolean} initial True if it comes from setupPath and
  *                          false if caused by an user action.
- * @param {DirectoryEntry} dirEntry A new directory entry.
  */
-DirectoryModel.prototype.changeDirectoryEntry_ = function(initial, dirEntry) {
+DirectoryModel.prototype.changeDirectoryEntry_ = function(dirEntry, action,
+                                                          initial) {
   var previous = this.currentDirEntry_;
   this.currentDirEntry_ = dirEntry;
   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;
 
@@ skipping 25 matching lines @@
   var overridden = false;
   function onExternalDirChange() { overridden = true }
   this.addEventListener('directory-changed', onExternalDirChange);
 
   var resolveCallback = function(exists) {
     this.removeEventListener('directory-changed', onExternalDirChange);
     if (opt_pathResolveCallback)
       opt_pathResolveCallback(baseName, leafName, exists && !overridden);
   }.bind(this);
 
-  var changeDirectoryEntry = function(entry, initial, exists) {
+  var changeDirectoryEntry = function(entry, callback, initial, exists) {
     resolveCallback(exists);
     if (!overridden)
-      this.changeDirectoryEntry_(initial, entry);
+      this.changeDirectoryEntry_(entry, callback, initial);
   }.bind(this);
 
   var INITIAL = true;
   var EXISTS = true;
 
   // Split the dirname from the basename.
   var ary = path.match(/^(?:(.*)\/)?([^\/]*)$/);
+  var autoSelect = function() {
+    this.selectIndex(this.autoSelectIndex_);
+    if (opt_loadedCallback)
+      opt_loadedCallback();
+  }.bind(this);
 
   if (!ary) {
     console.warn('Unable to split default path: ' + path);
-    changeDirectoryEntry(this.root_, INITIAL, !EXISTS);
+    changeDirectoryEntry(this.root_, autoSelect, INITIAL, !EXISTS);
     return;
   }
 
   var baseName = ary[1];
   var leafName = ary[2];
 
   function onLeafFound(baseDirEntry, leafEntry) {
     if (leafEntry.isDirectory) {
       baseName = path;
       leafName = '';
-      changeDirectoryEntry(leafEntry, INITIAL, EXISTS);
+      changeDirectoryEntry(leafEntry, autoSelect, INITIAL, EXISTS);
       return;
     }
 
     // Leaf is an existing file, cd to its parent directory and select it.
     changeDirectoryEntry(baseDirEntry,
                          function() {
                            this.selectEntry(leafEntry.name);
                            if (opt_loadedCallback)
                              opt_loadedCallback();
                          }.bind(this),
                          !INITIAL /*HACK*/,
                          EXISTS);
     // TODO(kaznacheev): Fix history.replaceState for the File Browser and
     // change !INITIAL to INITIAL. Passing |false| makes things
     // less ugly for now.
   }
 
   function onLeafError(baseDirEntry, err) {
     // Usually, leaf does not exist, because it's just a suggested file name.
     if (err.code != FileError.NOT_FOUND_ERR)
       console.log('Unexpected error resolving default leaf: ' + err);
-    changeDirectoryEntry(baseDirEntry, INITIAL, !EXISTS);
+    changeDirectoryEntry(baseDirEntry, autoSelect, INITIAL, !EXISTS);
   }
 
   var onBaseError = function(err) {
     console.log('Unexpected error resolving default base "' +
                 baseName + '": ' + err);
     if (path != this.getDefaultDirectory()) {
       // Can't find the provided path, let's go to default one instead.
       resolveCallback(!EXISTS);
       if (!overridden)
         this.setupDefaultPath(opt_loadedCallback);
     } else {
       // Well, we can't find the downloads dir. Let's just show something,
       // or we will get an infinite recursion.
       changeDirectoryEntry(this.root_, opt_loadedCallback, INITIAL, !EXISTS);
     }
   }.bind(this);
 
   var onBaseFound = function(baseDirEntry) {
     if (!leafName) {
       // Default path is just a directory, cd to it and we're done.
-      changeDirectoryEntry(baseDirEntry, INITIAL, !EXISTS);
+      changeDirectoryEntry(baseDirEntry, autoSelect, INITIAL, !EXISTS);
       return;
     }
 
     util.resolvePath(this.root_, path,
                      onLeafFound.bind(this, baseDirEntry),
                      onLeafError.bind(this, baseDirEntry));
   }.bind(this);
 
   var root = this.root_;
   if (!baseName)
@@ skipping 434 matching lines @@
 /**
  * @private
  */
 DirectoryModel.Scanner.prototype.recordMetrics_ = function() {
   metrics.recordInterval('DirectoryScan');
   if (this.dir_.fullPath ==
       '/' + DirectoryModel.DOWNLOADS_DIRECTORY) {
     metrics.recordMediumCount('DownloadsCount', this.list_.length);
   }
 };