Only show progress bar after 500ms

chrome/browser/resources/file_manager/js/file_copy_manager.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.
 
 function FileCopyManager() {
   this.copyTasks_ = [];
   this.cancelObservers_ = [];
   this.cancelRequested_ = false;
 }
 
@@ skipping 42 matching lines @@
     callback();
   }
 
   this.originalEntries = entries;
   // When moving directories, FileEntry.moveTo() is used if both source
   // and target are on GData. There is no need to recurse into directories.
   var recurse = !(this.deleteAfterCopy && this.sourceAndTargetOnGData);
   util.recurseAndResolveEntries(entries, recurse, onEntriesRecursed);
 }
 
-FileCopyManager.Task.prototype.takeNextEntry = function() {
-  if (this.pendingDirectories.length)
-    return this.pendingDirectories.shift();
+FileCopyManager.Task.prototype.getNextEntry = function() {
+  // We should keep the file in pending list and remove it after complete.
+  // Otherwise, if we try to get status in the middle of copying. The returned
+  // status is wrong (miss count the pasting item in totalItems).
+  if (this.pendingDirectories.length) {
+    this.pendingDirectories[0].inProgress = true;
+    return this.pendingDirectories[0];
+  }
 
-  if (this.pendingFiles.length)
-    return this.pendingFiles.shift();
+  if (this.pendingFiles.length) {
+    this.pendingFiles[0].inProgress = true;
+    return this.pendingFiles[0];
+  }
 
   return null;
 };
 
 FileCopyManager.Task.prototype.markEntryComplete = function(entry, size) {
-  if (entry.isDirectory) {
+  // It is probably not safe to directly remove the first entry in pending list.
+  // We need to check if the removed entry (srcEntry) corresponding to the added
+  // entry (target entry).
+  if (entry.isDirectory && this.pendingDirectories &&
+      this.pendingDirectories[0].inProgress) {
     this.completedDirectories.push(entry);
-  } else {
+    this.pendingDirectories.shift();
+  } else if (this.pendingFiles && this.pendingFiles[0].inProgress) {
     this.completedFiles.push(entry);
     this.completedBytes += size;
+    this.pendingFiles.shift();
+  } else {
+    throw new Error('Try to remove a source entry which is not correspond to' +
+                    ' the finished target entry');
   }
 };
 
 FileCopyManager.Task.prototype.registerRename = function(fromName, toName) {
   this.renamedDirectories_.push({from: fromName + '/', to: toName + '/'});
 };
 
 FileCopyManager.Task.prototype.applyRenames = function(path) {
   // Directories are processed in pre-order, so we will store only the first
   // renaming point:
@@ skipping 37 matching lines @@
     completedFiles: 0,
     completedDirectories: 0,
     completedBytes: 0
   };
 
   for (var i = 0; i < this.copyTasks_.length; i++) {
     var task = this.copyTasks_[i];
     rv.pendingFiles += task.pendingFiles.length;
     rv.pendingDirectories += task.pendingDirectories.length;
     rv.pendingBytes += task.pendingBytes;
-    rv.pendingItems += rv.pendingFiles + rv.pendingDirectories;
 
     rv.completedFiles += task.completedFiles.length;
     rv.completedDirectories += task.completedDirectories.length;
     rv.completedBytes += task.completedBytes;
-    rv.completedItems += rv.completedFiles + rv.completedDirectories;
-
   }
+  rv.pendingItems = rv.pendingFiles + rv.pendingDirectories;
+  rv.completedItems = rv.completedFiles + rv.completedDirectories;
 
   rv.totalFiles = rv.pendingFiles + rv.completedFiles;
   rv.totalDirectories = rv.pendingDirectories + rv.completedDirectories;
   rv.totalItems = rv.pendingItems + rv.completedItems;
   rv.totalBytes = rv.pendingBytes + rv.completedBytes;
 
   return rv;
 };
 
 /**
+ * Get the overall progress data of all queued copy tasks.
+ * @return {Object} An object containing the following parameters:
+ *    percentage - The percentage (0-1) of finished items.
+ *    pendingItems - The number of pending/unfinished items.
+ */
+FileCopyManager.prototype.getProgress = function() {
+  var status = this.getStatus();
+  return {
+    // TODO(bshe): Need to figure out a way to get completed bytes in real
+    // time. We currently use completedItems and totalItems to estimate the
+    // progress. There are completeBytes and totalBytes ready to use.
+    // However, the completedBytes is not in real time. It only updates
+    // itself after each item finished. So if there is a large item to
+    // copy, the progress bar will stop moving until it finishes and jump
+    // a large portion of the bar.
+    // There is case that when user copy a large file, we want to show an
+    // 100% animated progress bar. So we use completedItems + 1 here.
+    percentage: (status.completedItems + 1) / status.totalItems,
+    pendingItems: status.pendingItems
+  };
+};
+
+/**
+ * Dispatch a simple copy-progress event with reason and optional err data.
+ */
+FileCopyManager.prototype.sendProgressEvent_ = function(reason, opt_err) {
+  var event = new cr.Event('copy-progress');
+  event.reason = reason;
+  if (opt_err)
+    event.error = opt_err;
+  this.dispatchEvent(event);
+};
+
+/**
  * Completely clear out the copy queue, either because we encountered an error
  * or completed successfully.
  */
 FileCopyManager.prototype.resetQueue_ = function() {
   for (var i = 0; i < this.cancelObservers_.length; i++)
     this.cancelObservers_[i]();
 
   this.copyTasks_ = [];
   this.cancelObservers_ = [];
   this.cancelRequested_ = false;
 };
 
 /**
  * Request that the current copy queue be abandoned.
  */
 FileCopyManager.prototype.requestCancel = function(opt_callback) {
   this.cancelRequested_ = true;
   if (opt_callback)
     this.cancelObservers_.push(opt_callback);
 };
 
 /**
  * Perform the bookeeping required to cancel.
  */
 FileCopyManager.prototype.doCancel_ = function() {
-  var event = new cr.Event('copy-progress');
-  event.reason = 'CANCELLED';
-  this.dispatchEvent(event);
+  this.sendProgressEvent_('CANCELLED');
   this.resetQueue_();
 };
 
 /**
  * Used internally to check if a cancel has been requested, and handle
  * it if so.
  */
 FileCopyManager.prototype.maybeCancel_ = function() {
   if (!this.cancelRequested_)
     return false;
 
   this.doCancel_();
   return true;
 }
 
 /**
  * Convert string in clipboard to entries and kick off pasting.
  */
 FileCopyManager.prototype.paste = function(clipboard, targetEntry,
                                            sourceAndTargetOnGData, root) {
   var self = this;
   var results = {
     sourceDirEntry: null,
     entries: [],
     isCut: false
   };
 
   function onPathError(err) {
-    var event = new cr.Event('copy-progress');
-    event.reason = 'ERROR';
-    event.error = new FileCopyManager.Error('FILESYSTEM_ERROR', err);
-    self.dispatchEvent(event);
+    self.sendProgressEvent_('ERROR',
+                            new FileCopyManager.Error('FILESYSTEM_ERROR', err));
   }
 
   function onSourceEntryFound(dirEntry) {
     function onComplete() {
       self.queueCopy(results.sourceDirEntry,
             targetEntry,
             results.entries,
             results.isCut,
             sourceAndTargetOnGData);
     }
@@ skipping 48 matching lines @@
                                                sourceAndTargetOnGData) {
   var self = this;
   var copyTask = new FileCopyManager.Task(sourceDirEntry, targetDirEntry);
   copyTask.deleteAfterCopy = deleteAfterCopy;
   copyTask.sourceAndTargetOnGData = sourceAndTargetOnGData;
   copyTask.setEntries(entries, function() {
     self.copyTasks_.push(copyTask);
     if (self.copyTasks_.length == 1) {
       // This moved us from 0 to 1 active tasks, let the servicing begin!
       self.serviceAllTasks_();
+    } else {
+      // Force to update the progress of butter bar when there are new tasks
+      // coming while servicing current task.
+      self.sendProgressEvent_('PROGRESS');
     }
   });
 
   return copyTask;
 };
 
 /**
  * Service all pending tasks, as well as any that might appear during the
  * copy.
  */
 FileCopyManager.prototype.serviceAllTasks_ = function() {
   var self = this;
 
   function onTaskError(err) {
-    var event = new cr.Event('copy-progress');
-    event.reason = 'ERROR';
-    event.error = err;
-    self.dispatchEvent(event);
+    self.sendProgressEvent_('ERROR', err);
     self.resetQueue_();
   }
 
   function onTaskSuccess(task) {
-    if (task == null) {
+    if (!self.copyTasks_.length) {
       // All tasks have been serviced, clean up and exit.
-      var event = new cr.Event('copy-progress');
-      event.reason = 'SUCCESS';
-      self.dispatchEvent(event);
+      self.sendProgressEvent_('SUCCESS');
       self.resetQueue_();
       return;
     }
 
+    // We want to dispatch a PROGRESS event when there are more tasks to serve
+    // right after one task finished in the queue. We treat all tasks as one
+    // big task logically, so there is only one BEGIN/SUCCESS event pair for
+    // these continuous tasks.
+    self.sendProgressEvent_('PROGRESS');
+
     self.serviceNextTask_(onTaskSuccess, onTaskError);
   }
 
   // If the queue size is 1 after pushing our task, it was empty before,
-  // so we need to kick off queue processing.
+  // so we need to kick off queue processing and dispatch BEGIN event.
+
+  this.sendProgressEvent_('BEGIN');
   this.serviceNextTask_(onTaskSuccess, onTaskError);
 };
 
 /**
  * Service all entries in the next copy task.
  */
 FileCopyManager.prototype.serviceNextTask_ = function(
     successCallback, errorCallback) {
   if (this.maybeCancel_())
     return;
 
-  if (!this.copyTasks_.length) {
-    successCallback(null);
-    return;
-  }
-
   var self = this;
   var task = this.copyTasks_[0];
 
   function onFilesystemError(err) {
     errorCallback(new FileCopyManager.Error('FILESYSTEM_ERROR', err));
   }
 
   function onTaskComplete() {
     self.copyTasks_.shift();
     successCallback(task);
   }
 
   function deleteOriginals() {
     var count = task.originalEntries.length;
 
     function onEntryDeleted() {
       count--;
       if (!count)
         onTaskComplete();
     }
 
     for (var i = 0; i < task.originalEntries.length; i++) {
       util.removeFileOrDirectory(
           task.originalEntries[i], onEntryDeleted, onFilesystemError);
     }
   }
 
   function onEntryServiced(targetEntry, size) {
-    if (!targetEntry) {
+    // We should not dispatch a PROGRESS event when there is no pending items
+    // in the task.
+    if (task.pendingDirectories.length + task.pendingFiles.length == 0) {
       // All done with the entries in this task.
       // If files are moved within GData, FileEntry.moveTo() is used and
       // there is no need to delete the original files.
       if (task.deleteAfterCopy && !task.sourceAndTargetOnGData) {
         deleteOriginals();
       } else {
         onTaskComplete();
       }
       return;
     }
 
-    var event = new cr.Event('copy-progress');
-    event.reason = 'PROGRESS';
-    self.dispatchEvent(event);
+    self.sendProgressEvent_('PROGRESS');
 
     // We yield a few ms between copies to give the browser a chance to service
     // events (like perhaps the user clicking to cancel the copy, for example).
     setTimeout(function() {
       self.serviceNextTaskEntry_(task, onEntryServiced, errorCallback);
     }, 10);
   }
 
-  var event = new cr.Event('copy-progress');
-  event.reason = 'BEGIN';
-  this.dispatchEvent(event);
   this.serviceNextTaskEntry_(task, onEntryServiced, errorCallback);
 }
 
 /**
  * Service the next entry in a given task.
  */
 FileCopyManager.prototype.serviceNextTaskEntry_ = function(
     task, successCallback, errorCallback) {
   if (this.maybeCancel_())
     return;
 
   var self = this;
-  var sourceEntry = task.takeNextEntry();
+  var sourceEntry = task.getNextEntry();
 
   if (!sourceEntry) {
     // All entries in this task have been copied.
     successCallback(null);
     return;
   }
 
   var sourcePath = task.sourceDirEntry.fullPath;
   if (sourceEntry.fullPath.substr(0, sourcePath.length) != sourcePath) {
     // We found an entry in the list that is not relative to the base source
@@ skipping 135 matching lines @@
         successCallback(targetEntry, file.size)
       };
       writer.write(file);
     }
 
     targetEntry.createWriter(onWriterCreated, errorCallback);
   }
 
   sourceEntry.file(onSourceFileFound, errorCallback);
 };