Files.app: Fix the number of remaining files and processed bytes.

chrome/browser/resources/file_manager/background/js/file_operation_manager.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.
 
 'use strict';
 
 /**
  * Utilities for FileOperationManager.
  */
 var fileOperationUtil = {};
@@ skipping 394 matching lines @@
    */
   this.totalBytes = 0;
 
   /**
    * Total number of already processed bytes. Updated periodically.
    * @type {number}
    */
   this.processedBytes = 0;
 
   /**
+   * Index of the progressing entry in sourceEntries.
+   * @type {number}
+   * @private
+   */
+  this.processingSourceIndex_ = 0;
+
+  /**
    * Set to true when cancel is requested.
    * @private {boolean}
    */
   this.cancelRequested_ = false;
 
   /**
    * Callback to cancel the running process.
    * @private {function()}
    */
   this.cancelCallback_ = null;
 
   // TODO(hidehiko): After we support recursive copy, we don't need this.
   // If directory already exists, we try to make a copy named 'dir (X)',
   // where X is a number. When we do this, all subsequent copies from
   // inside the subtree should be mapped to the new directory name.
   // For example, if 'dir' was copied as 'dir (1)', then 'dir\file.txt' should
   // become 'dir (1)\file.txt'.
   this.renamedDirectories_ = [];
 };
 
 /**
  * @param {function()} callback When entries resolved.
  */
 FileOperationManager.Task.prototype.initialize = function(callback) {
 };
 
 /**
- * Updates copy progress status for the entry.
- *
- * @param {number} size Number of bytes that has been copied since last update.
- */
-FileOperationManager.Task.prototype.updateFileCopyProgress = function(size) {
-  this.completedBytes += size;
-};
-
-/**
  * Requests cancellation of this task.
  * When the cancellation is done, it is notified via callbacks of run().
  */
 FileOperationManager.Task.prototype.requestCancel = function() {
   this.cancelRequested_ = true;
   if (this.cancelCallback_) {
     this.cancelCallback_();
     this.cancelCallback_ = null;
   }
 };
@@ skipping 12 matching lines @@
 FileOperationManager.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.
  * @return {object} Status object.
  */
 FileOperationManager.Task.prototype.getStatus = function() {
-  var numRemainingItems = this.countRemainingItems();
+  var processingEntry = this.sourceEntries[this.processingSourceIndex_];
   return {
     operationType: this.operationType,
-    numRemainingItems: numRemainingItems,
+    numRemainingItems: this.sourceEntries.length - this.processingSourceIndex_,
     totalBytes: this.totalBytes,
     processedBytes: this.processedBytes,
-    processingEntry: this.getSingleEntry()
+    processingEntryName: processingEntry ? processingEntry.name : ''
   };
 };
 
 /**
- * Counts the number of remaining items.
- * @return {number} Number of remaining items.
+ * Obtains the number of total processed bytes.
+ * @return {number} Number of total processed bytes.
+ * @private
  */
-FileOperationManager.Task.prototype.countRemainingItems = function() {
-  var count = 0;
-  for (var i = 0; i < this.processingEntries.length; i++) {
-    for (var entryURL in this.processingEntries[i]) {
-      count++;
+FileOperationManager.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 count;
+  return bytes;
 };
 
 /**
- * Obtains the single processing entry. If there are multiple processing
- * entries, it returns null.
- * @return {Entry} First entry.
- */
-FileOperationManager.Task.prototype.getSingleEntry = function() {
-  if (this.countRemainingItems() !== 1)
-    return null;
-  for (var i = 0; i < this.processingEntries.length; i++) {
-    var entryMap = this.processingEntries[i];
-    for (var name in entryMap)
-      return entryMap[name];
-  }
-  return null;
-};
-
-/**
  * Task to copy entries.
  *
  * @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 {FileOperationManager.Task}
  */
 FileOperationManager.CopyTask = function(sourceEntries,
@@ skipping 112 matching lines @@
           return;
         }
         progressCallback();
         this.processEntry_(
             entry, this.targetDirEntry,
             function(sourceEntry, destinationEntry) {
               // Finalize the entry's progress state.
               var sourceEntryURL = sourceEntry.toURL();
               var processedEntry =
                   this.processingEntries[index][sourceEntryURL];
-              if (processedEntry) {
-                this.processedBytes +=
-                    processedEntry.size - processedEntry.processedBytes;
-                progressCallback();
-                delete this.processingEntries[index][sourceEntryURL];
-              }
+
+              // Update current source index.
+              this.processingSourceIndex_ = index + 1;
+              this.processedBytes = this.calcProcessedBytes_();
 
               // The destination entry may be null, if the copied file got
               // deleted just after copying.
               if (destinationEntry) {
                 entryChangedCallback(
                     util.EntryChangedKind.CREATED, destinationEntry);
               }
             }.bind(this),
             function(sourceEntry, size) {
               var sourceEntryURL = sourceEntry.toURL();
@@ skipping 135 matching lines @@
         if (this.cancelRequested_) {
           errorCallback(new FileOperationManager.Error(
               util.FileOperationErrorType.FILESYSTEM_ERROR,
               util.createDOMError(util.FileError.ABORT_ERR)));
           return;
         }
         progressCallback();
         FileOperationManager.MoveTask.processEntry_(
             entry, this.targetDirEntry, entryChangedCallback,
             function() {
-              // Erase the processing entry.
-              this.processingEntries[index] = {};
-              this.processedBytes++;
+              // Update current source index.
+              this.processingSourceIndex_ = index + 1;
+              this.processedBytes = this.calcProcessedBytes_();
               callback();
             }.bind(this),
             errorCallback);
       },
       function() {
         successCallback();
       }.bind(this),
       this);
 };
 
@@ skipping 530 matching lines @@
 
 /**
  * Generates new task ID.
  *
  * @return {string} New task ID.
  * @private
  */
 FileOperationManager.prototype.generateTaskId_ = function() {
   return 'file-operation-' + this.taskIdCounter_++;
 };