Tweaks for improving file manager performance

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
 const SIMULTANEOUS_RESCAN_INTERVAL = 1000;
 
 /**
  * Data model of the file manager.
@@ skipping 502 matching lines @@
     this.updateRootsListSelection_();
     this.scan_(onRescanComplete);
 
     var e = new cr.Event('directory-changed');
     e.previousDirEntry = this.currentEntry;
     e.newDirEntry = dirEntry;
     e.initial = initial;
     this.dispatchEvent(e);
   },
 
-  setupPath: function(path, opt_pathResolveCallback, opt_fileSelectCallback) {
+  /**
+   * Change the state of the model to reflect the specified path (either a
+   * file or directory).
+   *
+   * @param {string} path The root path to use
+   * @param {Function=} opt_loadedCallback Invoked when the entire directory
+   *     has been loaded and any default file selected.
+   * @param {Function=} opt_pathResolveCallback Invoked as soon as the path has
+   *     been resolved, and called with the base and leaf portions of the path
+   *     name, and a flag indicating if the entry exists.
+   */
+  setupPath: function(path, opt_loadedCallback, opt_pathResolveCallback) {
     // Split the dirname from the basename.
     var ary = path.match(/^(?:(.*)\/)?([^\/]*)$/);
-    var autoSelect = this.selectIndex.bind(this, this.autoSelectIndex_);
+    var autoSelect = function() {
+          this.selectIndex(this.autoSelectIndex_);
+          if (opt_loadedCallback)
+            opt_loadedCallback();
+    }.bind(this);
+
     if (!ary) {
       console.warn('Unable to split default path: ' + path);
       this.changeDirectoryEntry_(this.root_, autoSelect, true);
       return;
     }
 
     var baseName = ary[1];
     var leafName = ary[2];
 
     function resolveCallback(exists) {
       if (opt_pathResolveCallback)
         opt_pathResolveCallback(baseName, leafName, exists);
     }
 
     function onLeafFound(baseDirEntry, leafEntry) {
       if (leafEntry.isDirectory) {
         baseName = path;
         leafName = '';
         resolveCallback(true);
         this.changeDirectoryEntry_(leafEntry, autoSelect, true);
         return;
       }
 
       resolveCallback(true);
       // Leaf is an existing file, cd to its parent directory and select it.
       this.changeDirectoryEntry_(baseDirEntry,
                                  function() {
                                    this.selectEntry(leafEntry.name);
-                                   if (opt_fileSelectCallback)
-                                     opt_fileSelectCallback();
+                                   if (opt_loadedCallback)

[Vladislav Kaznacheev, 2012/02/29 21:04:48]

opt_loadedCallback has different semantic from the old opt_fileSelectCallback. I
expect this breaks some things in the file browser. Specifically,
opt_fileSelectCallback should be called only from this one place (when the file
is successfully selected).

[Rick Byers, 2012/03/02 00:19:46]

Thanks.  So you want to handle the case where the path specifies an existing
leaf note.  Rather than have a special callback for that, it looks like we
already communicate (and make sure of) that information in the onResolve
callback.  How about I just keep track of whether a leaf was found in onResolve?
 Alternately I could pass the base/leaf names again in the onLoaded callback.

+                                     opt_loadedCallback();
                                  }.bind(this),
                                  false /*HACK*/);
       // TODO(kaznacheev): Fix history.replaceState for the File Browser and
       // change the last parameter back to |true|. Passing |false| makes things
       // less ugly for now.
     }
 
     function onLeafError(baseDirEntry, err) {
       resolveCallback(false);
       // Usually, leaf does not exist, because it's just a suggested file name.
       if (err != FileError.NOT_FOUND_ERR)
         console.log('Unexpected error resolving default leaf: ' + err);
       this.changeDirectoryEntry_(baseDirEntry, autoSelect, true);
     }
 
     var onBaseError = function(err) {
       resolveCallback(false);
       console.log('Unexpected error resolving default base "' +
                   baseName + '": ' + err);
       if (path != '/' + DirectoryModel.DOWNLOADS_DIRECTORY) {
         // Can't find the provided path, let's go to default one instead.
-        this.setupDefaultPath();
+        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.
-        this.changeDirectory('/', undefined, true);
+        this.changeDirectory('/', opt_loadedCallback, true);
       }
     }.bind(this);
 
     var onBaseFound = function(baseDirEntry) {
       if (!leafName) {
         // Default path is just a directory, cd to it and we're done.
         this.changeDirectoryEntry_(baseDirEntry, autoSelect, true);
         return;
       }
 
       util.resolvePath(this.root_, path,
                        onLeafFound.bind(this, baseDirEntry),
                        onLeafError.bind(this, baseDirEntry));
     }.bind(this);
 
     var root = this.root_;
     if (baseName) {
       root.getDirectory(
           baseName, {create: false}, onBaseFound, onBaseError);
     } else {
       this.getDefaultDirectory_(function(defaultDir) {
         baseName = defaultDir;
         root.getDirectory(
             baseName, {create: false}, onBaseFound, onBaseError);
       });
     }
   },
 
-  setupDefaultPath: function() {
-    this.getDefaultDirectory_(this.setupPath.bind(this));
+  setupDefaultPath: function(opt_callback) {
+    this.getDefaultDirectory_(function(path) {
+      this.setupPath(path, opt_callback);
+    }.bind(this));
   },
 
   getDefaultDirectory_: function(callback) {
     function onGetDirectoryComplete(entries, error) {
       if (entries.length > 0)
         callback(entries[0].fullPath);
       else
         callback('/' + DirectoryModel.DOWNLOADS_DIRECTORY);
     }
 
@@ skipping 124 matching lines @@
     root.getDirectory(DirectoryModel.DOWNLOADS_DIRECTORY, { create: false },
                       onDownloads, onDownloadsError);
     util.readDirectory(root, DirectoryModel.ARCHIVE_DIRECTORY,
                        append.bind(this, 'archives'));
     util.readDirectory(root, DirectoryModel.REMOVABLE_DIRECTORY,
                        append.bind(this, 'removables'));
     root.getDirectory(DirectoryModel.GDATA_DIRECTORY, { create: false },
                       onGData, onGDataError);
   },
 
-  updateRoots: function(opt_changeDirectoryTo) {
+  updateRoots: function(opt_callback) {
     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_();
-
-      if (opt_changeDirectoryTo)
-        self.changeDirectory(opt_changeDirectoryTo);
+      if (opt_callback)
+        opt_callback();
     });
   },
 
   onRootsSelectionChanged_: function(event) {
     var root = this.rootsList.item(this.rootsListSelection.selectedIndex);
     var current = this.currentEntry.fullPath;
     if (root && this.rootPath != root.fullPath)
       this.changeDirectory(root.fullPath);
   },
 
@@ skipping 129 matching lines @@
 
   recordMetrics_: function() {
     metrics.recordInterval('DirectoryScan');
     if (this.dir_.fullPath ==
         '/' + DirectoryModel.DOWNLOADS_DIRECTORY) {
       metrics.recordMediumCount("DownloadsCount", this.list_.length);
     }
   }
 };