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 38 matching lines @@
     self.pendingDirectories = result.dirEntries;
     self.pendingFiles = result.fileEntries;
     self.pendingBytes = result.fileBytes;
     callback();
   }
 
   this.originalEntries = entries;
   util.recurseAndResolveEntries(entries, onEntriesRecursed);
 }
 
-FileCopyManager.Task.prototype.takeNextEntry = function() {
+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)
-    return this.pendingDirectories.shift();
+    return this.pendingDirectories[0];
 
   if (this.pendingFiles.length)
-    return this.pendingFiles.shift();
+    return this.pendingFiles[0];
 
   return null;
 };
 
 FileCopyManager.Task.prototype.markEntryComplete = function(entry, size) {
   if (entry.isDirectory) {
     this.completedDirectories.push(entry);
+    this.pendingDirectories.shift();
   } else {
     this.completedFiles.push(entry);
     this.completedBytes += size;
+    this.pendingFiles.shift();
   }
 };
 
 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;
 };
 
+FileCopyManager.prototype.getProgress = function() {

[Rick Byers, 2012/03/12 14:20:08]

Since this is a public function you should have a full jsdoc header that
desribes the function and it's return value.

[bshe, 2012/03/12 16:41:19]

Done.

+  var status = this.getStatus();
+  var result = {

[Rick Byers, 2012/03/12 14:20:08]

No need to create a variable and initializing to 0 first, Just do:
return {
  // TODO(bshe): big comment...
  percentage: (status.completed ...),

  pendingItems = status.pendingItems;
}

[bshe, 2012/03/12 16:41:19]

Done.

+    percentage: 0,
+    pendingItems: 0
+  };
+
+  // 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.
+  result.percentage = (status.completedItems + 1) / status.totalItems;
+
+  result.pendingItems = status.pendingItems;
+  return result;
+};
+
 /**
  * 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_ = [];
@@ skipping 105 matching lines @@
                                                entries,
                                                deleteAfterCopy) {
   var self = this;
   var copyTask = new FileCopyManager.Task(sourceDirEntry, targetDirEntry);
   copyTask.deleteAfterCopy = deleteAfterCopy;
   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.
+      var event = new cr.Event('copy-progress');
+      event.reason = 'PROGRESS';
+      self.dispatchEvent(event);
     }
   });
 
   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.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.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.
+    var event = new cr.Event('copy-progress');
+    event.reason = 'PROGRESS';
+    self.dispatchEvent(event);

[Rick Byers, 2012/03/12 14:20:08]

Probably worth encapsulating these 3 lines in a simple
'sendProgressEvent_(reason)' helper function - I see it's repeated several times
now.

[bshe, 2012/03/12 16:41:19]

Done.

+
     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.
+
+  var event = new cr.Event('copy-progress');
+  event.reason = 'BEGIN';
+  this.dispatchEvent(event);
   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 (task.deleteAfterCopy) {
         deleteOriginals()
       } else {
         onTaskComplete();
       }
       return;
     }
 
     var event = new cr.Event('copy-progress');
     event.reason = 'PROGRESS';
     self.dispatchEvent(event);
 
     // 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 74 matching lines @@
                     onFilesystemError));
     } else {
       targetDirEntry.getFile(
           targetRelativePath,
           {create: true, exclusive: true},
           function(targetEntry) {
             self.copyEntry_(sourceEntry, targetEntry,
                            onCopyComplete, onError);
           },
           util.flog('Error getting file: ' + targetRelativePath,
-                    onFilesystemError));
+                     onFilesystemError));

[Rick Byers, 2012/03/12 14:20:08]

Remove added extra space

[bshe, 2012/03/12 16:41:19]

Done.

     }
   }
 
   function tryNextCopy() {
     targetRelativePath = targetRelativePrefix;
     if (copyNumber > 0) {
       targetRelativePath += ' (' + copyNumber + ')';
     }
     targetRelativePath += targetExt;
 
@@ skipping 23 matching lines @@
         successCallback(targetEntry, file.size)
       };
       writer.write(file);
     }
 
     targetEntry.createWriter(onWriterCreated, errorCallback);
   }
 
   sourceEntry.file(onSourceFileFound, errorCallback);
 };