Show number of remaining files when copying directories.

ui/file_manager/file_manager/background/js/file_operation_util.js

 // Copyright 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.
 
 /**
  * Utilities for file operations.
  */
 var fileOperationUtil = {};
 
 /**
@@ skipping 532 matching lines @@
    */
   this.totalBytes = 1;
 
   /**
    * Total number of already processed bytes. Updated periodically.
    * @type {number}
    */
   this.processedBytes = 0;
 
   /**
+   * Total number of remaining items. Updated periodically.
+   * @type {number}
+   */
+  this.numRemainingItems = this.sourceEntries.length;
+
+  /**
    * Index of the progressing entry in sourceEntries.
    * @private {number}
    */
   this.processingSourceIndex_ = 0;
 
   /**
    * Set to true when cancel is requested.
    * @private {boolean}
    */
   this.cancelRequested_ = false;
@@ skipping 42 matching lines @@
  * @param {function()} successCallback Callback run on success.
  * @param {function(fileOperationUtil.Error)} errorCallback Callback run on
  *     error.
  */
 fileOperationUtil.Task.prototype.run = function(
     entryChangedCallback, progressCallback, successCallback, errorCallback) {
 };
 
 /**
  * Get states of the task.
- * TOOD(hirono): Removes this method and sets a task to progress events.
+ * TODO(hirono): Removes this method and sets a task to progress events.
  * @return {Object} Status object.
  */
 fileOperationUtil.Task.prototype.getStatus = function() {
   var processingEntry = this.sourceEntries[this.processingSourceIndex_];
   return {
     operationType: this.operationType,
-    numRemainingItems: this.sourceEntries.length - this.processingSourceIndex_,
+    numRemainingItems: this.numRemainingItems,
     totalBytes: this.totalBytes,
     processedBytes: this.processedBytes,
     processingEntryName: processingEntry ? processingEntry.name : ''
   };
 };
 
 /**
  * Obtains the number of total processed bytes.
  * @return {number} Number of total processed bytes.
  * @private
  */
 fileOperationUtil.Task.prototype.calcProcessedBytes_ = function() {
   var bytes = 0;
   for (var i = 0; i < this.processingSourceIndex_ + 1; i++) {
     var entryMap = this.processingEntries[i];
     if (!entryMap)
       break;
     for (var name in entryMap) {
       bytes += i < this.processingSourceIndex_ ?
           entryMap[name].size : entryMap[name].processedBytes;
     }
   }
   return bytes;
 };
 
 /**
+ * Obtains the number of remaining items.
+ * @return {number} Number of remaining items.
+ * @private
+ */
+fileOperationUtil.Task.prototype.calcNumRemainingItems_ = function() {
+  var numRemainingItems = 0;
+
+  var resolvedEntryMap;
+  if (this.processingEntries && this.processingEntries.length > 0)
+    resolvedEntryMap = this.processingEntries[this.processingSourceIndex_];
+
+  if (resolvedEntryMap) {
+    for (var key in resolvedEntryMap) {
+      if (resolvedEntryMap.hasOwnProperty(key) &&
+          resolvedEntryMap[key].processedBytes === 0) {
+        numRemainingItems++;
+      }
+    }
+    for (var i = this.processingSourceIndex_ + 1;
+         i < this.processingEntries.length; i++) {
+      numRemainingItems += Object.keys(this.processingEntries[i] || {}).length;
+    }
+  } else {
+    numRemainingItems = this.sourceEntries.length - this.processingSourceIndex_;
+  }
+
+  return numRemainingItems;
+};
+
+/**
  * Task to copy entries.
  *
  * @param {string} taskId A unique ID for identifying this task.
  * @param {Array<Entry>} sourceEntries Array of source entries.
  * @param {DirectoryEntry} targetDirEntry Target directory.
  * @param {boolean} deleteAfterCopy Whether the delete original files after
  *     copy.
  * @constructor
  * @extends {fileOperationUtil.Task}
  * @struct
@@ skipping 128 matching lines @@
    *     dropped, all bytes of the entry are considered to be processed.
    */
   var updateProgress = function(index, sourceEntryUrl, opt_size) {
     if (!sourceEntryUrl)
       return;
 
     var processedEntry = this.processingEntries[index][sourceEntryUrl];
     if (!processedEntry)
       return;
 
+    var alreadyCompleted =
+        processedEntry.processedBytes === processedEntry.size;
+
     // Accumulates newly processed bytes.
     var size = opt_size !== undefined ? opt_size : processedEntry.size;
     this.processedBytes += size - processedEntry.processedBytes;
     processedEntry.processedBytes = size;
 
+    // updateProgress can be called multiple times for a single file copy, and
+    // it might not be called for a small file.
+    // The following prevents multiple call for a single file to decrement
+    // numRemainingItems multiple times.
+    // For small files, it will be decremented by next calcNumRemainingItems_().
+    if (!alreadyCompleted &&
+        processedEntry.processedBytes === processedEntry.size) {
+      this.numRemainingItems--;
+    }
+
     // Updates progress bar in limited frequency so that intervals between
     // updates have at least 200ms.
     this.updateProgressRateLimiter_.run();
   };
   updateProgress = updateProgress.bind(this);
 
   this.updateProgressRateLimiter_ = new AsyncUtil.RateLimiter(progressCallback);
 
