Cancel scans when directory changed.

ui/file_manager/file_manager/foreground/js/import_controller.js

 // Copyright 2014 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.
 
 // Namespace
 var importer = importer || {};
 
 /** @private @enum {string} */
 importer.ActivityState = {
   READY: 'ready',
@@ skipping 62 matching lines @@
 
   var listener = this.onScanEvent_.bind(this);
   this.scanner_.addObserver(listener);
   // Remove the observer when the foreground window is closed.
   window.addEventListener(
       'pagehide',
       function() {
         this.scanner_.removeObserver(listener);
       }.bind(this));
 
+  this.environment_.addWindowCloseListener(
+      this.onWindowClosing_.bind(this));
+
   this.environment_.addVolumeUnmountListener(
       this.onVolumeUnmounted_.bind(this));
 
   this.environment_.addDirectoryChangedListener(
       this.onDirectoryChanged_.bind(this));
 
   this.environment_.addSelectionChangedListener(
       this.onSelectionChanged_.bind(this));
 
   this.commandWidget_.addClickListener(
@@ skipping 28 matching lines @@
  *
  * @private
  */
 importer.ImportController.prototype.onScanEvent_ = function(event, scan) {
   if (!this.scanManager_.isActiveScan(scan)) {
     return;
   }
 
   switch (event) {
     case importer.ScanEvent.INVALIDATED:
-      this.scanManager_.reset();
+      this.onScanInvalidated_();
     case importer.ScanEvent.FINALIZED:
     case importer.ScanEvent.UPDATED:
       this.checkState_(scan);
       break;
   }
 };
 
+/** @private */
+importer.ImportController.prototype.onWindowClosing_ = function() {
+  this.scanManager_.reset();  // Will cancel any active scans.
+};
+
 /**
  * @param {string} volumeId
  * @private
  */
 importer.ImportController.prototype.onVolumeUnmounted_ = function(volumeId) {
   if (this.activeImport_) {
     this.activeImport_.task.requestCancel();
     this.finalizeActiveImport_();
     this.tracker_.send(metrics.ImportEvents.DEVICE_YANKED);
   }
   this.scanManager_.reset();
   this.checkState_();
 };
 
 /**
  * @param {!Event} event
  * @private
  */
 importer.ImportController.prototype.onDirectoryChanged_ = function(event) {
   if (!event.previousDirEntry &&
       event.newDirEntry &&
       importer.isMediaDirectory(event.newDirEntry, this.environment_)) {
     this.commandWidget_.setDetailsVisible(true);
   }
-  this.scanManager_.clearSelectionScan();
+
+  this.scanManager_.reset();
   if (this.isCurrentDirectoryScannable_()) {
     this.checkState_(
-        this.scanManager_.getCurrentDirectoryScan());
+        this.scanManager_.getDirectoryScan());
   } else {
     this.checkState_();
   }
 };
 
 /** @private */
 importer.ImportController.prototype.onSelectionChanged_ = function() {
+  // NOTE: Empty selection changed events can and will fire for a directory
+  // before we receive the the corresponding directory changed event
+  // and when the selection is empty. These are spurios events
+  // and we ignore them.
+  if (!this.scanManager_.hasSelectionScan() &&
+      this.environment_.getSelection().length === 0) {
+    return;
+  }
+
   // NOTE: We clear the scan here, but don't immediately initiate
   // a new scan. checkState will attempt to initialize the scan
   // during normal processing.
   // Also, in the case the selection is transitioning to empty,
   // we want to reinstate the underlying directory scan (if
   // in fact, one is possible).
   this.scanManager_.clearSelectionScan();
   if (this.environment_.getSelection().length === 0 &&
       this.isCurrentDirectoryScannable_()) {
     this.checkState_(
-        this.scanManager_.getCurrentDirectoryScan());
+        this.scanManager_.getDirectoryScan());
   } else {
     this.checkState_();
   }
 };
 
 /**
  * @param {!importer.MediaImportHandler.ImportTask} task
  * @private
  */
 importer.ImportController.prototype.onImportFinished_ = function(task) {
   this.finalizeActiveImport_();
   this.scanManager_.reset();
   this.storage_.set(importer.Setting.HAS_COMPLETED_IMPORT, true);
   this.commandWidget_.setDetailsBannerVisible(false);
   this.checkState_();
 };
 
