Add cancellation feature to the AsyncUtil.Queue for Files.app. (Abandoned)

chrome/browser/resources/file_manager/js/async_util.js

 // Copyright (c) 2013 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';
 
 /**
  * Namespace for async utility functions.
  */
 var AsyncUtil = {};
 
 /**
  * Creates a class for executing several asynchronous closures in a fifo queue.
  * Added tasks will be executed sequentially in order they were added.
  *
+ * Once the queue is cancelled, any pending tasks in the queue as well as later
+ * added ones will not be executed. The current one being executed will not be
+ * terminated.
+ *
  * @constructor
  */
 AsyncUtil.Queue = function() {
   this.running_ = false;
-  this.closures_ = [];
+  this.cancelled_ = false;
+  this.tasks_ = [];
+};
+
+/**
+ * Cancels the queue. Any pending and later added tasks will not be executed.
+ * If there is a task being executed, then it will not be terminated. Once
+ * the queue is cancelled, it can't be resumed.
+ */
+AsyncUtil.Queue.prototype.cancel = function() {
+  this.cancelled_ = true;
+  this.running_ = false;
+  for (var index = 0; index < this.tasks_.length; index++) {
+    this.tasks_[index].onCancelled();
+  }
+  this.tasks_ = [];
+};
+
+/**
+ * Returns true if the queue is cancelled. Once cancelled, it can't be resumed.
+ * @return {boolean} True if cancelled, false otherwise.
+ */
+AsyncUtil.Queue.prototype.isCancelled = function() {
+  return this.cancelled_;
 };
 
 /**
  * Enqueues a closure to be executed.
+ *
  * @param {function(function())} closure Closure with a completion callback to
  *     be executed.
+ * @param {function()=} opt_onCancelled Called when the task hasn't been
+ *     executed because the queue has been terminated.
  */
-AsyncUtil.Queue.prototype.run = function(closure) {
-  this.closures_.push(closure);
+AsyncUtil.Queue.prototype.run = function(closure, opt_onCancelled) {
+  var onCancelled = opt_onCancelled || function() {};
+
+  if (this.cancelled_) {
+    onCancelled();
+    return;
+  }
+
+  this.tasks_.push({closure: closure, onCancelled: onCancelled});
   if (!this.running_)
     this.continue_();
 };
 
 /**
  * Serves the next closure from the queue.
  * @private
  */
 AsyncUtil.Queue.prototype.continue_ = function() {
-  if (!this.closures_.length) {
+  if (!this.tasks_.length) {
     this.running_ = false;
     return;
   }
 
   // Run the next closure.
-  this.running_ = true;
-  var closure = this.closures_.shift();
-  closure(this.continue_.bind(this));
+  if (!this.cancelled_) {
+    this.running_ = true;
+    var task = this.tasks_.shift();
+    task.closure(this.continue_.bind(this));
+  }
 };
 
 /**
  * Creates a class for executing several asynchronous closures in a group in
  * a dependency order.
  *
  * @constructor
  */
 AsyncUtil.Group = function() {
   this.addedTasks_ = {};
@@ skipping 19 matching lines @@
     closure: closure,
     dependencies: opt_dependencies || [],
     name: name
   };
 
   this.addedTasks_[name] = task;
   this.pendingTasks_[name] = task;
 };
 
 /**
- * Runs the enqueued closured in order of dependencies.
+ * Runs the enqueued closures in order of dependencies.
  *
  * @param {function()=} opt_onCompletion Completion callback.
  */
 AsyncUtil.Group.prototype.run = function(opt_onCompletion) {
   if (opt_onCompletion)
     this.completionCallbacks_.push(opt_onCompletion);
   this.continue_();
 };
 
 /**
@@ skipping 108 matching lines @@
 /**
  * Cancels all scheduled runs (if any).
  * @private
  */
 AsyncUtil.Aggregation.prototype.cancelScheduledRuns_ = function() {
   if (this.scheduledRunsTimer_) {
     clearTimeout(this.scheduledRunsTimer_);
     this.scheduledRunsTimer_ = null;
   }
 };