[FileBrowser] Progress of copying file to/from gdata.

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.
 
 /**
  * @constructor
  * @param {DirectoryEntry} root Root directory entry.
  */
 function FileCopyManager(root) {
   this.copyTasks_ = [];
@@ skipping 178 matching lines @@
   var rv = {
     pendingItems: 0,  // Files + Directories
     pendingFiles: 0,
     pendingDirectories: 0,
     pendingBytes: 0,
 
     completedItems: 0,  // Files + Directories
     completedFiles: 0,
     completedDirectories: 0,
     completedBytes: 0,
-
-    // If source or target are on gdata we can't use completed bytes to track
-    // progress.
-    useBytesForPercentage: true
   };
 
   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.completedFiles += task.completedFiles.length;
     rv.completedDirectories += task.completedDirectories.length;
     rv.completedBytes += task.completedBytes;
-    if (task.sourceOnGData || task.targetOnGData)
-      rv.useBytesForPercentage = false;
   }
   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();
 
-  // TODO(tbarzic): We can't use completedBytes and totalBytes to estimate
-  // progress if the file is transferred from/to drive for two reasons:
-  // 1' completedBytes don't get updated for drive files.
-  // 2' There is no way to get completed bytes in real time. If completed bytes
-  //    are updated when each item finished and if there is a large item to be
-  //    copied, the progress bar would stop moving until the item is finished
-  //    and then jump a large portion of the bar.
-  //
-  // Obviously 2' > 1'.
-  var percentage = status.useBytesForPercentage ?
-      (status.completedBytes / status.totalBytes) :
-      ((status.completedItems + 0.5) / status.totalItems);
+  var percentage = status.completedBytes / status.totalBytes;
 
   return {
     percentage: percentage,
     pendingItems: status.pendingItems
   };
 };
 
 /**
  * Dispatch a simple copy-progress event with reason and optional err data.
  * @private
@@ skipping 499 matching lines @@
         return;
       }
     }
 
     // TODO(benchan): Until GDataFileSystem supports FileWriter, we use the
     // transferFile API to copy files into or out from a gdata file system.
     if (sourceEntry.isFile && (task.sourceOnGData || task.targetOnGData)) {
       var sourceFileUrl = sourceEntry.toURL();
       var targetFileUrl = targetDirEntry.toURL() + '/' +
                           encodeURIComponent(targetRelativePath);
+      var transferedBytes = 0;
+      function onFileTransfersUpdated(statusList) {
+        for (var i = 0; i < statusList.length; i++) {
+          var s = statusList[i];
+          if ((s.fileUrl == sourceFileUrl || s.fileUrl == targetFileUrl) &&
+              s.processed > transferedBytes) {
+            onCopyProgress(sourceEntry, s.processed - transferedBytes);
+            transferedBytes = s.processed;
+          }
+        }
+      }
+      chrome.fileBrowserPrivate.onFileTransfersUpdated.addListener(
+          onFileTransfersUpdated);
       chrome.fileBrowserPrivate.transferFile(
         sourceFileUrl, targetFileUrl,
         function() {
+          chrome.fileBrowserPrivate.onFileTransfersUpdated.removeListener(
+              onFileTransfersUpdated);
           if (chrome.extension.lastError) {
             console.log(
                 'Error copying ' + sourceFileUrl + ' to ' + targetFileUrl);
             onFilesystemError({
               code: chrome.extension.lastError.message,
               toGDrive: task.targetOnGData,
               sourceFileUrl: sourceFileUrl
             });
           } else {
             targetDirEntry.getFile(targetRelativePath, {},
-                onFilesystemCopyComplete.bind(self, sourceEntry),
+                function(targetEntry) {
+                  targetEntry.getMetadata(function(metadata) {
+                    if (metadata.size > transferedBytes)
+                      onCopyProgress(sourceEntry,
+                                     metadata.size - transferedBytes);
+                    onFilesystemCopyComplete(sourceEntry, targetEntry);
+                  });
+                },
                 onFilesystemError);
           }
         });
       return;
     }
 
     if (sourceEntry.isDirectory) {
       targetDirEntry.getDirectory(
           targetRelativePath,
           {create: true, exclusive: true},
@@ skipping 84 matching lines @@
       };
 
       writer.write(file);
     }
 
     targetEntry.createWriter(onWriterCreated, errorCallback);
   }
 
   sourceEntry.file(onSourceFileFound, errorCallback);
 };