Files.app: Introduce AsyncUtil.ConcurrentQueue

ui/file_manager/file_manager/foreground/js/directory_contents.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';
 
 /**
  * Scanner of the entries.
  * @constructor
  */
@@ skipping 548 matching lines @@
  */
 DirectoryContents.prototype.cancelScan = function() {
   if (this.scanCancelled_)
     return;
   this.scanCancelled_ = true;
   if (this.scanner_)
     this.scanner_.cancel();
 
   this.onScanFinished_();
 
+  // Cancels the current prefetchMetadata queue and replaces it with new one.
   this.prefetchMetadataQueue_.cancel();
+  this.prefetchMetadataQueue_ = new AsyncUtil.Queue();

[hirono, 2014/05/26 09:19:42]

Does it really need to reassign a new queue?
It looks this.scanCancelled_ does not turn back to false.

[yoshiki, 2014/05/26 09:36:33]

That's right. Removed.

+
   cr.dispatchSimpleEvent(this, 'scan-cancelled');
 };
 
 /**
  * Called when the scanning by scanner_ is done, even when the scanning is
  * succeeded or failed. This is called before completion (or error) callback.
  *
  * @private
  */
 DirectoryContents.prototype.onScanFinished_ = function() {
   this.scanner_ = null;
 
-  this.prefetchMetadataQueue_.run(function(callback) {
+  this.prefetchMetadataQueue_.run(function(callback, cancelled) {
+    if (cancelled)
+      return callback();
+
     // TODO(yoshiki): Here we should fire the update event of changed
     // items. Currently we have a method this.fileList_.updateIndex() to
     // fire an event, but this method takes only 1 argument and invokes sort
     // one by one. It is obviously time wasting. Instead, we call sort
     // directory.
     // In future, we should implement a good method like updateIndexes and
     // use it here.
     var status = this.fileList_.sortStatus;
     if (status)
       this.fileList_.sort(status.field, status.direction);
 
     callback();
   }.bind(this));
 };
 
 /**
  * Called when the scanning by scanner_ is succeeded.
  * @private
  */
 DirectoryContents.prototype.onScanCompleted_ = function() {
   if (this.scanCancelled_)
     return;
 
-  this.prefetchMetadataQueue_.run(function(callback) {
+  this.prefetchMetadataQueue_.run(function(callback, cancelled) {

[hirono, 2014/05/26 09:19:42]

What is difference between this.scanCancelled_ and the cancelled argument passed
via Queue?

[yoshiki, 2014/05/26 09:36:33]

In this case, they are same. But in general, the callback function should need
to know if the task is cancelled to handle the cancel, and passing the status to
the callback is better than passing queue's instance using closure.

[hirono, 2014/05/26 09:41:04]

How about removing this.scanCancelled_ and using
this.prefetchMetadataQueue_.isCancelled() instead?
We can avoid having two names for the same thing.

     // Call callback first, so isScanning() returns false in the event handlers.
     callback();
 
-    cr.dispatchSimpleEvent(this, 'scan-completed');
+    if (!cancelled)
+      cr.dispatchSimpleEvent(this, 'scan-completed');
   }.bind(this));
 };
 
 /**
  * Called in case scan has failed. Should send the event.
  * @private
  */
 DirectoryContents.prototype.onScanError_ = function() {
   if (this.scanCancelled_)
     return;
 
-  this.prefetchMetadataQueue_.run(function(callback) {
+  this.prefetchMetadataQueue_.run(function(callback, cancelled) {
     // Call callback first, so isScanning() returns false in the event handlers.
     callback();
-    cr.dispatchSimpleEvent(this, 'scan-failed');
+
+    if (!cancelled)
+      cr.dispatchSimpleEvent(this, 'scan-failed');
   }.bind(this));
 };
 
 /**
  * Called when some chunk of entries are read by scanner.
  * @param {Array.<Entry>} entries The list of the scanned entries.
  * @private
  */
 DirectoryContents.prototype.onNewEntries_ = function(entries) {
   if (this.scanCancelled_)
@@ skipping 12 matching lines @@
   cr.dispatchSimpleEvent(this, 'scan-updated');
 
   this.context_.metadataCache.setCacheSize(this.fileList_.length);
 
   // Because the prefetchMetadata can be slow, throttling by splitting entries
   // into smaller chunks to reduce UI latency.
   // TODO(hidehiko,mtomasz): This should be handled in MetadataCache.
   var MAX_CHUNK_SIZE = 50;
   for (var i = 0; i < entriesFiltered.length; i += MAX_CHUNK_SIZE) {
     var chunk = entriesFiltered.slice(i, i + MAX_CHUNK_SIZE);
-    this.prefetchMetadataQueue_.run(function(chunk, callback) {
+    this.prefetchMetadataQueue_.run(function(chunk, callback, cancelled) {
+      if (cancelled)
+        return callback();

[hirono, 2014/05/26 09:19:42]

Maybe "callback(); return;" is more free from misreadings.

[yoshiki, 2014/05/26 09:36:33]

Done.

+
       this.prefetchMetadata(chunk, function() {
         if (this.scanCancelled_) {
           // Do nothing if the scanning is cancelled.
           callback();
           return;
         }
 
         cr.dispatchSimpleEvent(this, 'scan-updated');
         callback();
       }.bind(this));
@@ skipping 82 matching lines @@
 DirectoryContents.createForDriveMetadataSearch = function(
     context, fakeDirectoryEntry, searchType) {
   return new DirectoryContents(
       context,
       true,  // Search
       fakeDirectoryEntry,
       function() {
         return new DriveMetadataSearchContentScanner(searchType);
       });
 };