Cancel scans when directory changed.

ui/file_manager/file_manager/foreground/js/import_controller_unittest.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.
 
 /** @const {!Event} */
 var EMPTY_EVENT = new Event('directory-changed');
 
 /** @type {!MockVolumeManager} */
 var volumeManager;
 
 /** @type {!TestMediaScanner} */
 var mediaScanner;
 
 /** @type {!TestImportRunner} */
 var mediaImporter;
 
 /** @type {!TestControllerEnvironment} */
 var environment;
 
 /** @type {!VolumeInfo} */
 var sourceVolume;
 
 /** @type {!VolumeInfo} */
 var destinationVolume;
 
 /** @type {!importer.TestCommandWidget} */
 var widget;
 
+/** @type {!DirectoryEntry} */
+var nonDcimDirectory;
+
 /**
  * @enum {string}
  */
 var MESSAGES = {
   CLOUD_IMPORT_BUTTON_LABEL: 'Import it!',
   CLOUD_IMPORT_ACTIVE_IMPORT_BUTTON_LABEL: 'Already importing!',
   CLOUD_IMPORT_EMPTY_SCAN_BUTTON_LABEL: 'No new media',
   CLOUD_IMPORT_INSUFFICIENT_SPACE_BUTTON_LABEL: 'Not enough space!',
   CLOUD_IMPORT_SCANNING_BUTTON_LABEL: 'Scanning... ...!',
   DRIVE_DIRECTORY_LABEL: 'My Drive',
   DOWNLOADS_DIRECTORY_LABEL: 'Downloads'
 };
 
 // Set up string assets.
 loadTimeData.data = MESSAGES;
 
 function setUp() {
   new MockChromeStorageAPI();
 
   widget = new importer.TestCommandWidget();
 
+  nonDcimDirectory = new MockDirectoryEntry(
+      new MockFileSystem('testFs'),
+      '/jellybeans/');
+
   volumeManager = new MockVolumeManager();
   MockVolumeManager.installMockSingleton(volumeManager);
 
   destinationVolume = volumeManager.getCurrentProfileVolumeInfo(
       VolumeManagerCommon.VolumeType.DOWNLOADS);
 
   mediaScanner = new TestMediaScanner();
   mediaImporter = new TestImportRunner();
 }
 
@@ skipping 28 matching lines @@
         '/DCIM/',
         '/DCIM/photos0/',
         '/DCIM/photos0/IMG00001.jpg',
         '/DCIM/photos0/IMG00002.jpg',
         '/DCIM/photos1/',
         '/DCIM/photos1/IMG00001.jpg',
         '/DCIM/photos1/IMG00003.jpg'
       ],
       '/DCIM');
 
-  environment.directoryChangedListener_(EMPTY_EVENT);
+  var dcim = environment.getCurrentDirectory();
+
+  environment.directoryChangedListener(EMPTY_EVENT);
   var promise = widget.updateResolver.promise.then(
+      function() {
+        // Reset the promise so we can wait on a second widget update.
+        widget.resetPromises();
+        environment.setCurrentDirectory(nonDcimDirectory);
+        environment.simulateUnmount();
+
+        environment.setCurrentDirectory(dcim);
+        environment.directoryChangedListener(EMPTY_EVENT);
+        // Return the new promise, so subsequent "thens" only
+        // fire once the widget has been updated again.
+        return widget.updateResolver.promise;
+      }).then(
           function() {
-            // Reset the promise so we can wait on a second widget update.
-            widget.resetPromises();
-
-            // Faux unmount the volume, then request an update again.
-            // A fresh new scan should be started.
-            environment.simulateUnmount();
-
-            environment.directoryChangedListener_(EMPTY_EVENT);
-            // Return the new promise, so subsequent "thens" only
-            // fire once the widget has been updated again.
-            return widget.updateResolver.promise;
-          }).then(
-            function() {
-              mediaScanner.assertScanCount(2);
-            });
+            mediaScanner.assertScanCount(2);
+          });
 
   reportPromise(promise, callback);
 }
 
 function testDirectoryChange_TriggersUpdate(callback) {
   var controller = createController(
       VolumeManagerCommon.VolumeType.MTP,
       'mtp-volume',
       [
         '/DCIM/',
         '/DCIM/photos0/',
         '/DCIM/photos0/IMG00001.jpg',
       ],
       '/DCIM');
 
-  environment.directoryChangedListener_(EMPTY_EVENT);
+  environment.directoryChangedListener(EMPTY_EVENT);
   reportPromise(widget.updateResolver.promise, callback);
 }
 
