Introduce fileOperationUtil.

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';
 
 /**
+ * Utilities for FileCopyManager.
+ */
+var fileOperationUtil = {};
+
+/**
+ * Simple wrapper for util.deduplicatePath. On error, this method translates
+ * the FileError to FileCopyManager.Error object.
+ *
+ * @param {DirectoryEntry} dirEntry The target directory entry.
+ * @param {string} relativePath The path to be deduplicated.
+ * @param {function(string)} successCallback Callback run with the deduplicated
+ *     path on success.
+ * @param {function(FileCopyManager.Error)} errorCallback Callback run on error.
+ */
+fileOperationUtil.deduplicatePath = function(
+    dirEntry, relativePath, successCallback, errorCallback) {
+  util.deduplicatePath(
+      dirEntry, relativePath, successCallback,
+      function(err) {
+        var onFileSystemError = function(error) {
+          errorCallback(new FileCopyManager.Error(
+              util.FileOperationErrorType.FILESYSTEM_ERROR, error));
+        };
+
+        if (err.code == FileError.PATH_EXISTS_ERR) {
+          // Failed to uniquify the file path. There should be an existing
+          // entry, so return the error with it.
+          util.resolvePath(
+              dirEntry, relativePath,
+              function(entry) {
+                errorCallback(new FileCopyManager.Error(
+                    util.FileOperationErrorType.TARGET_EXISTS, entry));
+              },
+              onFileSystemError);
+          return;
+        }
+        onFileSystemError(err);
+      });
+};
+
+/**
+ * Sets last modified date to the entry.
+ * @param {Entry} entry The entry to which the last modified is set.
+ * @param {Date} modificationTime The last modified time.
+ */
+fileOperationUtil.setLastModified = function(entry, modificationTime) {
+  chrome.fileBrowserPrivate.setLastModified(
+      entry.toURL(), '' + Math.round(modificationTime.getTime() / 1000));
+};
+
+/**
+ * Thin wrapper of chrome.fileBrowserPrivate.zipSelection to adapt its
+ * interface similar to copyTo().
+ *
+ * @param {Array.<Entry>} sources The array of entries to be archived.
+ * @param {DirectoryEntry} parent The entry of the destination directory.
+ * @param {string} newName The name of the archive to be created.
+ * @param {function(FileEntry)} successCallback Callback invoked when the
+ *     operation is successfully done with the entry of the created archive.
+ * @param {function(FileError)} errorCallback Callback invoked when an error
+ *     is found.
+ */
+fileOperationUtil.zipSelection = function(
+    sources, parent, newName, successCallback, errorCallback) {
+  chrome.fileBrowserPrivate.zipSelection(
+      parent.toURL(),
+      sources.map(function(e) { return e.toURL(); }),
+      newName, function(success) {
+        if (!success) {
+          // Failed to create a zip archive.
+          errorCallback(
+              util.createFileError(FileError.INVALID_MODIFICATION_ERR));
+          return;
+        }
+
+        // Returns the created entry via callback.
+        parent.getFile(
+            newName, {create: false}, successCallback, errorCallback);
+      });
+};
+
+/**
  * @constructor
  */
 function FileCopyManager() {
   this.copyTasks_ = [];
   this.deleteTasks_ = [];
   this.cancelObservers_ = [];
   this.cancelRequested_ = false;
   this.cancelCallback_ = null;
   this.unloadTimeout_ = null;
 
@@ skipping 111 matching lines @@
   this.zip = 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_ = [];
 };
 