+/** @private */
+importer.ImportController.prototype.onScanInvalidated_ = function() {
+  this.scanManager_.reset();
+  if (this.environment_.getSelection().length === 0 &&
+      this.isCurrentDirectoryScannable_()) {
+    this.checkState_(
+        this.scanManager_.getDirectoryScan());
+  } else {
+    this.checkState_();
+  }
+};
+
 /**
  * Does book keeping necessary to finalize the active task.
  * @private
  */
 importer.ImportController.prototype.finalizeActiveImport_ = function() {
   console.assert(!!this.activeImport_,
       'Cannot finish import when none is running.');
   this.previousImport_ = this.activeImport_;
   this.activeImport_ = null;
 };
@@ skipping 63 matching lines @@
   var taskFinished = this.onImportFinished_.bind(this, importTask);
   importTask.whenFinished.then(taskFinished).catch(taskFinished);
   this.checkState_();
 };
 
 /**
  * Cancels the active task.
  * @private
  */
 importer.ImportController.prototype.cancel_ = function() {
-  this.activeImport_.task.requestCancel();
-  this.finalizeActiveImport_();
-  this.tracker_.send(metrics.ImportEvents.IMPORT_CANCELLED);
+  if (this.activeImport_) {
+    this.activeImport_.task.requestCancel();
+    this.finalizeActiveImport_();
+    this.tracker_.send(metrics.ImportEvents.IMPORT_CANCELLED);
+  }
 
   this.scanManager_.reset();
   this.checkState_();
 };
 
 /**
  * Checks the environment and updates UI as needed.
  * @param {importer.ScanResult=} opt_scan If supplied,
  * @private
  */
@@ skipping 106 matching lines @@
 
 /**
  * Attempts to scan the current context.
  *
  * @return {importer.ScanResult} A scan object,
  *     or null if scan is not possible in current context.
  * @private
  */
 importer.ImportController.prototype.tryScan_ = function() {
   var entries = this.environment_.getSelection();
-
   if (entries.length) {
     if (entries.every(
         importer.isEligibleEntry.bind(null, this.environment_))) {
       return this.scanManager_.getSelectionScan(entries);
     }
   } else if (this.isCurrentDirectoryScannable_()) {
-    return this.scanManager_.getCurrentDirectoryScan();
+    return this.scanManager_.getDirectoryScan();
   }
 
   return null;
 };
 
 /**
  * Class that adapts from the new non-command button to the old
  * command style interface.
  *
  * @interface
@@ skipping 363 matching lines @@
  */
 importer.ScanManager = function(environment, scanner) {
 
   /** @private {!importer.ControllerEnvironment} */
   this.environment_ = environment;
 
   /** @private {!importer.MediaScanner} */
   this.scanner_ = scanner;
 
   /**
-   * A cache of selection scans by directory (url).
+   * The active files scan, if any.
    *
    * @private {importer.ScanResult}
    */
   this.selectionScan_ = null;
 
   /**
-   * A cache of scans by directory (url).
+   * The active directory scan, if any.
    *
-   * @private {!Object.<string, !importer.ScanResult>}
+   * @private {importer.ScanResult}
    */
-  this.directoryScans_ = {};
+  this.directoryScan_ = null;
 };
 
 /**
- * Forgets all scans.
+ * Cancels and forgets all scans.
  */
 importer.ScanManager.prototype.reset = function() {
   this.clearSelectionScan();
-  this.clearDirectoryScans();
+  this.clearDirectoryScan();
 };
 
 /**
- * Forgets the selection scans for the current directory.
+ * @return {boolean} True if we have an existing selection scan.
+ */
+importer.ScanManager.prototype.hasSelectionScan = function() {
+  return !!this.selectionScan_;
+};
+
+/**
+ * Cancels and forgets the current selection scan, if any.
  */
 importer.ScanManager.prototype.clearSelectionScan = function() {
+  if (this.selectionScan_) {
+    this.selectionScan_.cancel();
+  }
   this.selectionScan_ = null;
 };
 
 /**
- * Forgets directory scans.
+ * Cancels and forgets the current directory scan, if any.
  */