+function testDirectoryChange_CancelsScan(callback) {
+  var controller = createController(
+      VolumeManagerCommon.VolumeType.MTP,
+      'mtp-volume',
+      [
+        '/DCIM/',
+        '/DCIM/photos0/',
+        '/DCIM/photos0/IMG00001.jpg',
+        '/DCIM/photos0/IMG00002.jpg',
+        '/DCIM/photos1/',
+        '/DCIM/photos1/IMG00001.jpg',
+        '/DCIM/photos1/IMG00003.jpg'
+      ],
+      '/DCIM');
+
+  environment.directoryChangedListener(EMPTY_EVENT);
+  var promise = widget.updateResolver.promise.then(
+      function() {
+        // Reset the promise so we can wait on a second widget update.
+        widget.resetPromises();
+        environment.setCurrentDirectory(nonDcimDirectory);
+        environment.directoryChangedListener(EMPTY_EVENT);
+      }).then(
+          function() {
+            mediaScanner.assertScanCount(1);
+            mediaScanner.assertLastScanCanceled();
+          });
+
+  reportPromise(promise, callback);
+}
+
+function testWindowClose_CancelsScan(callback) {
+  var controller = createController(
+      VolumeManagerCommon.VolumeType.MTP,
+      'mtp-volume',
+      [
+        '/DCIM/',
+        '/DCIM/photos0/',
+        '/DCIM/photos0/IMG00001.jpg',
+        '/DCIM/photos0/IMG00002.jpg',
+        '/DCIM/photos1/',
+        '/DCIM/photos1/IMG00001.jpg',
+        '/DCIM/photos1/IMG00003.jpg'
+      ],
+      '/DCIM');
+
+  environment.directoryChangedListener(EMPTY_EVENT);
+  var promise = widget.updateResolver.promise.then(
+      function() {
+        // Reset the promise so we can wait on a second widget update.
+        widget.resetPromises();
+        environment.windowCloseListener();
+      }).then(
+          function() {
+            mediaScanner.assertScanCount(1);
+            mediaScanner.assertLastScanCanceled();
+          });
+
+  reportPromise(promise, callback);
+}
+
 function testDirectoryChange_DetailsPanelVisibility_InitialChangeDir() {
   var controller = createController(
       VolumeManagerCommon.VolumeType.MTP,
       'mtp-volume',
       [
         '/DCIM/',
         '/DCIM/photos0/',
         '/DCIM/photos0/IMG00001.jpg',
       ],
       '/DCIM');
 
   var event = new Event('directory-changed');
   event.newDirEntry = new MockDirectoryEntry(
       new MockFileSystem('testFs'),
       '/DCIM/');
 
-  environment.directoryChangedListener_(event);
+  environment.directoryChangedListener(event);
   assertTrue(widget.detailsVisible);
 }
 
 function testDirectoryChange_DetailsPanelVisibility_SubsequentChangeDir() {
   var controller = createController(
       VolumeManagerCommon.VolumeType.MTP,
       'mtp-volume',
       [
         '/DCIM/',
         '/DCIM/photos0/',
         '/DCIM/photos0/IMG00001.jpg',
       ],
       '/DCIM');
 
   var event = new Event('directory-changed');
   event.newDirEntry = new MockDirectoryEntry(
       new MockFileSystem('testFs'),
       '/DCIM/');
   // Any previous dir at all will skip the new window logic.
   event.previousDirEntry = event.newDirEntry;
 
-  environment.directoryChangedListener_(event);
+  environment.directoryChangedListener(event);
   assertFalse(widget.detailsVisible);
 }
 
 function testSelectionChange_TriggersUpdate(callback) {
   var controller = createController(
       VolumeManagerCommon.VolumeType.MTP,
       'mtp-volume',
       [
         '/DCIM/',
         '/DCIM/photos0/',
         '/DCIM/photos0/IMG00001.jpg',
       ],
       '/DCIM');
 
-  environment.selectionChangedListener_();
+  var fileSystem = new MockFileSystem('testFs');
+  // ensure there is some content in the scan so the code that depends
+  // on this state doesn't croak which it finds it missing.
+  environment.selection.push(
+      new MockFileEntry(fileSystem, '/DCIM/photos0/IMG00001.jpg', {size: 0}));
+
+  environment.selectionChangedListener();
+  mediaScanner.finalizeScans();
   reportPromise(widget.updateResolver.promise, callback);
 }
 
 function testFinalizeScans_TriggersUpdate(callback) {
   var controller = createController(
       VolumeManagerCommon.VolumeType.MTP,
       'mtp-volume',
       [
         '/DCIM/',
         '/DCIM/photos0/',
         '/DCIM/photos0/IMG00001.jpg',
       ],
       '/DCIM');
 
   var fileSystem = new MockFileSystem('testFs');
   // ensure there is some content in the scan so the code that depends
   // on this state doesn't croak which it finds it missing.
   mediaScanner.fileEntries.push(
       new MockFileEntry(fileSystem, '/DCIM/photos0/IMG00001.jpg', {size: 0}));
 
-  environment.directoryChangedListener_(EMPTY_EVENT);  // initiates a scan.
+  environment.directoryChangedListener(EMPTY_EVENT);  // initiates a scan.
   widget.resetPromises();
   mediaScanner.finalizeScans();
 
   reportPromise(widget.updateResolver.promise, callback);
 }
 
 function testClickDestination_ShowsRootPriorToImport(callback) {
   var controller = createController(
       VolumeManagerCommon.VolumeType.MTP,
       'mtp-volume',
@@ skipping 36 matching lines @@
       ],
       '/DCIM');
 
   var fileSystem = new MockFileSystem('testFs');
   // ensure there is some content in the scan so the code that depends
   // on this state doesn't croak which it finds it missing.
   mediaScanner.fileEntries.push(
       new MockFileEntry(fileSystem, '/DCIM/photos0/IMG00001.jpg', {size: 0}));
 
   // First we need to force the controller into a scanning state.