-/**
- * Simple wrapper for util.deduplicatePath. On error, this method translates
- * the FileError to FileCopyManager.Error object.
- *
- * @param {DirectoryEntry} dirEntry The target directory entry.
- * @param {string} relativePath The path to be deduplicated.
- * @param {function(string)} successCallback Callback run with the deduplicated
- *     path on success.
- * @param {function(FileCopyManager.Error)} errorCallback Callback run on error.
- */
-FileCopyManager.Task.deduplicatePath = function(
-    dirEntry, relativePath, successCallback, errorCallback) {
-  util.deduplicatePath(
-      dirEntry, relativePath, successCallback,
-      function(err) {
-        var onFileSystemError = function(error) {
-          errorCallback(new FileCopyManager.Error(
-              util.FileOperationErrorType.FILESYSTEM_ERROR, error));
-        };
-
-        if (err.code == FileError.PATH_EXISTS_ERR) {
-          // Failed to uniquify the file path. There should be an existing
-          // entry, so return the error with it.
-          util.resolvePath(
-              dirEntry, relativePath,
-              function(entry) {
-                errorCallback(new FileCopyManager.Error(
-                    util.FileOperationErrorType.TARGET_EXISTS, entry));
-              },
-              onFileSystemError);
-          return;
-        }
-        onFileSystemError(err);
-      });
-};
 
 /**
  * @param {Array.<Entry>} entries Entries.
  * @param {function()} callback When entries resolved.
  */
 FileCopyManager.Task.prototype.setEntries = function(entries, callback) {
   var self = this;
   this.originalEntries = entries;
   // When moving directories, FileEntry.moveTo() is used if both source
   // and target are on Drive. There is no need to recurse into directories.
@@ skipping 715 matching lines @@
                 function(error) {
                   self.cancelCallback_ = null;
                   onFilesystemError(error);
                 });
           },
           util.flog('Error getting file: ' + targetRelativePath,
                     onFilesystemError));
       return;
     }
 
+    // TODO(hidehiko): Move following code to fileOperationUtil.
+
     // 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);
 
     // Progress callback.
     // Because the uploading the file from local cache to Drive server will be
     // done as a part of background Drive file system sync, so for this copy
     // operation, what we need to take care about is only file downloading.
     var numTransferredBytes = 0;
@@ skipping 54 matching lines @@
               function(error) {
                 self.cancelCallback_ = null;
                 chrome.fileBrowserPrivate.onFileTransfersUpdated.removeListener(
                     onFileTransfersUpdated);
                 onFilesystemError(error);
               });
         },
         onFilesystemError);
   };
 
