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() {

[Rick Byers, 2012/03/09 21:45:45]

This function name is misleading now (you're not 'taking' anything).  Maybe it
should be 'get nextEntry'?

[bshe, 2012/03/12 00:13:34]

Done.

+  // 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();

[Rick Byers, 2012/03/09 21:45:45]

You're implicitly assuming that 'entry' is still the next entry on the pending
list.  Are you sure that's always the case (I haven't looked at how this is
used)?  Regardless I'd suggest removing the risk of mismatch by either:
 1) checking that 'entry' still matches the next pending 
entry and throwing an exception or something if it doesn't, or
 2) removing entry wherever it occurs in the pending list (and possibly throwing
an exception if it occurs nowhere, but a no-op in that case probably isn't
terrible either).

[bshe, 2012/03/12 00:13:34]

It seems entry is targetEntry and shift function removes the corresponding
srcEntry. They will never be the same (src and target file path cant be the
same). 

From the code, it seems only after the targetEntry successfully wrote the file
system, the file copy manager then start to fetch next srcEntry in
pendingDirectories/Files list. So it should be safe here.

We can try to test if the entry is a targetEntry of srcEntry(entry returned from
shift function) to improve the safty here. But it probably wont be trivial and
we should probably create a new bug to track it. Given the risk if pretty low, I
am not sure if it's worth it though... 

   } 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 259 matching lines @@
         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');
@@ skipping 154 matching lines @@
         successCallback(targetEntry, file.size)
       };
       writer.write(file);
     }
 
     targetEntry.createWriter(onWriterCreated, errorCallback);
   }
 
   sourceEntry.file(onSourceFileFound, errorCallback);
 };