-importer.ScanManager.prototype.clearDirectoryScans = function() {
-  this.directoryScans_ = {};
+importer.ScanManager.prototype.clearDirectoryScan = function() {
+  if (this.directoryScan_) {
+    this.directoryScan_.cancel();
+  }
+  this.directoryScan_ = null;
 };
 
 /**
  * @return {importer.ScanResult} Current active scan, or null
  * if none.
  */
 importer.ScanManager.prototype.getActiveScan = function() {
-  if (!!this.selectionScan_) {
-    return this.selectionScan_;
-  }
-  var directory = this.environment_.getCurrentDirectory();
-  if (directory) {
-    return this.directoryScans_[directory.toURL()];
-  }
-  return null;
+  return this.selectionScan_ || this.directoryScan_;
 };
 
 /**
  * @param {importer.ScanResult} scan
  * @return {boolean} True if scan is the active scan...meaning the current
  *     selection scan or the scan for the current directory.
  */
 importer.ScanManager.prototype.isActiveScan = function(scan) {
-  if (scan === this.selectionScan_) {
-    return true;
-  }
-
-  var directory = this.environment_.getCurrentDirectory();
-  return !!directory &&
-      scan === this.directoryScans_[directory.toURL()];
+  return scan === this.selectionScan_ || scan === this.directoryScan_;
 };
 
 /**
  * Returns the existing selection scan or a new one for the supplied
  * selection.
  *
  * @param {!Array.<!FileEntry>} entries
  *
  * @return {!importer.ScanResult}
  */
 importer.ScanManager.prototype.getSelectionScan = function(entries) {
   console.assert(!this.selectionScan_,
       'Cannot create new selection scan with another in the cache.');
   this.selectionScan_ = this.scanner_.scanFiles(entries);
   return this.selectionScan_;
 };
 
 /**
  * Returns a scan for the directory.
  *
  * @return {importer.ScanResult}
  */
-importer.ScanManager.prototype.getCurrentDirectoryScan = function() {
-  var directory = this.environment_.getCurrentDirectory();
-  if (!directory) {
-    return null;
+importer.ScanManager.prototype.getDirectoryScan = function() {
+  if (!this.directoryScan_) {
+    var directory = this.environment_.getCurrentDirectory();
+    if (directory) {
+      this.directoryScan_ = this.scanner_.scanDirectory(
+          /** @type {!DirectoryEntry} */ (directory));
+    }
   }
-
-  var url = directory.toURL();
-  var scan = this.directoryScans_[url];
-  if (!scan) {
-    scan = this.scanner_.scanDirectory(
-        /** @type {!DirectoryEntry} */ (directory));
-    this.directoryScans_[url] = scan;
-  }
-
-  return scan;
+  return this.directoryScan_;
 };
 
 /**
  * Interface abstracting away the concrete file manager available
  * to commands. By hiding file manager we make it easy to test
  * ImportController.
  *
  * @interface
  * @extends {VolumeManagerCommon.VolumeInfoProvider}
  */
@@ skipping 22 matching lines @@
  */
 importer.ControllerEnvironment.prototype.isGoogleDriveMounted;
 
 /**
  * Returns the available space for the local volume in bytes.
  * @return {!Promise<number>}
  */
 importer.ControllerEnvironment.prototype.getFreeStorageSpace;
 
 /**
+ * Installs a 'window closed' listener. Listener is called just
+ * just before the window is closed. Any business must be
+ * done synchronously.
+ * @param {function()} listener
+ */
+importer.ControllerEnvironment.prototype.addWindowCloseListener;
+
+/**
  * Installs an 'unmount' listener. Listener is called with
  * the corresponding volume id when a volume is unmounted.
  * @param {function(string)} listener
  */
 importer.ControllerEnvironment.prototype.addVolumeUnmountListener;
 
 /**
  * Installs an 'directory-changed' listener. Listener is called when
  * the directory changed.
  * @param {function(!Event)} listener
@@ skipping 84 matching lines @@
 
 /** @override */
 importer.RuntimeControllerEnvironment.prototype.isGoogleDriveMounted =
     function() {
   var drive = this.fileManager_.volumeManager.getCurrentProfileVolumeInfo(
       VolumeManagerCommon.VolumeType.DRIVE);
   return !!drive;
 };
 
 /** @override */
-importer.RuntimeControllerEnvironment.prototype.addVolumeUnmountListener =
-    function(listener) {
-  // TODO(smckay): remove listeners when the page is torn down.
-  chrome.fileManagerPrivate.onMountCompleted.addListener(
-      /**
-       * @param {!MountCompletedEvent} event
-       * @this {importer.RuntimeControllerEnvironment}
-       */
-      function(event) {
-        if (event.eventType === 'unmount') {
-          listener(event.volumeMetadata.volumeId);
-        }
-      });
-};
-
-/** @override */
 importer.RuntimeControllerEnvironment.prototype.getFreeStorageSpace =
     function() {
   // Checking DOWNLOADS returns the amount of available local storage space.
   var localVolumeInfo =
       this.fileManager_.volumeManager.getCurrentProfileVolumeInfo(
           VolumeManagerCommon.VolumeType.DOWNLOADS);
   return new Promise(
       function(resolve, reject) {
         chrome.fileManagerPrivate.getSizeStats(
             localVolumeInfo.volumeId,
             /** @param {Object} stats */
             function(stats) {
               if (stats && !chrome.runtime.lastError) {
                 resolve(stats.remainingSize);
               } else {
                 reject('Failed to ascertain available free space: ' +
                     chrome.runtime.lastError.message ||
                     chrome.runtime.lastError);
               }
             });
       });
 };
 
 /** @override */
+importer.RuntimeControllerEnvironment.prototype.addWindowCloseListener =
+    function(listener) {
+  window.addEventListener('pagehide', listener);
+};
+
+/** @override */
+importer.RuntimeControllerEnvironment.prototype.addVolumeUnmountListener =
+    function(listener) {
+  // TODO(smckay): remove listeners when the page is torn down.
+  chrome.fileManagerPrivate.onMountCompleted.addListener(
+      /**
+       * @param {!MountCompletedEvent} event
+       * @this {importer.RuntimeControllerEnvironment}
+       */
+      function(event) {
+        if (event.eventType === 'unmount') {
+          listener(event.volumeMetadata.volumeId);
+        }
+      });
+};
+
+/** @override */
 importer.RuntimeControllerEnvironment.prototype.addDirectoryChangedListener =
     function(listener) {
   // TODO(smckay): remove listeners when the page is torn down.
   this.fileManager_.directoryModel.addEventListener(
       'directory-changed',
       listener);
 };
 
 /** @override */
 importer.RuntimeControllerEnvironment.prototype.addSelectionChangedListener =
@@ skipping 67 matching lines @@
       .catch(importer.getLogger().catcher('import-destination-provision'));
 };
 
 /** @override */
 importer.RuntimeControllerEnvironment.prototype.showImportDestination =
     function(date) {
   return this.getImportDestination(date)
       .then(this.revealDirectory_.bind(this))
       .catch(importer.getLogger().catcher('import-destination-reveal'));
 };