+  this.numRemainingItems = this.calcNumRemainingItems_();
+
   // Number of consecutive errors. Increases while failing and resets to zero
   // when one of them succeeds.
   var errorCount = 0;
   var lastError;
 
   AsyncUtil.forEach(
       this.sourceEntries,
       function(callback, entry, index) {
         if (this.cancelRequested_) {
           errorCallback(new fileOperationUtil.Error(
@@ skipping 15 matching lines @@
             },
             function(sourceEntryUrl, size) {
               updateProgress(index, sourceEntryUrl, size);
             },
             function() {
               // Finishes off delayed updates if necessary.
               this.updateProgressRateLimiter_.runImmediately();
               // Update current source index and processing bytes.
               this.processingSourceIndex_ = index + 1;
               this.processedBytes = this.calcProcessedBytes_();
+              this.numRemainingItems = this.calcNumRemainingItems_();
               errorCount = 0;
               callback();
             }.bind(this),
             function(error) {
               // Finishes off delayed updates if necessary.
               this.updateProgressRateLimiter_.runImmediately();
               // Update current source index and processing bytes.
               this.processingSourceIndex_ = index + 1;
               this.processedBytes = this.calcProcessedBytes_();
+              this.numRemainingItems = this.calcNumRemainingItems_();
               errorCount++;
               lastError = error;
               if (errorCount <
                   fileOperationUtil.CopyTask.CONSECUTIVE_ERROR_LIMIT_) {
                 callback();
               } else {
                 errorCallback(error);
               }
             }.bind(this));
       },
@@ skipping 131 matching lines @@
               util.createDOMError(util.FileError.ABORT_ERR)));
           return;
         }
         progressCallback();
         fileOperationUtil.MoveTask.processEntry_(
             entry, this.targetDirEntry, entryChangedCallback,
             function() {
               // Update current source index.
               this.processingSourceIndex_ = index + 1;
               this.processedBytes = this.calcProcessedBytes_();
+              this.numRemainingItems = this.calcNumRemainingItems_();
               callback();
             }.bind(this),
             errorCallback);
       },
       function() {
         successCallback();
       }.bind(this),
       this);
 };
 
@@ skipping 277 matching lines @@
 fileOperationUtil.EventRouter.prototype.sendDeleteEvent = function(
     reason, task) {
   var event = /** @type {FileOperationProgressEvent} */ (new Event('delete'));
   event.reason = reason;
   event.taskId = task.taskId;
   event.entries = task.entries;
   event.totalBytes = task.totalBytes;
   event.processedBytes = task.processedBytes;
   this.dispatchEvent(event);
 };