Make resizing in Files.app more responsive.

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 = {};
@@ skipping 119 matching lines @@
 /**
  * Finishes the passed task and continues executing enqueued closures.
  *
  * @param {Object} task Task object.
  * @private
  */
 AsyncUtil.Group.prototype.finish_ = function(task) {
   this.finishedTasks_[task.name] = task;
   this.continue_();
 };
+
+/**
+ * Aggregates consecutive calls and executes the closure only once instead of
+ * several times. The first call is always called immediately, and the next
+ * consecutive ones are aggregated and the closure is called only once once
+ * |delay| amount of time passes after the last call to run().
+ *
+ * @param {function()} closure Closure to be aggregated.
+ * @param {number=} opt_delay Minimum aggregation time in milliseconds. Default
+ *     is 50 milliseconds.
+ * @constructor
+ */
+AsyncUtil.Aggregation = function(closure, opt_delay) {
+  /**
+   * @type {number}
+   * @private
+   */
+  this.delay_ = opt_delay || 50;
+
+  /**
+   * @type {function()}
+   * @private
+   */
+  this.closure_ = closure;
+
+  /**
+   * @type {number?}
+   * @private
+   */
+  this.scheduledRunsTimer_ = null;
+
+  /**
+   * @type {number}
+   * @private
+   */
+  this.lastRunTime_ = 0;
+};
+
+/**
+ * Runs a closure. Skips consecutive calls. The first call is called
+ * immediately.
+ */
+AsyncUtil.Aggregation.prototype.run = function() {
+  // If recently called, then schedule the consecutive call with a delay.
+  if (Date.now() - this.lastRunTime_ < this.delay_) {
+    this.cancelScheduledRuns_();
+    this.scheduledRunsTimer_ = setTimeout(this.runImmediately_.bind(this),
+                                          this.delay_ + 1);
+    this.lastRunTime_ = Date.now();
+    return;
+  }
+
+  // Otherwise, run immediately.
+  this.runImmediately_();
+};
+
+/**
+ * Calls the schedule immediately and cancels any scheduled calls.
+ * @private
+ */
+AsyncUtil.Aggregation.prototype.runImmediately_ = function() {
+  this.cancelScheduledRuns_();
+  this.closure_();
+  this.lastRunTime_ = Date.now();
+};
+
+/**
+ * Cancels all scheduled runs (if any).
+ * @private
+ */
+AsyncUtil.Aggregation.prototype.cancelScheduledRuns_ = function() {
+  if (this.scheduledRunsTimer_) {
+    clearTimeout(this.scheduledRunsTimer_);
+    this.scheduledRunsTimer_ = null;
+  }
+};