File manager: support for zipping selected files.

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.
 
 if (chrome.extension) {
   function getContentWindows() {
     return chrome.extension.getViews();
   }
 }
 
@@ skipping 49 matching lines @@
   this.pendingDirectories = [];
   this.pendingFiles = [];
   this.pendingBytes = 0;
 
   this.completedDirectories = [];
   this.completedFiles = [];
   this.completedBytes = 0;
 
   this.deleteAfterCopy = false;
   this.move = false;
+  this.zip = 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_ = [];
 };
@@ skipping 149 matching lines @@
     pendingBytes: 0,
 
     completedItems: 0,  // Files + Directories
     completedFiles: 0,
     completedDirectories: 0,
     completedBytes: 0,
 
     percentage: NaN,
     pendingCopies: 0,
     pendingMoves: 0,
+    pendingZips: 0,
     filename: ''  // In case pendingItems == 1
   };
 
   var pendingFile = null;
 
   for (var i = 0; i < this.copyTasks_.length; i++) {
     var task = this.copyTasks_[i];
     var pendingFiles = task.pendingFiles.length;
     var pendingDirectories = task.pendingDirectories.length;
     rv.pendingFiles += pendingFiles;
     rv.pendingDirectories += pendingDirectories;
     rv.pendingBytes += task.pendingBytes;
 
     rv.completedFiles += task.completedFiles.length;
     rv.completedDirectories += task.completedDirectories.length;
     rv.completedBytes += task.completedBytes;
 
-    if (task.move || task.deleteAfterCopy) {
+    if (task.zip) {
+      rv.pendingZips += pendingFiles + pendingDirectories;
+    } else if (task.move || task.deleteAfterCopy) {
       rv.pendingMoves += pendingFiles + pendingDirectories;
     } else {
       rv.pendingCopies += pendingFiles + pendingDirectories;
     }
 
     if (task.pendingFiles.length === 1)
       pendingFile = task.pendingFiles[0];
 
     if (task.pendingDirectories.length === 1)
       pendingFile = task.pendingDirectories[0];
@@ skipping 380 matching lines @@
 
     self.sendProgressEvent_('PROGRESS');
 
     // We yield a few ms between copies to give the browser a chance to service
     // events (like perhaps the user clicking to cancel the copy, for example).
     setTimeout(function() {
       self.serviceNextTaskEntry_(task, onEntryServiced, errorCallback);
     }, 10);
   }
 
-  this.serviceNextTaskEntry_(task, onEntryServiced, errorCallback);
+  if (!task.zip)
+    this.serviceNextTaskEntry_(task, onEntryServiced, errorCallback);
+  else
+    this.serviceZipTask_(task, onTaskComplete, errorCallback);
 };
 
 /**
  * Service the next entry in a given task.
  * TODO(olege): Refactor this method into a separate class.
  *
  * @private
  * @param {FileManager.Task} task A task.
  * @param {Function} successCallback On success.
  * @param {Function} errorCallback On error.
@@ skipping 309 matching lines @@
     // Check to see if the target exists.  This kicks off the rest of the copy
     // if the target is not found, or raises an error if it does.
     util.resolvePath(targetDirEntry, targetRelativePath, onTargetExists,
                      onTargetNotResolved);
   }
 
   tryNextCopy();
 };
 
 /**
+ * Service a zip file creation task.
+ *
+ * @private
+ * @param {FileManager.Task} task A task.
+ * @param {Function} completeCallback On complete.
+ * @param {Function} errorCallback On error.
+ */
+FileCopyManager.prototype.serviceZipTask_ = function(task, completeCallback,
+                                                     errorCallback) {
+  var self = this;
+  var dirURL = task.sourceDirEntry.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());
+
+  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 copyNumber = 0;
+  var firstExistingEntry = null;
+  var destPath = destName + '.zip';
+
+  function onError(reason, data) {
+    self.log_('serviceZipTask error: ' + reason + ':', data);
+    errorCallback(new FileCopyManager.Error(reason, data));
+  }
+
+  function onTargetExists(existingEntry) {
+    if (copyNumber < 10) {
+      if (!firstExistingEntry)
+        firstExistingEntry = existingEntry;
+      copyNumber++;
+      tryZipSelection();
+    } else {
+      onError('TARGET_EXISTS', firstExistingEntry);
+    }
+  }
+
+  function onTargetNotResolved() {
+    function onZipSelectionComplete(success) {
+      if (success) {
+        self.sendProgressEvent_('SUCCESS');
+      } else {
+        self.sendProgressEvent_('ERROR',
+            new FileCopyManager.Error('FILESYSTEM_ERROR', ''));
+      }
+      completeCallback(task);
+    }
+
+    self.sendProgressEvent_('PROGRESS');
+    chrome.fileBrowserPrivate.zipSelection(dirURL, selectionURLs, destPath,
+        onZipSelectionComplete);
+  }
+
+  function tryZipSelection() {
+    if (copyNumber > 0)
+      destPath = destName + ' (' + copyNumber + ').zip';
+
+    // Check if the target exists. This kicks off the rest of the zip file
+    // creation if the target is not found, or raises an error if it does.
+    util.resolvePath(task.targetDirEntry, destPath, onTargetExists,
+                     onTargetNotResolved);
+  }
+
+  tryZipSelection();
+};
+
+/**
  * Copy the contents of sourceEntry into targetEntry.
  *
  * @private
  * @param {Entry} sourceEntry entry that will be copied.
  * @param {Entry} targetEntry entry to which sourceEntry will be copied.
  * @param {function(Entry, 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(Entry, number)} successCallback function that will be called
  *     the copy operation finishes. It takes |targetEntry| and size of the last
@@ skipping 67 matching lines @@
     timeout: setTimeout(this.forceDeleteTask.bind(this, id),
         FileCopyManager.DELETE_TIMEOUT)
   };
   this.deleteTasks_.push(task);
   this.maybeScheduleCloseBackgroundPage_();
   callback(id);
   this.sendDeleteEvent_(task, 'SCHEDULED');
 };
 
 /**
+ * Creates a zip file for the selection of files.
+ * @param {Entry} dirEntry the directory containing the selection.
+ * @param {boolean} isOnGData If directory is on GDrive.
+ * @param {Array.<Entry>} selectionEntries the selected entries.
+ */
+FileCopyManager.prototype.zipSelection = function(dirEntry, isOnGData,
+                                                   selectionEntries) {
+  var self = this;
+  var zipTask = new FileCopyManager.Task(dirEntry, dirEntry);
+  zipTask.zip = true;
+  zipTask.sourceOnGData = isOnGData;
+  zipTask.targetOnGData = isOnGData;
+  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.sendProgressEvent_('PROGRESS');
+    }
+  });
+};
+
+/**
  * Force deletion before timeout runs out.
  * @param {number} id The delete task id (as returned by deleteEntries).
  */
 FileCopyManager.prototype.forceDeleteTask = function(id) {
   var task = this.findDeleteTaskAndCancelTimeout_(id);
   if (task) this.serviceDeleteTask_(task);
 };
 
 /**
  * Cancels the scheduled deletion.
@@ skipping 57 matching lines @@
  */
 FileCopyManager.prototype.sendDeleteEvent_ = function(task, reason) {
   this.sendEvent_('delete', {
     reason: reason,
     id: task.id,
     urls: task.entries.map(function(e) {
       return util.makeFilesystemUrl(e.fullPath);
     })
   });
 };