Fix cut/paste on the same volume.

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(root) {
   this.copyTasks_ = [];
   this.cancelObservers_ = [];
   this.cancelRequested_ = false;
   this.root_ = root;
 }
@@ skipping 16 matching lines @@
 
   this.pendingDirectories = [];
   this.pendingFiles = [];
   this.pendingBytes = 0;
 
   this.completedDirectories = [];
   this.completedFiles = [];
   this.completedBytes = 0;
 
   this.deleteAfterCopy = false;
+  this.move = false;
   this.sourceOnGData = false;
   this.targetOnGData = 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;
   // 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.sourceOnGData && this.targetOnGData);
+  var recurse = !this.move;
   util.recurseAndResolveEntries(entries, recurse, onEntriesRecursed);
 }
 
 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];
@@ skipping 258 matching lines @@
  * Initiate a file copy.
  */
 FileCopyManager.prototype.queueCopy = function(sourceDirEntry,
                                                targetDirEntry,
                                                entries,
                                                deleteAfterCopy,
                                                sourceOnGData,
                                                targetOnGData) {
   var self = this;
   var copyTask = new FileCopyManager.Task(sourceDirEntry, targetDirEntry);
-  copyTask.deleteAfterCopy = deleteAfterCopy;
+  if (deleteAfterCopy) {
+    if (DirectoryModel.getRootPath(sourceDirEntry.fullPath) ==
+            DirectoryModel.getRootPath(targetDirEntry.fullPath)) {
+      copyTask.move = true;
+    } else {
+      copyTask.deleteAfterCopy = true;
+    }
+  }
   copyTask.sourceOnGData = sourceOnGData;
   copyTask.targetOnGData = targetOnGData;
   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.
@@ skipping 74 matching lines @@
       var entry = task.originalEntries[i];
       util.removeFileOrDirectory(
           entry, onEntryDeleted.bind(self, entry), onFilesystemError);
     }
   }
 
   function onEntryServiced(targetEntry, size) {
     // 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.
-      var sourceAndTargetOnGData = task.sourceOnGData && task.targetOnGData;
-      if (task.deleteAfterCopy && !sourceAndTargetOnGData) {
+      if (task.deleteAfterCopy) {
         deleteOriginals();
       } else {
         onTaskComplete();
       }
       return;
     }
 
     self.sendProgressEvent_('PROGRESS');
 
     // We yield a few ms between copies to give the browser a chance to service
@@ skipping 147 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.deleteAfterCopy &&
-        DirectoryModel.getRootPath(sourceEntry.fullPath) ==
-            DirectoryModel.getRootPath(targetDirEntry.fullPath)) {
+    if (task.move) {
       resolveDirAndBaseName(
           targetDirEntry, targetRelativePath,
           function(dirEntry, fileName) {
             sourceEntry.moveTo(dirEntry, fileName,
                                onFilesystemMoveComplete.bind(self, sourceEntry),
                                onFilesystemError);
           },
           onFilesystemError);
-      // Since the file has been moved (not copied) the original file doesn't
-      // need to be deleted.
-      task.deleteAfterCopy = false;
       return;
     }
 
-    if (task.sourceOnGData && task.targetOnGData && !task.deleteAfterCopy) {
+    if (task.sourceOnGData && task.targetOnGData) {
       // 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) {
         resolveDirAndBaseName(
             targetDirEntry, targetRelativePath,
             function(dirEntry, fileName) {
               sourceEntry.copyTo(dirEntry, fileName,
                   onFilesystemCopyComplete.bind(self, sourceEntry),
                   onFilesystemError);
@@ skipping 83 matching lines @@
         successCallback(targetEntry, file.size)
       };
       writer.write(file);
     }
 
     targetEntry.createWriter(onWriterCreated, errorCallback);
   }
 
   sourceEntry.file(onSourceFileFound, errorCallback);
 };