Re-implement cancellation of copyFileEntry_().

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.
 
 'use strict';
 
 /**
  * @constructor
  */
 function FileCopyManager() {
@@ skipping 465 matching lines @@
   this.maybeScheduleCloseBackgroundPage_();
 };
 
 /**
  * Request that the current copy queue be abandoned.
  *
  * @param {function()=} opt_callback On cancel.
  */
 FileCopyManager.prototype.requestCancel = function(opt_callback) {
   this.cancelRequested_ = true;
-  if (this.cancelCallback_)
+  if (this.cancelCallback_) {
     this.cancelCallback_();
+    this.cancelCallback_ = null;
+  }
   if (opt_callback)
     this.cancelObservers_.push(opt_callback);
 
   // If there is any active task it will eventually call maybeCancel_.
   // Otherwise call it right now.
   if (this.copyTasks_.length == 0)
     this.doCancel_();
 };
 
 /**
@@ skipping 382 matching lines @@
     var isTargetOnDrive = PathUtil.isDriveBasedPath(targetDirEntry.fullPath);
 
     if (!isSourceOnDrive && !isTargetOnDrive) {
       // Sending a file from local to local.
       // To copy local file, we use File blob and FileWriter to take the
       // progress.
       targetDirEntry.getFile(
           targetRelativePath,
           {create: true, exclusive: true},
           function(targetEntry) {
-            self.copyFileEntry_(
+            self.cancelCallback_ = self.copyFileEntry_(
                 sourceEntry, targetEntry,
-                onCopyProgress, onCopyComplete, onFilesystemError);
+                onCopyProgress,
+                function(entry, size) {
+                  self.cancelCallback_ = null;
+                  onCopyComplete(entry, size);
+                },
+                function(error) {
+                  self.cancelCallback_ = null;
+                  onFilesystemError(error);
+                });
           },
           util.flog('Error getting file: ' + targetRelativePath,
                     onFilesystemError));
       return;
     }
 
     // Sending a file from a) Drive to Drive, b) Drive to local or c) local to
     // Drive.
     var sourceFileUrl = sourceEntry.toURL();
     var sourceFilePath = util.extractFilePath(sourceFileUrl);
@@ skipping 79 matching lines @@
  *     copied.
  * @param {function(FileEntry, number)} progressCallback Function that will be
  *     called when a part of the source entry is copied. It takes |targetEntry|
  *     and size of the last copied chunk as parameters.
  * @param {function(FileEntry, number)} successCallback Function that will be
  *     called the copy operation finishes. It takes |targetEntry| and size of
  *     the last (not previously reported) copied chunk as parameters.
  * @param {function(FileError)} errorCallback Function that will be called
  *     if an error is encountered. Takes error type and additional error data
  *     as parameters.
+ * @return {function()} Callback to cancel the current file copy operation.
+ *     When the cancel is done, errorCallback will be called. The returned
+ *     callback must not be called more than once.
  * @private
  */
 FileCopyManager.prototype.copyFileEntry_ = function(sourceEntry,
                                                     targetEntry,
                                                     progressCallback,
                                                     successCallback,
                                                     errorCallback) {
-  if (this.maybeCancel_())
-    return;
+  // Set to true when cancel is requested.
+  var cancelRequested = false;
 
-  var self = this;
+  sourceEntry.file(function(file) {
+    if (cancelRequested) {
+      errorCallback(util.createFileError(FileError.ABORT_ERR));
+      return;
+    }
 
-  var onSourceFileFound = function(file) {
-    var onWriterCreated = function(writer) {
+    targetEntry.createWriter(function(writer) {
+      if (cancelRequested) {
+        errorCallback(util.createFileError(FileError.ABORT_ERR));
+        return;
+      }
+
       var reportedProgress = 0;
-      writer.onerror = function(progress) {
-        errorCallback(writer.error);
+      writer.onerror = writer.onabort = function(progress) {
+        errorCallback(cancelRequested ?
+            util.createFileError(FileError.ABORT_ERR) :
+            writer.error);
       };
 
       writer.onprogress = function(progress) {
-        if (self.maybeCancel_()) {
+        if (cancelRequested) {
           // If the copy was cancelled, we should abort the operation.
+          // The errorCallback will be called by writer.onabort after the
+          // termination.
           writer.abort();
           return;
         }
+
         // |progress.loaded| will contain total amount of data copied by now.
         // |progressCallback| expects data amount delta from the last progress
         // update.
         progressCallback(targetEntry, progress.loaded - reportedProgress);
         reportedProgress = progress.loaded;
       };
 
       writer.onwrite = function() {
+        if (cancelRequested) {
+          errorCallback(util.createFileError(FileError.ABORT_ERR));
+          return;
+        }
+
         sourceEntry.getMetadata(function(metadata) {
-          chrome.fileBrowserPrivate.setLastModified(targetEntry.toURL(),
+          if (cancelRequested) {
+            errorCallback(util.createFileError(FileError.ABORT_ERR));
+            return;
+          }
+
+          chrome.fileBrowserPrivate.setLastModified(
+              targetEntry.toURL(),
               '' + Math.round(metadata.modificationTime.getTime() / 1000));
           successCallback(targetEntry, file.size - reportedProgress);
         });
       };
 
       writer.write(file);
-    };
+    }, errorCallback);
+  }, errorCallback);
 
-    targetEntry.createWriter(onWriterCreated, errorCallback);
+  return function() {
+    cancelRequested = true;
   };
-
-  sourceEntry.file(onSourceFileFound, errorCallback);
 };
 
 /**
  * Moves all entries in the task.
  *
  * @param {FileCopyManager.Task} task A move task to be run.
  * @param {function(util.EntryChangedType, Entry)} entryChangedCallback Callback
  *     invoked when an entry is changed.
  * @param {function()} progressCallback Callback invoked periodically during
  *     the moving.
@@ skipping 138 matching lines @@
       if (success) {
         task.targetDirEntry.getFile(
             destPath, {create: false},
             function(entry) {
               entryChangedCallback(util.EntryChangedType.CREATE, entry);
               successCallback();
             },
             onFilesystemError);
       } else {
         onFilesystemError(
-            Object.create(FileError.prototype, {
-              code: {
-                get: function() { return FileError.INVALID_MODIFICATION_ERR; }
-              }
-            }));
+            util.createFileError(FileError.INVALID_MODIFICATION_ERR));
       }
     };
 
     progressCallback();
     chrome.fileBrowserPrivate.zipSelection(dirURL, selectionURLs, destPath,
         onZipSelectionComplete);
   };
 
   FileCopyManager.Task.deduplicatePath(
       task.targetDirEntry, destName + '.zip', onDeduplicated, errorCallback);
@@ skipping 139 matching lines @@
       // Assume self.cancelRequested_ == false.
       // 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.
       self.eventRouter_.sendProgressEvent('PROGRESS', self.getStatus());
     }
   });
 };