Fix moving by dragging and CTRL-X CTRL-V.

chrome/browser/resources/file_manager/background/js/file_operation_manager.js

 // Copyright 2013 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.
 
 'use strict';
 
 /**
  * Utilities for FileOperationManager.
  */
 var fileOperationUtil = {};
@@ skipping 280 matching lines @@
       });
 };
 
 /**
  * @constructor
  */
 function FileOperationManager() {
   this.copyTasks_ = [];
   this.deleteTasks_ = [];
   this.taskIdCounter_ = 0;
-
   this.eventRouter_ = new FileOperationManager.EventRouter();
 
   Object.seal(this);
 }
 
 /**
  * Get FileOperationManager instance. In case is hasn't been initialized, a new
  * instance is created.
  *
  * @return {FileOperationManager} A FileOperationManager instance.
@@ skipping 262 matching lines @@
               entry.processedBytes = 0;
               resolvedEntryMap[entry.toURL()] = entry;
             }
             this.processingEntries[index] = resolvedEntryMap;
             callback();
           }.bind(this),
           function(error) {
             console.error(
                 'Failed to resolve for copy: %s',
                 util.getFileErrorMnemonic(error.code));
+            callback();
           });
     }.bind(this, i));
   }
 
   group.run(function() {
     // Fill totalBytes.
     this.totalBytes = 0;
     for (var i = 0; i < this.processingEntries.length; i++) {
       for (var entryURL in this.processingEntries[i])
         this.totalBytes += this.processingEntries[i][entryURL].size;
@@ skipping 307 matching lines @@
   var group = new AsyncUtil.Group();
   for (var i = 0; i < this.sourceEntries.length; i++) {
     group.add(function(index, callback) {
       fileOperationUtil.resolveRecursively(
           this.sourceEntries[index],
           function(entries) {
             for (var j = 0; j < entries.length; j++)
               resolvedEntryMap[entries[j].toURL()] = entries[j];
             callback();
           },
-          function(error) {});
+          callback);
     }.bind(this, i));
   }
 
   group.run(function() {
     // For zip archiving, all the entries are processed at once.
     this.processingEntries = [resolvedEntryMap];
 
     this.totalBytes = 0;
     for (var url in resolvedEntryMap)
       this.totalBytes += resolvedEntryMap[url].size;
@@ skipping 236 matching lines @@
     // Do nothing, if we have no entries to be pasted.
     if (filteredEntries.length === 0)
        return;
 
     this.queueCopy_(targetEntry, filteredEntries, isMove);
   }.bind(this));
 };
 
 /**
  * Checks if the move operation is available between the given two locations.
+ * This method uses the volume manager, which is lazily created, therefore the
+ * result is returned asynchronously.
  *
  * @param {DirectoryEntry} sourceEntry An entry from the source.
  * @param {DirectoryEntry} targetDirEntry Directory entry for the target.
- * @return {boolean} Whether we can move from the source to the target.
+ * @param {function(boolean)} callback Callback with result whether the entries
+ *     can be directly moved.
+ * @private
  */
-FileOperationManager.prototype.isMovable = function(
-    sourceEntry, targetDirEntry) {
-  var sourceLocationInfo = this.volumeManager_.getLocationInfo(sourceEntry);
-  var targetDirLocationInfo = this.volumeManager_.getLocationInfo(
-      targetDirEntry);
-
-  return sourceLocationInfo && targetDirLocationInfo &&
-      sourceLocationInfo.volumeInfo === targetDirLocationInfo.volumeInfo;
+FileOperationManager.prototype.isMovable_ = function(
+    sourceEntry, targetDirEntry, callback) {
+  VolumeManager.getInstance(function(volumeManager) {
+    var sourceLocationInfo = volumeManager.getLocationInfo(sourceEntry);
+    var targetDirLocationInfo = volumeManager.getLocationInfo(targetDirEntry);
+    callback(
+        sourceLocationInfo && targetDirLocationInfo &&
+        sourceLocationInfo.volumeInfo === targetDirLocationInfo.volumeInfo);
+  });
 };
 
 /**
- * Initiate a file copy.
+ * Initiate a file copy. When copying files, null can be specified as source
+ * directory.
  *
  * @param {DirectoryEntry} targetDirEntry Target directory.
  * @param {Array.<Entry>} entries Entries to copy.
  * @param {boolean} isMove In case of move.
- * @return {FileOperationManager.Task} Copy task.
  * @private
  */
 FileOperationManager.prototype.queueCopy_ = function(
     targetDirEntry, entries, isMove) {
-  // When copying files, null can be specified as source directory.
+  var createTask = function(task) {
+    task.taskId = this.generateTaskId_();
+    task.initialize(function() {
+      this.copyTasks_.push(task);
+      this.eventRouter_.sendProgressEvent(
+          'BEGIN', task.getStatus(), task.taskId);
+      if (this.copyTasks_.length === 1)
+        this.serviceAllTasks_();
+    }.bind(this));
+  }.bind(this);
+
   var task;
   if (isMove) {
-    if (this.isMovable(entries[0], targetDirEntry)) {
-      task = new FileOperationManager.MoveTask(entries, targetDirEntry);
-    } else {
-      task = new FileOperationManager.CopyTask(entries, targetDirEntry);
-      task.deleteAfterCopy = true;
-    }
+    // When moving between different volumes, moving is implemented as a copy
+    // and delete. This is because moving between volumes is slow, and moveTo()
+    // is not cancellable nor provides progress feedback.
+    this.isMovable_(entries[0], targetDirEntry, function(isMovable) {
+      if (isMovable) {
+        createTask(new FileOperationManager.MoveTask(entries, targetDirEntry));
+      } else {
+        var task = new FileOperationManager.CopyTask(entries, targetDirEntry);
+        task.deleteAfterCopy = true;
+        createTask(task);
+      }
+    });
   } else {
-    task = new FileOperationManager.CopyTask(entries, targetDirEntry);
+    createTask(new FileOperationManager.CopyTask(entries, targetDirEntry));
   }
-
-  task.taskId = this.generateTaskId_();
-  task.initialize(function() {
-    this.copyTasks_.push(task);
-    this.eventRouter_.sendProgressEvent('BEGIN', task.getStatus(), task.taskId);
-    if (this.copyTasks_.length == 1)
-      this.serviceAllTasks_();
-  }.bind(this));
-
-  return task;
 };
 
 /**
  * Service all pending tasks, as well as any that might appear during the
  * copy.
  *
  * @private
  */
 FileOperationManager.prototype.serviceAllTasks_ = function() {
   if (!this.copyTasks_.length) {
@@ skipping 181 matching lines @@
 
 /**
  * Generates new task ID.
  *
  * @return {string} New task ID.
  * @private
  */
 FileOperationManager.prototype.generateTaskId_ = function() {
   return 'file-operation-' + this.taskIdCounter_++;
 };