-  FileCopyManager.Task.deduplicatePath(
+  fileOperationUtil.deduplicatePath(
       targetDirEntry, originalPath, onDeduplicated, errorCallback);
 };
 
 /**
  * Copies the contents of sourceEntry into targetEntry.
+ * TODO(hidehiko): Move this method into fileOperationUtil.
  *
  * @param {FileEntry} sourceEntry The file entry that will be copied.
  * @param {FileEntry} targetEntry The file entry to which sourceEntry will be
  *     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.
@@ skipping 53 matching lines @@
           errorCallback(util.createFileError(FileError.ABORT_ERR));
           return;
         }
 
         sourceEntry.getMetadata(function(metadata) {
           if (cancelRequested) {
             errorCallback(util.createFileError(FileError.ABORT_ERR));
             return;
           }
 
-          chrome.fileBrowserPrivate.setLastModified(
-              targetEntry.toURL(),
-              '' + Math.round(metadata.modificationTime.getTime() / 1000));
+          fileOperationUtil.setLastModified(
+              targetEntry, metadata.modificationTime);
           successCallback(targetEntry, file.size - reportedProgress);
         });
       };
 
       writer.write(file);
     }, errorCallback);
   }, errorCallback);
 
   return function() {
     cancelRequested = true;
@@ skipping 69 matching lines @@
   var sourcePath = sourceEntry.originalSourcePath;
   if (sourceEntry.fullPath.substr(0, sourcePath.length) != sourcePath) {
     // We found an entry in the list that is not relative to the base source
     // path, something is wrong.
     errorCallback(new FileCopyManager.Error(
         util.FileOperationErrorType.UNEXPECTED_SOURCE_FILE,
         sourceEntry.fullPath));
     return;
   }
 
-  FileCopyManager.Task.deduplicatePath(
+  fileOperationUtil.deduplicatePath(
       task.targetDirEntry,
       task.applyRenames(sourceEntry.fullPath.substr(sourcePath.length + 1)),
       function(targetRelativePath) {
         var onFilesystemError = function(err) {
           errorCallback(new FileCopyManager.Error(
               util.FileOperationErrorType.FILESYSTEM_ERROR,
               err));
         };
 
         task.targetDirEntry.getDirectory(
@@ skipping 24 matching lines @@
  *     invoked when an entry is changed.
  * @param {function()} progressCallback Callback invoked periodically during
  *     the moving.
  * @param {function()} successCallback On complete.
  * @param {function(FileCopyManager.Error)} errorCallback On error.
  * @private
  */
 FileCopyManager.prototype.serviceZipTask_ = function(
     task, entryChangedCallback, progressCallback, successCallback,
     errorCallback) {
-  var dirURL = task.zipBaseDirEntry.toURL();
-  var selectionURLs = [];
-  for (var i = 0; i < task.pendingDirectories.length; i++)
-    selectionURLs.push(task.pendingDirectories[i].toURL());
-  for (var i = 0; i < task.pendingFiles.length; i++)
-    selectionURLs.push(task.pendingFiles[i].toURL());
-
   // TODO(hidehiko): we should localize the name.
   var destName = 'Archive';
   if (task.originalEntries.length == 1) {
     var entryPath = task.originalEntries[0].fullPath;
     var i = entryPath.lastIndexOf('/');
     var basename = (i < 0) ? entryPath : entryPath.substr(i + 1);
     i = basename.lastIndexOf('.');
     destName = ((i < 0) ? basename : basename.substr(0, i));
   }
 
-  var onDeduplicated = function(destPath) {
-    var onZipSelectionComplete = function(success) {
-      var onFilesystemError = function(err) {
-        errorCallback(new FileCopyManager.Error(
-            util.FileOperationErrorType.FILESYSTEM_ERROR,
-            err));
-      };
+  fileOperationUtil.deduplicatePath(
+      task.targetDirEntry, destName + '.zip',
+      function(destPath) {
+        progressCallback();
 
-      if (success) {
-        task.targetDirEntry.getFile(
-            destPath, {create: false},
+        fileOperationUtil.zipSelection(
+            task.pendingDirectories.concat(task.pendingFiles),
+            task.zipBaseDirEntry,
+            destPath,
             function(entry) {
               entryChangedCallback(util.EntryChangedType.CREATE, entry);
               successCallback();
             },
-            onFilesystemError);
-      } else {
-        onFilesystemError(
-            util.createFileError(FileError.INVALID_MODIFICATION_ERR));
-      }
-    };
-
-    progressCallback();
-    chrome.fileBrowserPrivate.zipSelection(dirURL, selectionURLs, destPath,
-        onZipSelectionComplete);
-  };
-
-  FileCopyManager.Task.deduplicatePath(
-      task.targetDirEntry, destName + '.zip', onDeduplicated, errorCallback);
+            function(error) {
+              errorCallback(new FileCopyManager.Error(
+                  util.FileOperationErrorType.FILESYSTEM_ERROR, error));
+            });
+      },
+      errorCallback);
 };
 
 /**
  * Timeout before files are really deleted (to allow undo).
  */
 FileCopyManager.DELETE_TIMEOUT = 30 * 1000;
 
 /**
  * Schedules the files deletion.
  *
@@ skipping 116 matching lines @@
  * @param {Array.<Entry>} selectionEntries The selected entries.
  */
 FileCopyManager.prototype.zipSelection = function(dirEntry, selectionEntries) {
   var self = this;
   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 completedBytes to same value as totalBytes so that the
     // progress bar is full.
-    zipTask.completedBytes = zip.Task.totalBytes;
+    zipTask.completedBytes = zipTask.totalBytes;
     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());
     }
   });
 };