Files.app: Fix flakiness in chaining directory

ui/file_manager/file_manager/foreground/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.
 
 'use strict';
 
 // 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.
@@ skipping 14 matching lines @@
                         metadataCache, volumeManager) {
   this.fileListSelection_ = singleSelection ?
       new cr.ui.ListSingleSelectionModel() : new cr.ui.ListSelectionModel();
 
   this.runningScan_ = null;
   this.pendingScan_ = null;
   this.rescanTime_ = null;
   this.scanFailures_ = 0;
   this.changeDirectorySequence_ = 0;
 
+  this.directoryChangeQueue_ = new AsyncUtil.Queue();
+
   this.fileFilter_ = fileFilter;
   this.fileFilter_.addEventListener('changed',
                                     this.onFilterChanged_.bind(this));
 
   this.currentFileListContext_ = new FileListContext(
       fileFilter, metadataCache);
   this.currentDirContents_ =
       DirectoryContents.createForDirectory(this.currentFileListContext_, null);
 
   this.metadataCache_ = metadataCache;
@@ skipping 226 matching lines @@
  * a single refresh.
  * @param {number} delay Delay in ms after which the rescan will be performed.
  */
 DirectoryModel.prototype.scheduleRescan = function(delay) {
   if (this.rescanTime_) {
     if (this.rescanTime_ <= Date.now() + delay)
       return;
     clearTimeout(this.rescanTimeoutId_);
   }
 
+  var sequence = this.changeDirectorySequence_;
+
   this.rescanTime_ = Date.now() + delay;
-  this.rescanTimeoutId_ = setTimeout(this.rescan.bind(this), delay);
+  this.rescanTimeoutId_ = setTimeout(function() {
+    this.rescanTimeoutId_ = null;
+    tracker.stop();

[hirono, 2014/06/02 11:52:07]

Remaining line.

[yoshiki, 2014/06/04 13:46:41]

Done.

+    if (sequence !== this.changeDirectorySequence_)
+      this.rescan();
+  }.bind(this), delay);
 };
 
 /**
  * Cancel a rescan on timeout if it is scheduled.
  * @private
  */
 DirectoryModel.prototype.clearRescanTimeout_ = function() {
   this.rescanTime_ = null;
   if (this.rescanTimeoutId_) {
     clearTimeout(this.rescanTimeoutId_);
@@ skipping 12 matching lines @@
 DirectoryModel.prototype.rescan = function() {
   this.clearRescanTimeout_();
   if (this.runningScan_) {
     this.pendingRescan_ = true;
     return;
   }
 
   var dirContents = this.currentDirContents_.clone();
   dirContents.setFileList([]);
 
+  var sequence = this.changeDirectorySequence_;
+
   var successCallback = (function() {
-    this.replaceDirectoryContents_(dirContents);
+    if (sequence !== this.changeDirectorySequence_)
+      this.replaceDirectoryContents_(dirContents);
     cr.dispatchSimpleEvent(this, 'rescan-completed');
   }).bind(this);
 
   this.scan_(dirContents,
              successCallback, function() {}, function() {}, function() {});
 };
 
 /**
  * Run scan on the current DirectoryContents. The active fileList is cleared and
  * the entries are added directly.
  *
  * This should be used when changing directory or initiating a new search.
  *
  * @param {DirectoryContentes} newDirContents New DirectoryContents instance to
  *     replace currentDirContents_.
- * @param {function()=} opt_callback Called on success.
+ * @param {function(boolean)} callback Callback with result. True if the scan
+ *     is completed successfully, false if the scan is failed.
  * @private
  */
 DirectoryModel.prototype.clearAndScan_ = function(newDirContents,
-                                                  opt_callback) {
+                                                  callback) {
   if (this.currentDirContents_.isScanning())
     this.currentDirContents_.cancelScan();
   this.currentDirContents_ = newDirContents;
   this.clearRescanTimeout_();
 
   if (this.pendingScan_)
     this.pendingScan_ = false;
 
   if (this.runningScan_) {
     if (this.runningScan_.isScanning())
       this.runningScan_.cancelScan();
     this.runningScan_ = null;
   }
 
+  var sequence = this.changeDirectorySequence_;
+  var cancelled = false;
+
   var onDone = function() {
+    if (cancelled)
+      return;
+
     cr.dispatchSimpleEvent(this, 'scan-completed');
-    if (opt_callback)
-      opt_callback();
+    callback(true);
   }.bind(this);
 
   var onFailed = function() {
+    if (cancelled)
+      return;
+
     cr.dispatchSimpleEvent(this, 'scan-failed');
+    callback(false);
   }.bind(this);
 
   var onUpdated = function() {
+    if (cancelled)
+      return;
+
+    if (this.changeDirectorySequence_ !== sequence) {
+      cancelled = true;
+      cr.dispatchSimpleEvent(this, 'scan-cancelled');
+      callback(false);
+      return;
+    }
+
     cr.dispatchSimpleEvent(this, 'scan-updated');
   }.bind(this);
 
   var onCancelled = function() {
+    if (cancelled)
+      return;
+
+    cancelled = true;
     cr.dispatchSimpleEvent(this, 'scan-cancelled');
+    callback(false);
   }.bind(this);
 
   // Clear the table, and start scanning.
   cr.dispatchSimpleEvent(this, 'scan-started');
   var fileList = this.getFileList();
   fileList.splice(0, fileList.length);
   this.scan_(this.currentDirContents_,
              onDone, onFailed, onUpdated, onCancelled);
 };
 
@@ skipping 218 matching lines @@
                                                     errorCallback,
                                                     abortCallback) {
   // Obtain and check the current directory.
   var entry = this.getCurrentDirEntry();
   if (!entry || this.isSearching()) {
     errorCallback(util.createDOMError(
         util.FileError.INVALID_MODIFICATION_ERR));
     return;
   }
 
-  var tracker = this.createDirectoryChangeTracker();
-  tracker.start();
+  var sequence = this.changeDirectorySequence_;
 
   new Promise(entry.getDirectory.bind(
       entry, name, {create: true, exclusive: true})).
 
       then(function(newEntry) {
         // Refresh the cache.
         this.metadataCache_.clear([newEntry], '*');
         return new Promise(function(onFulfilled, onRejected) {
           this.metadataCache_.get([newEntry],
                                   'filesystem',
                                   onFulfilled.bind(null, newEntry));
         }.bind(this));
       }.bind(this)).
 
       then(function(newEntry) {
         // Do not change anything or call the callback if current
         // directory changed.
-        tracker.stop();
-        if (tracker.hasChanged) {
+        if (this.changeDirectorySequence_ !== sequence) {
           abortCallback();
           return;
         }
 
         // If target directory is already in the list, just select it.
         var existing = this.getFileList().slice().filter(
             function(e) { return e.name === name; });
         if (existing.length) {
           this.selectEntry(newEntry);
           successCallback(existing[0]);
         } else {
           this.fileListSelection_.beginChange();
           this.getFileList().splice(0, 0, newEntry);
           this.selectEntry(newEntry);
           this.fileListSelection_.endChange();
           successCallback(newEntry);
         }
       }.bind(this), function(reason) {
         tracker.stop();

[hirono, 2014/06/02 11:52:07]

ditto.

[yoshiki, 2014/06/04 13:46:41]

Done.

         errorCallback(reason);
       });
 };
 
 /**
  * Changes the current directory to the directory represented by
  * a DirectoryEntry or a fake entry.
  *
  * Dispatches the 'directory-changed' event when the directory is successfully
  * changed.
  *
  * Note : if this is called from UI, please consider to use DirectoryModel.
  * activateDirectoryEntry instead of this, which is higher-level function and
  * cares about the selection.
  *
  * @param {DirectoryEntry|Object} dirEntry The entry of the new directory to
  *     be opened.
  * @param {function()=} opt_callback Executed if the directory loads
  *     successfully.
  */
 DirectoryModel.prototype.changeDirectoryEntry = function(
     dirEntry, opt_callback) {
   // Increment the sequence value.
   this.changeDirectorySequence_++;
   this.clearSearch_();
 
-  var promise = new Promise(
-      function(onFulfilled, onRejected) {
-        this.fileWatcher_.changeWatchedDirectory(dirEntry, onFulfilled);
-      }.bind(this)).
-
-      then(function(sequence) {
-        return new Promise(function(onFulfilled, onRejected) {
-          if (this.changeDirectorySequence_ !== sequence)
+  this.directoryChangeQueue_.run(function(sequence, queueTaskCallback) {
+    this.fileWatcher_.changeWatchedDirectory(
+        dirEntry,
+        function() {
+          if (this.changeDirectorySequence_ !== sequence) {
+            callback();
             return;
+          }
 
           var newDirectoryContents = this.createDirectoryContents_(
               this.currentFileListContext_, dirEntry, '');
-          if (!newDirectoryContents)
+          if (!newDirectoryContents) {
+            callback();
             return;
+          }
 
-          var previousDirEntry = this.currentDirContents_.getDirectoryEntry();
-          this.clearAndScan_(newDirectoryContents, opt_callback);
+          var previousDirEntry =
+              this.currentDirContents_.getDirectoryEntry();
+          this.clearAndScan_(
+              newDirectoryContents,
+              function(result) {
+                // Calls the callback of the method when successful.
+                if (result && opt_callback)
+                  opt_callback();
 
-          // For tests that open the dialog to empty directories, everything is
-          // loaded at this point.
+                // Notify that the current task of this.directoryChangeQueue_
+                // is completed.
+                setTimeout(queueTaskCallback);
+              });
+
+          // For tests that open the dialog to empty directories, everything
+          // is loaded at this point.
           util.testSendMessage('directory-change-complete');
 
           var event = new Event('directory-changed');
           event.previousDirEntry = previousDirEntry;
           event.newDirEntry = dirEntry;
           this.dispatchEvent(event);
         }.bind(this));
-      }.bind(this, this.changeDirectorySequence_));
+  }.bind(this, this.changeDirectorySequence_));
 };
 
 /**
  * Activates the given directry.
  * This method:
  *  - Changes the current directory, if the given directory is the current
  *    directory.
  *  - Clears the selection, if the given directory is the current directory.
  *
  * @param {DirectoryEntry|Object} dirEntry The entry of the new directory to
@@ skipping 187 matching lines @@
 DirectoryModel.prototype.search = function(query,
                                            onSearchRescan,
                                            onClearSearch) {
   this.clearSearch_();
   var currentDirEntry = this.getCurrentDirEntry();
   if (!currentDirEntry) {
     // Not yet initialized. Do nothing.
     return;
   }
 
-  if (!(query || '').trimLeft()) {
-    if (this.isSearching()) {
-      var newDirContents = this.createDirectoryContents_(
-          this.currentFileListContext_,
-          currentDirEntry);
-      this.clearAndScan_(newDirContents);
+  this.changeDirectorySequence_++;
+  this.directoryChangeQueue_.run(function(sequence, callback) {
+    if (this.changeDirectorySequence_ !== sequence) {
+      callback();
+      return;
     }
-    return;
-  }
 
-  var newDirContents = this.createDirectoryContents_(
-      this.currentFileListContext_, currentDirEntry, query);
-  if (!newDirContents)
-    return;
+    if (!(query || '').trimLeft()) {
+      if (this.isSearching()) {
+        var newDirContents = this.createDirectoryContents_(
+            this.currentFileListContext_,
+            currentDirEntry);
+        this.clearAndScan_(newDirContents,
+                           sequence,
+                           callback);
+      } else {
+        callback();
+      }
+      return;
+    }
 
-  this.onSearchCompleted_ = onSearchRescan;
-  this.onClearSearch_ = onClearSearch;
-  this.addEventListener('scan-completed', this.onSearchCompleted_);
-  this.clearAndScan_(newDirContents);
+    var newDirContents = this.createDirectoryContents_(
+        this.currentFileListContext_, currentDirEntry, query);
+    if (!newDirContents) {
+      callback();
+      return;
+    }
+
+    this.onSearchCompleted_ = onSearchRescan;
+    this.onClearSearch_ = onClearSearch;
+    this.addEventListener('scan-completed', this.onSearchCompleted_);
+    this.clearAndScan_(newDirContents,
+                       sequence,
+                       callback);
+  }.bind(this, this.changeDirectorySequence_));
 };
 
 /**
  * In case the search was active, remove listeners and send notifications on
  * its canceling.
  * @private
  */
 DirectoryModel.prototype.clearSearch_ = function() {
   if (!this.isSearching())
     return;
 
   if (this.onSearchCompleted_) {
     this.removeEventListener('scan-completed', this.onSearchCompleted_);
     this.onSearchCompleted_ = null;
   }
 
   if (this.onClearSearch_) {
     this.onClearSearch_();
     this.onClearSearch_ = null;
   }
 };