Remove sourceOnDrive and targetOnDrive from FileCopyManager.Task.

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 89 matching lines @@
 };
 
 /**
  * A record of a queued copy operation.
  *
  * Multiple copy operations may be queued at any given time.  Additional
  * Tasks may be added while the queue is being serviced.  Though a
  * cancel operation cancels everything in the queue.
  *
  * @param {DirectoryEntry} targetDirEntry Target directory.
- * @param {boolean} sourceOnDrive True if the source entries are on Drive.
- * @param {boolean} targetOnDrive True if the target entry is on Drive.
  * @param {DirectoryEntry=} opt_zipBaseDirEntry Base directory dealt as a root
  *     in ZIP archive.
  * @constructor
  */
-FileCopyManager.Task = function(targetDirEntry,
-                                sourceOnDrive,
-                                targetOnDrive,
-                                opt_zipBaseDirEntry) {
+FileCopyManager.Task = function(targetDirEntry, opt_zipBaseDirEntry) {
   this.targetDirEntry = targetDirEntry;
   this.zipBaseDirEntry = opt_zipBaseDirEntry;
   this.originalEntries = null;
 
   this.pendingDirectories = [];
   this.pendingFiles = [];
   this.pendingBytes = 0;
 
   this.completedDirectories = [];
   this.completedFiles = [];
   this.completedBytes = 0;
 
   this.deleteAfterCopy = false;
   this.move = false;
   this.zip = false;
-  this.sourceOnDrive = sourceOnDrive;
-  this.targetOnDrive = targetOnDrive;
 
   // 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_ = [];
 };
 
 /**
@@ skipping 382 matching lines @@
   return true;
 };
 
 /**
  * Kick off pasting.
  *
  * @param {Array.<string>} files Pathes of source files.
  * @param {Array.<string>} directories Pathes of source directories.
  * @param {boolean} isCut If the source items are removed from original
  *     location.
- * @param {boolean} isOnDrive If the source items are on Google Drive.
  * @param {string} targetPath Target path.
- * @param {boolean} targetOnDrive If target is on Drive.
  */
-FileCopyManager.prototype.paste = function(files, directories, isCut, isOnDrive,
-                                           targetPath, targetOnDrive) {
+FileCopyManager.prototype.paste = function(
+    files, directories, isCut, targetPath) {
   var self = this;
   var entries = [];
   var added = 0;
   var total;
 
   var steps = {
     start: function() {
       // Filter entries.
       var entryFilterFunc = function(entry) {
         if (entry == '')
@@ skipping 28 matching lines @@
       if (added == total)
         steps.onSourceEntriesFound();
     },
 
     onSourceEntriesFound: function() {
       self.root_.getDirectory(targetPath, {},
                               steps.onTargetEntryFound, steps.onPathError);
     },
 
     onTargetEntryFound: function(targetEntry) {
-      self.queueCopy_(targetEntry,
-                      entries,
-                      isCut,
-                      isOnDrive,
-                      targetOnDrive);
+      self.queueCopy_(targetEntry, entries, isCut);
     },
 
     onPathError: function(err) {
       self.eventRouter_.sendProgressEvent(
           'ERROR',
           self.getStatus(),
           new FileCopyManager.Error(
               util.FileOperationErrorType.FILESYSTEM_ERROR, err));
     }
   };
@@ skipping 15 matching lines @@
          (PathUtil.getRootPath(sourceEntry.fullPath) ==
           PathUtil.getRootPath(targetDirEntry.fullPath));
 };
 
 /**
  * Initiate a file copy.
  *
  * @param {DirectoryEntry} targetDirEntry Target directory.
  * @param {Array.<Entry>} entries Entries to copy.
  * @param {boolean} deleteAfterCopy In case of move.
- * @param {boolean} sourceOnDrive Source directory on Drive.
- * @param {boolean} targetOnDrive Target directory on Drive.
  * @return {FileCopyManager.Task} Copy task.
  * @private
  */
-FileCopyManager.prototype.queueCopy_ = function(targetDirEntry,
-                                                entries,
-                                                deleteAfterCopy,
-                                                sourceOnDrive,
-                                                targetOnDrive) {
+FileCopyManager.prototype.queueCopy_ = function(
+    targetDirEntry, entries, deleteAfterCopy) {
   var self = this;
   // When copying files, null can be specified as source directory.
-  var copyTask = new FileCopyManager.Task(
-      targetDirEntry, sourceOnDrive, targetOnDrive);
+  var copyTask = new FileCopyManager.Task(targetDirEntry);
   if (deleteAfterCopy) {
     if (this.isMovable(entries[0], targetDirEntry)) {
       copyTask.move = true;
     } else {
       copyTask.deleteAfterCopy = true;
     }
   }
   copyTask.setEntries(entries, function() {
     self.copyTasks_.push(copyTask);
     self.maybeScheduleCloseBackgroundPage_();
@@ skipping 199 matching lines @@
         util.EntryChangedType.CREATED, targetEntry);
     onCopyCompleteBase(targetEntry, 0);
   };
 
   var onFilesystemError = function(err) {
     errorCallback(new FileCopyManager.Error(
         util.FileOperationErrorType.FILESYSTEM_ERROR, err));
   };
 
   var onDeduplicated = function(targetRelativePath) {
+    var isSourceOnDrive = PathUtil.isDriveBasedPath(sourceEntry.fullPath);
+    var isTargetOnDrive = PathUtil.isDriveBasedPath(targetDirEntry.fullPath);
+
     // TODO(benchan): drive::FileSystem has not implemented directory copy,
     // and thus we only call FileEntry.copyTo() for files. Revisit this
     // code when drive::FileSystem supports directory copy.
-    if (sourceEntry.isFile && (task.sourceOnDrive || task.targetOnDrive)) {
+    if (sourceEntry.isFile && (isSourceOnDrive || isTargetOnDrive)) {
       var sourceFileUrl = sourceEntry.toURL();
       var targetFileUrl = targetDirEntry.toURL() + '/' +
                           encodeURIComponent(targetRelativePath);
       var sourceFilePath = util.extractFilePath(sourceFileUrl);
       var targetFilePath = util.extractFilePath(targetFileUrl);
       var transferedBytes = 0;
 
       var onStartTransfer = function() {
         chrome.fileBrowserPrivate.onFileTransfersUpdated.addListener(
             onFileTransfersUpdated);
@@ skipping 24 matching lines @@
           var s = statusList[i];
           // Comparing urls is unreliable, since they may use different
           // url encoding schemes (eg. rfc2396 vs. rfc3986).
           var filePath = util.extractFilePath(s.fileUrl);
           if (filePath == sourceFilePath || filePath == targetFilePath) {
             var processed = s.processed;
 
             // It becomes tricky when both the sides are on Drive.
             // Currently, it is implemented by download followed by upload.
             // Note, however, download will not happen if the file is cached.
-            if (task.sourceOnDrive && task.targetOnDrive) {
+            if (isSourceOnDrive && isTargetOnDrive) {
               if (filePath == sourceFilePath) {
                 // Download transfer is detected. Let's halve the progress.
                 downTransfer = processed = (s.processed >> 1);
               } else {
                 // If download transfer has been detected, the upload transfer
                 // is stacked on top of it after halving. Otherwise, just use
                 // the upload transfer as-is.
                 processed = downTransfer > 0 ?
                    downTransfer + (s.processed >> 1) : s.processed;
               }
             }
 
             if (processed > transferedBytes) {
               onCopyProgress(sourceEntry, processed - transferedBytes);
               transferedBytes = processed;
             }
           }
         }
       };
 
-      if (task.sourceOnDrive && task.targetOnDrive) {
+      if (isSourceOnDrive && isTargetOnDrive) {
         targetDirEntry.getDirectory(
             PathUtil.dirname(targetRelativePath), {create: false},
             function(dirEntry) {
               onStartTransfer();
               sourceEntry.copyTo(
                   dirEntry, PathUtil.basename(targetRelativePath),
                   onSuccessTransfer, onFailTransfer);
             },
             onFilesystemError);
         return;
       }
 
       var onFileTransferCompleted = function() {
         self.cancelCallback_ = null;
         if (chrome.runtime.lastError) {
           onFailTransfer({
             code: chrome.runtime.lastError.message,
-            toDrive: task.targetOnDrive,
+            toDrive: isTargetOnDrive,
             sourceFileUrl: sourceFileUrl
           });
         } else {
           targetDirEntry.getFile(targetRelativePath, {}, onSuccessTransfer,
                                                          onFailTransfer);
         }
       };
 
       self.cancelCallback_ = function() {
         self.cancelCallback_ = null;
         chrome.fileBrowserPrivate.onFileTransfersUpdated.removeListener(
             onFileTransfersUpdated);
-        if (task.sourceOnDrive) {
+        if (isSourceOnDrive) {
           chrome.fileBrowserPrivate.cancelFileTransfers([sourceFileUrl],
                                                         function() {});
         } else {
           chrome.fileBrowserPrivate.cancelFileTransfers([targetFileUrl],
                                                         function() {});
         }
       };
 
       // TODO(benchan): Until drive::FileSystem supports FileWriter, we use the
       // transferFile API to copy files into or out from a drive file system.
@@ skipping 365 matching lines @@
             filesystemError = error;
           onComplete();
         });
   }
 };
 
 /**
  * Creates a zip file for the selection of files.
  *
  * @param {Entry} dirEntry the directory containing the selection.
- * @param {boolean} isOnDrive If directory is on Drive.
  * @param {Array.<Entry>} selectionEntries the selected entries.
  */
-FileCopyManager.prototype.zipSelection = function(dirEntry, isOnDrive,
-                                                  selectionEntries) {
+FileCopyManager.prototype.zipSelection = function(dirEntry, selectionEntries) {
   var self = this;
-  var zipTask = new FileCopyManager.Task(
-      dirEntry, isOnDrive, isOnDrive, dirEntry);
+  var zipTask = new FileCopyManager.Task(dirEntry, dirEntry);
   zipTask.zip = true;
   zipTask.setEntries(selectionEntries, function() {
     // TODO: per-entry zip progress update with accurate byte count.
     // For now just set pendingBytes to zero so that the progress bar is full.
     zipTask.pendingBytes = 0;
     self.copyTasks_.push(zipTask);
     if (self.copyTasks_.length == 1) {
       // 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());
     }
   });
 };