Cancel scans when directory changed.

ui/file_manager/file_manager/background/js/media_scanner.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.
 
 /**
  * Class representing the results of a scan operation.
  *
  * @interface
  */
 importer.MediaScanner = function() {};
@@ skipping 85 matching lines @@
   if (index > -1) {
     this.observers_.splice(index, 1);
   } else {
     console.warn('Ignoring request to remove observer that is not registered.');
   }
 };
 
 /** @override */
 importer.DefaultMediaScanner.prototype.scanDirectory = function(directory) {
   var scan = this.createScanResult_();
+  console.info(scan.name + ': Scanning directory ' + directory.fullPath);
+
   var watcher = this.watcherFactory_(
       /** @this {importer.DefaultMediaScanner} */
       function() {
-        scan.invalidateScan();
+        scan.cancel();
         this.notify_(importer.ScanEvent.INVALIDATED, scan);
       }.bind(this));
 
   this.crawlDirectory_(directory, watcher)
       .then(this.scanMediaFiles_.bind(this, scan))
       .then(scan.resolve)
       .catch(scan.reject);
 
   scan.whenFinal()
       .then(
           /** @this {importer.DefaultMediaScanner} */
           function() {
+            console.info(scan.name + ': Finished.');
             this.notify_(importer.ScanEvent.FINALIZED, scan);
           }.bind(this));
 
   return scan;
 };
 
 /** @override */
 importer.DefaultMediaScanner.prototype.scanFiles = function(entries) {
   if (entries.length === 0) {
     throw new Error('Cannot scan empty list.');
   }
   var scan = this.createScanResult_();
+  console.info(
+      scan.name + ': Scanning fixed set of ' +
+      entries.length + ' entries.');
+
   var watcher = this.watcherFactory_(
       /** @this {importer.DefaultMediaScanner} */
       function() {
-        scan.invalidateScan();
+        scan.cancel();
         this.notify_(importer.ScanEvent.INVALIDATED, scan);
       }.bind(this));
 
   var scanPromises = entries.map(this.onUniqueFileFound_.bind(this, scan));
 
   Promise.all(scanPromises)
       .then(scan.resolve)
       .catch(scan.reject);
 
   scan.whenFinal()
       .then(
           /** @this {importer.DefaultMediaScanner} */
           function() {
+            console.info(scan.name + ': Finished.');
             this.notify_(importer.ScanEvent.FINALIZED, scan);
           }.bind(this));
 
   return scan;
 };
 
 /** @const {number} */
 importer.DefaultMediaScanner.SCAN_BATCH_SIZE = 1;
 
 /**
  * @param {!importer.DefaultScanResult} scan
  * @param  {!Array<!FileEntry>} entries
- * @return {!Promise} Resolves when scanning is finished.
+ * @return {!Promise} Resolves when scanning is finished normally
+ *     or canceled.
  * @private
  */
 importer.DefaultMediaScanner.prototype.scanMediaFiles_ =
     function(scan, entries) {
   var handleFileEntry = this.onFileEntryFound_.bind(this, scan);
 
   /**
    * @param {number} begin The beginning offset in the list of entries
    *     to process.
    * @return {!Promise}
    */
-  var scanChunk = function(begin) {
+  var scanBatch = function(begin) {
+    if (scan.canceled()) {
+      console.debug(
+          scan.name + ': Skipping remaining ' +
+          (entries.length - begin) +
+          ' entries. Scan was canceled.');
+      return Promise.resolve();
+    }
+
     // the second arg to slice is an exclusive end index, so we +1 batch size.
-    var end = begin + importer.DefaultMediaScanner.SCAN_BATCH_SIZE + 1;
+    var end = begin + importer.DefaultMediaScanner.SCAN_BATCH_SIZE ;

[mtomasz, 2015/04/01 03:55:40]

nit: \s; -> ;

[Steve McKay, 2015/04/01 04:00:13]

Done.

+    console.log(scan.name + ': Processing batch ' + begin + '-' + (end - 1));
+    var batch = entries.slice(begin, end);
+
     return Promise.all(
-        entries.slice(begin, end).map(handleFileEntry))
+        batch.map(handleFileEntry))
         .then(
+            /** @this {importer.DefaultMediaScanner} */
             function() {
               if (end < entries.length) {
-                return scanChunk(end);
+                return scanBatch(end);
               }
             });
   };
 
-  return scanChunk(0);
+  return scanBatch(0);
 };
 
 /**
  * Notifies all listeners at some point in the near future.
  *
  * @param {!importer.ScanEvent} event
  * @param {!importer.DefaultScanResult} result
  * @private
  */
 importer.DefaultMediaScanner.prototype.notify_ = function(event, result) {
@@ skipping 115 matching lines @@
  * @interface
  */
 importer.ScanResult = function() {};
 
 /**
  * @return {boolean} true if scanning is complete.
  */
 importer.ScanResult.prototype.isFinal;
 
 /**
- * @return {boolean} true if scanning is invalidated.
+ * Notifies the scan to stop working. Some in progress work
+ * may continue, but no new work will be undertaken.
  */
-importer.ScanResult.prototype.isInvalidated;
+importer.ScanResult.prototype.cancel;
+
+/**
+ * @return {boolean} True if the scan has been canceled. Some
+ * work started prior to cancelation may still be ongoing.
+ */
+importer.ScanResult.prototype.canceled;
 
 /**
  * Returns all files entries discovered so far. The list will be
  * complete only after scanning has completed and {@code isFinal}
  * returns {@code true}.
  *
  * @return {!Array<!FileEntry>}
  */
 importer.ScanResult.prototype.getFileEntries;
 
 /**
- * Returns a promise that fires when scanning is complete.
+ * Returns a promise that fires when scanning is finished
+ * normally or has been canceled.
  *
  * @return {!Promise<!importer.ScanResult>}
  */
 importer.ScanResult.prototype.whenFinal;
 
 /**
  * @return {!importer.ScanResult.Statistics}
  */
 importer.ScanResult.prototype.getStatistics;
 
 /**
  * @typedef {{
  *   scanDuration: number,
  *   newFileCount: number,
  *   duplicates: !Object<!importer.Disposition, number>,
  *   sizeBytes: number
  * }}
  */
 importer.ScanResult.Statistics;
 
 /**
  * Results of a scan operation. The object is "live" in that data can and
  * will change as the scan operation discovers files.
  *
  * <p>The scan is complete, and the object will become static once the
  * {@code whenFinal} promise resolves.
  *
+ * Note that classes implementing this should provide a read-only
+ * {@code name} field.
+ *
  * @constructor
  * @struct
  * @implements {importer.ScanResult}
  *
  * @param {function(!FileEntry): !Promise.<string>} hashGenerator Hash-code
  *     generator used to dedupe within the scan results itself.
  */
 importer.DefaultScanResult = function(hashGenerator) {
+  /** @private {number} */
+  this.scanId_ = importer.generateId();
 
   /** @private {function(!FileEntry): !Promise.<string>} */
   this.createHashcode_ = hashGenerator;
 
   /**
    * List of file entries found while scanning.
    * @private {!Array<!FileEntry>}
    */
   this.fileEntries_ = [];
 
@@ skipping 19 matching lines @@
 
   /**
    * The point in time when the last scan activity occured.
    * @type {Date}
    */
   this.lastScanActivity_ = this.scanStarted_;
 
   /**
    * @private {boolean}
    */
-  this.invalidated_ = false;
+  this.canceled_ = false;
 
   /** @private {!importer.Resolver.<!importer.ScanResult>} */
   this.resolver_ = new importer.Resolver();
 };
 
 /** @struct */
 importer.DefaultScanResult.prototype = {
+  /** @return {string} */
+  get name() { return 'ScanResult(' + this.scanId_ + ')' },
 
   /** @return {function()} */
   get resolve() { return this.resolver_.resolve.bind(null, this); },
 
   /** @return {function(*=)} */
   get reject() { return this.resolver_.reject; }
 };
 
 /** @override */
 importer.DefaultScanResult.prototype.isFinal = function() {
   return this.resolver_.settled;
 };
 
-importer.DefaultScanResult.prototype.isInvalidated = function() {
-  return this.invalidated_;
-};
-
 /** @override */
 importer.DefaultScanResult.prototype.getFileEntries = function() {
   return this.fileEntries_;
 };
 
 /** @override */
 importer.DefaultScanResult.prototype.whenFinal = function() {
   return this.resolver_.promise;
 };
 
-/**
- * Invalidates this scan.
- */
-importer.DefaultScanResult.prototype.invalidateScan = function() {
-  this.invalidated_ = true;
+/** @override */
+importer.DefaultScanResult.prototype.cancel = function() {
+  this.canceled_ = true;
+};
+
+/** @override */
+importer.DefaultScanResult.prototype.canceled = function() {
+  return this.canceled_;
 };
 
 /**
  * Adds a file to results.
  *
  * @param {!FileEntry} entry
  * @return {!Promise.<boolean>} True if the file as added, false if it was
  *     rejected as a dupe.
  */
 importer.DefaultScanResult.prototype.addFileEntry = function(entry) {
@@ skipping 127 matching lines @@
   if (!this.watchedDirectories_[event.entry.toURL()])
     return;
   this.triggered = true;
   for (var url in this.watchedDirectories_) {
     chrome.fileManagerPrivate.removeFileWatch(url, function() {});
   }
   chrome.fileManagerPrivate.onDirectoryChanged.removeListener(
       assert(this.listener_));
   this.callback_();
 };