Use FileEntry.copyTo() and FileEntry.moveTo() on GData file system.

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 15 matching lines @@
 
   this.pendingDirectories = [];
   this.pendingFiles = [];
   this.pendingBytes = 0;
 
   this.completedDirectories = [];
   this.completedFiles = [];
   this.completedBytes = 0;
 
   this.deleteAfterCopy = false;
+  this.sourceAndTargetOnGData = false;
 
   // 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_ = [];
 }
 
 FileCopyManager.Task.prototype.setEntries = function(entries, callback) {
   var self = this;
 
   function onEntriesRecursed(result) {
     self.pendingDirectories = result.dirEntries;
     self.pendingFiles = result.fileEntries;
     self.pendingBytes = result.fileBytes;
     callback();
   }
 
   this.originalEntries = entries;
-  util.recurseAndResolveEntries(entries, onEntriesRecursed);
+  // 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();
 
   if (this.pendingFiles.length)
     return this.pendingFiles.shift();
 
   return null;
@@ skipping 119 matching lines @@
   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, root) {
+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);
   }
 
   function onSourceEntryFound(dirEntry) {
     function onComplete() {
       self.queueCopy(results.sourceDirEntry,
             targetEntry,
             results.entries,
-            results.isCut);
+            results.isCut,
+            sourceAndTargetOnGData);
     }
 
     function onEntryFound(entry) {
       // When getDirectories/getFiles finish, they call addEntry with null.
       // We dont want to add null to our entries.
       if (entry != null) {
         results.entries.push(entry);
         added++;
         if (added == total && results.sourceDirEntry != null)
           onComplete();
@@ skipping 28 matching lines @@
                     onSourceEntryFound,
                     onPathError);
 }
 
 /**
  * Initiate a file copy.
  */
 FileCopyManager.prototype.queueCopy = function(sourceDirEntry,
                                                targetDirEntry,
                                                entries,
-                                               deleteAfterCopy) {
+                                               deleteAfterCopy,
+                                               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_();
     }
   });
 
   return copyTask;
 };
@@ skipping 67 matching lines @@
 
     for (var i = 0; i < task.originalEntries.length; i++) {
       util.removeFileOrDirectory(
           task.originalEntries[i], onEntryDeleted, onFilesystemError);
     }
   }
 
   function onEntryServiced(targetEntry, size) {
     if (!targetEntry) {
       // All done with the entries in this task.
-      if (task.deleteAfterCopy) {
-        deleteOriginals()
+      // 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);
 
@@ skipping 86 matching lines @@
     }
   }
 
   function onTargetNotResolved(err) {
     // We expect to be unable to resolve the target file, since we're going
     // to create it during the copy.  However, if the resolve fails with
     // anything other than NOT_FOUND, that's trouble.
     if (err.code != FileError.NOT_FOUND_ERR)
       return onError('FILESYSTEM_ERROR', err);
 
+    if (task.sourceAndTargetOnGData) {
+      if (task.deleteAfterCopy) {
+        sourceEntry.moveTo(targetDirEntry, targetRelativePath,

[dgozman, 2012/03/12 09:46:03]

Can we have such copyTo/moveTo methods for all entries? It would be much cleaner
for clients.

[Ben Chan, 2012/03/12 14:58:47]

It's possible to use copyTo/moveTo for native filesystems. But I guess the
existing code uses other approach in order to cross origins and show progress of
copying. Is that correct, @rginda?    We may be able to optimize for certain
cases using copyTo/moveTo.

+                           onCopyComplete, onError);
+        return;
+      } else {
+        // TODO(benchan): GDataFileSystem has not implemented directory copy,
+        // and thus we only call FileEntry.copyTo() for files. Revisit this
+        // code when GDataFileSystem supports directory copy.
+        if (!sourceEntry.isDirectory) {
+          sourceEntry.copyTo(targetDirEntry, targetRelativePath,
+                             onCopyComplete, onError);
+          return;
+        }
+      }
+    }
+
     if (sourceEntry.isDirectory) {
       targetDirEntry.getDirectory(
           targetRelativePath,
           {create: true, exclusive: true},
           function(targetEntry) {
             if (targetRelativePath != originalPath) {
               task.registerRename(originalPath, targetRelativePath);
             }
             onCopyComplete(targetEntry);
           },
@@ skipping 45 matching lines @@
         successCallback(targetEntry, file.size)
       };
       writer.write(file);
     }
 
     targetEntry.createWriter(onWriterCreated, errorCallback);
   }
 
   sourceEntry.file(onSourceFileFound, errorCallback);
 };