Not selecting first entry in the "File save" dialog.

chrome/browser/resources/file_manager/js/file_manager.js

 // Copyright (c) 2011 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.
 
 // Setting the src of an img to an empty string can crash the browser, so we
 // use an empty 1x1 gif instead.
 const EMPTY_IMAGE_URI = 'data:image/gif;base64,'
         + 'R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw%3D%3D';
 
 var g_slideshow_data = null;
@@ skipping 1393 matching lines @@
         return;
       }
 
       function onLeafFound(leafEntry) {
         if (leafEntry.isDirectory) {
           self.changeDirectoryEntry(leafEntry, CD_NO_HISTORY);
           return;
         }
 
         // Leaf is an existing file, cd to its parent directory and select it.
-        self.changeDirectoryEntry(baseDirEntry, CD_NO_HISTORY, leafEntry.name);
+        self.changeDirectoryEntry(baseDirEntry, CD_NO_HISTORY, function() {
+          self.selectEntry(leafEntry.name);
+        });
       }
 
       function onLeafError(err) {
         // Set filename first so OK button will update in changeDirectoryEntry.
         self.filenameInput_.value = leafName;
         if (err = FileError.NOT_FOUND_ERR) {
           // Leaf does not exist, it's just a suggested file name.
           self.changeDirectoryEntry(baseDirEntry, CD_NO_HISTORY);
         } else {
           console.log('Unexpected error resolving default leaf: ' + err);
@@ skipping 81 matching lines @@
       cacheFunction = cacheEntrySize;
     } else if (field == 'type') {
       cacheFunction = this.cacheEntryFileType.bind(this);
     } else if (field == 'cachedIconType_') {
       cacheFunction = this.cacheEntryIconType.bind(this);
     } else {
       setTimeout(callback, 0);
       return;
     }
 
-    function checkCount() {
-      if (uncachedCount == 0) {
-        // Callback via a setTimeout so the sync/async semantics don't change
-        // based on whether or not the value is cached.
-        setTimeout(callback, 0);
+    // Start one fake wait to prevent calling the callback twice.
+    var waitCount = 1;
+    for (var i = 0; i < entries.length ; i++) {
+      var entry = entries[i];
+      if (!(field in entry)) {
+        waitCount++;
+        cacheFunction(entry, onCacheDone)
       }
     }
+    onCacheDone();  // Finish the fake callback.
 
-    var uncachedCount = entries.length;
-
-    for (var i = uncachedCount - 1; i >= 0 ; i--) {
-      var entry = entries[i];
-      if (field in entry) {
-        uncachedCount--;
-      } else {
-        cacheFunction(entry, function() {
-          uncachedCount--;
-          checkCount();
-        });
-      }
+    function onCacheDone() {
+      waitCount--;
+      // If all caching functions finished synchronously or entries.length = 0
+      // call the callback synchronously.
+      if (waitCount == 0)
+        setTimeout(callback, 0);
     }
-
-    checkCount();
   }
 
   /**
    * Render (and wire up) a checkbox to be used in either a detail or a
    * thumbnail list item.
    */
   FileManager.prototype.renderCheckbox_ = function(entry) {
     var input = this.document_.createElement('input');
     input.setAttribute('type', 'checkbox');
     input.setAttribute('tabindex', -1);
@@ skipping 1077 matching lines @@
   /**
    * Change the current directory to the directory represented by a
    * DirectoryEntry.
    *
    * Dispatches the 'directory-changed' event when the directory is successfully
    * changed.
    *
    * @param {string} path The absolute path to the new directory.
    * @param {bool} opt_saveHistory Save this in the history stack (defaults
    *     to true).
-   * @param {string} opt_selectedEntry The name of the file to select after
-   *     changing directories.
+   * @param {function} opt_action Action executed when the directory loaded.
+   *                              By default selects the first item
+   *                              (unless it's a save dialog).
    */
   FileManager.prototype.changeDirectoryEntry = function(dirEntry,
                                                         opt_saveHistory,
-                                                        opt_selectedEntry,
-                                                        opt_callback) {
+                                                        opt_action) {
     if (typeof opt_saveHistory == 'undefined') {
       opt_saveHistory = true;
     } else {
       opt_saveHistory = !!opt_saveHistory;
     }
 
+    var action = opt_action ||
+        (this.dialogType_ == FileManager.DialogType.SELECT_SAVEAS_FILE ?
+            undefined : this.selectIndex.bind(this, 0));
+
     var location = document.location.origin + document.location.pathname + '#' +
                    encodeURI(dirEntry.fullPath);
     if (opt_saveHistory) {
       history.pushState(undefined, dirEntry.fullPath, location);
     } else if (window.location.hash != location) {
       // If the user typed URL manually that is not canonical it would be fixed
       // here. However it seems history.replaceState doesn't work properly
       // with rewritable URLs (while does with history.pushState). It changes
       // window.location but doesn't change content of the ombibox.
       history.replaceState(undefined, dirEntry.fullPath, location);
     }
 
     if (this.currentDirEntry_ &&
         this.currentDirEntry_.fullPath == dirEntry.fullPath) {
       // Directory didn't actually change.
-      if (opt_selectedEntry)
-        this.selectEntry(opt_selectedEntry);
-      else
-        this.selectIndex(0);
+      if (opt_action)
+        opt_action();
       return;
     }
 
     var e = new cr.Event('directory-changed');
     e.previousDirEntry = this.currentDirEntry_;
     e.newDirEntry = dirEntry;
     e.saveHistory = opt_saveHistory;
-    e.selectedEntry = opt_selectedEntry;
-    e.opt_callback = opt_callback;
+    e.opt_callback = action;
     this.currentDirEntry_ = dirEntry;
     this.dispatchEvent(e);
   }
 
   /**
    * Change the current directory to the directory represented by a string
    * path.
    *
    * Dispatches the 'directory-changed' event when the directory is successfully
    * changed.
    *
    * @param {string} path The absolute path to the new directory.
    * @param {bool} opt_saveHistory Save this in the history stack (defaults
    *     to true).
    * @param {string} opt_selectedEntry The name of the file to select after
    *     changing directories.
    */
   FileManager.prototype.changeDirectory = function(path,
-                                                   opt_saveHistory,
-                                                   opt_selectedEntry,
-                                                   opt_callback) {
+                                                   opt_saveHistory) {
     if (path == '/')
       return this.changeDirectoryEntry(this.filesystem_.root,
-                                       opt_saveHistory,
-                                       opt_selectedEntry,
-                                       opt_callback);
+                                       opt_saveHistory);
 
     var self = this;
-
     this.filesystem_.root.getDirectory(
         path, {create: false},
         function(dirEntry) {
-          self.changeDirectoryEntry(
-              dirEntry, opt_saveHistory, opt_selectedEntry, opt_callback);
+          self.changeDirectoryEntry(dirEntry, opt_saveHistory);
         },
         function(err) {
           console.error('Error changing directory to: ' + path + ', ' + err);
           if (self.currentDirEntry_) {
             var location = '#' + encodeURI(self.currentDirEntry_.fullPath);
             history.replaceState(undefined,
                                  self.currentDirEntry_.fullPath,
                                  location);
           } else {
             // If we've never successfully changed to a directory, force them
             // to the root.
-            self.changeDirectory('/', false);
+            self.changeDirectory('/', CD_NO_HISTORY);
           }
         });
   };
 
   FileManager.prototype.deleteEntries = function(entries, force, opt_callback) {
     if (!force) {
       var self = this;
       var msg;
       if (entries.length == 1) {
         msg = strf('CONFIRM_DELETE_ONE', entries[0].name);
@@ skipping 340 matching lines @@
       this.subscribedOnDirectoryChanges_ = true;
       chrome.fileBrowserPrivate.addFileWatch(event.newDirEntry.toURL(),
         function(result) {
           if (!result) {
             console.log('Failed to add file watch');
           }
       });
     }
 
     this.rescanDirectory_(function() {
-        if (event.selectedEntry)
-          self.selectEntry(event.selectedEntry);
-        else
-          self.selectIndex(0);
         if (event.opt_callback) {
           try {
             event.opt_callback();
           } catch (ex) {
             console.error('Caught exception while inovking callback: ', ex);
           }
         }
         // For tests that open the dialog to empty directories, everything
         // is loaded at this point.
         chrome.test.sendMessage('directory-change-complete');
@@ skipping 893 matching lines @@
           });
       }, onError);
 
       function onError(err) {
         console.log('Error while checking free space: ' + err);
         setTimeout(doCheck, 1000 * 60);
       }
     }
   }
 })();