-  environment.directoryChangedListener_(EMPTY_EVENT);
+  environment.directoryChangedListener(EMPTY_EVENT);
 
   return widget.updateResolver.promise.then(
-          function() {
-            widget.resetPromises();
-            mediaScanner.finalizeScans();
-            return widget.updateResolver.promise.then(
-                function() {
-                  widget.resetPromises();
-                  widget.click(clickSource);
-                  return mediaImporter.importResolver.promise;
-                });
-          });
+      function() {
+        widget.resetPromises();
+        mediaScanner.finalizeScans();
+        return widget.updateResolver.promise.then(
+            function() {
+              widget.resetPromises();
+              widget.click(clickSource);
+              return mediaImporter.importResolver.promise;
+            });
+      });
 }
 
 /**
  * A stub that just provides interfaces from ImportTask that are required by
  * these tests.
  *
  * @constructor
  *
  * @param {!impoter.ScanResult} scan
  * @param {!impoter.Destination} destination
@@ skipping 98 matching lines @@
  * @param {!VolumeInfo} volumeInfo
  * @param {!DirectoryEntry} directory
  */
 TestControllerEnvironment = function(volumeInfo, directory) {
   /** @private {!VolumeInfo} */
   this.volumeInfo_ = volumeInfo;
 
   /** @private {!DirectoryEntry} */
   this.directory_ = directory;
 
-  /** @private {function(string)} */
-  this.volumeUnmountListener_;
+  /** @public {function()} */
+  this.windowCloseListener;
 
-  /** @private {function()} */
-  this.directoryChangedListener_;
+  /** @public {function(string)} */
+  this.volumeUnmountListener;
 
-  /** @private {function()} */
-  this.selectionChangedListener_;
+  /** @public {function()} */
+  this.directoryChangedListener;
+
+  /** @public {function()} */
+  this.selectionChangedListener;
 
   /** @public {!Entry} */
   this.selection = [];
 
   /** @public {boolean} */
   this.isDriveMounted = true;
 
   /** @public {number} */
   this.freeStorageSpace = 123456789;  // bytes
 
@@ skipping 33 matching lines @@
   return this.isDriveMounted;
 };
 
 /** @override */
 TestControllerEnvironment.prototype.getFreeStorageSpace =
     function() {
   return Promise.resolve(this.freeStorageSpace);
 };
 
 /** @override */
+TestControllerEnvironment.prototype.addWindowCloseListener =
+    function(listener) {
+  this.windowCloseListener = listener;
+};
+
+/** @override */
 TestControllerEnvironment.prototype.addVolumeUnmountListener =
     function(listener) {
-  this.volumeUnmountListener_ = listener;
+  this.volumeUnmountListener = listener;
 };
 
 /** @override */
 TestControllerEnvironment.prototype.addDirectoryChangedListener =
     function(listener) {
-  this.directoryChangedListener_ = listener;
+  this.directoryChangedListener = listener;
 };
 
 /** @override */
 TestControllerEnvironment.prototype.addSelectionChangedListener =
     function(listener) {
-  this.selectionChangedListener_ = listener;
+  this.selectionChangedListener = listener;
 };
 
 /** @override */
 TestControllerEnvironment.prototype.getImportDestination =
     function(date) {
   var fileSystem = new MockFileSystem('testFs');
   return new MockDirectoryEntry(fileSystem, '/abc/123');
 };
 
 /** @override */
 TestControllerEnvironment.prototype.showImportDestination = function() {
   this.showImportDestinationResolver.resolve();
 };
 
 /** @override */
 TestControllerEnvironment.prototype.showImportRoot = function() {
   this.showImportRootResolver.resolve();
 };
 
 /**
  * Simulates an unmount event.
  */
 TestControllerEnvironment.prototype.simulateUnmount = function() {
-  this.volumeUnmountListener_(this.volumeInfo_.volumeId);
+  this.volumeUnmountListener(this.volumeInfo_.volumeId);
 };
 
 /**
  * Test implementation of importer.CommandWidget.
  *
  * @constructor
  * @implements {importer.CommandWidget}
  * @struct
  */
 importer.TestCommandWidget = function() {
@@ skipping 94 matching lines @@
  * @param {!Array.<string>} fileNames
  * @return {!VolumeInfo}
  */
 function setupFileSystem(volumeType, volumeId, fileNames) {
   var volumeInfo = volumeManager.createVolumeInfo(
       volumeType, volumeId, 'A volume known as ' + volumeId);
   assertTrue(volumeInfo != null);
   volumeInfo.fileSystem.populate(fileNames);
   return volumeInfo;
 }