Move FileCopyManager to background page.

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.
 
 /**
  * @constructor
  * @param {DirectoryEntry} root Root directory entry.
  */
 function FileCopyManager(root) {
   this.copyTasks_ = [];
   this.cancelObservers_ = [];
   this.cancelRequested_ = false;
   this.root_ = root;
+  this.unloadTimeout_ = null;
 }
 
-FileCopyManager.prototype = {
-  __proto__: cr.EventTarget.prototype
+var fileCopyManagerInstance = null;
+
+/**
+ * Get FileCopyManager instance. In case is hasn't been initialized, a new
+ * instance is created.
+ * @param {DirectoryEntry} root Root entry.
+ * @return {FileCopyManager} A FileCopyManager instance.
+ */
+FileCopyManager.getInstance = function(root) {
+  if (fileCopyManagerInstance === null) {
+    fileCopyManagerInstance = new FileCopyManager(root);
+  }
+  return fileCopyManagerInstance;
 };
 
 /**
  * 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} sourceDirEntry Source directory.
@@ skipping 202 matching lines @@
 
   var percentage = status.completedBytes / status.totalBytes;
 
   return {
     percentage: percentage,
     pendingItems: status.pendingItems
   };
 };
 
 /**
+ * Send an event to all the FileManager windows.
+ * @private
+ * @param {string} eventName Event name.
+ * @param {Object} eventArgs An object with arbitrary event parameters.
+ */
+FileCopyManager.prototype.sendEvent_ = function(eventName, eventArgs) {
+  var windows = chrome.extension.getViews();
+  for (var i = 0; i < windows.length; i++) {
+    var w = windows[i];
+    if (w.fileCopyManagerWrapper)
+      w.fileCopyManagerWrapper.onEvent(eventName, eventArgs);
+  }
+
+  if (this.copyTasks_.length === 0) {
+    if (this.unloadTimeout_ === null)
+      this.unloadTimeout_ = setTimeout(close, 5000);
+  } else {
+    this.unloadTimeout_ = null;
+  }
+};
+
+/**
+ * Write to console.log on all the active FileManager windows.
+ * @private
+ */
+FileCopyManager.prototype.log_ = function() {
+  var windows = chrome.extension.getViews();
+  for (var i = 0; i < windows.length; i++) {
+    windows[i].console.log.apply(windows[i].console, arguments);
+  }
+};
+
+/**
  * Dispatch a simple copy-progress event with reason and optional err data.
  * @private
  * @param {string} reason Event type.
  * @param {FileCopyManager.Error} opt_err Error.
  */
 FileCopyManager.prototype.sendProgressEvent_ = function(reason, opt_err) {
-  var event = new cr.Event('copy-progress');
+  var event = {};
   event.reason = reason;
   if (opt_err)
     event.error = opt_err;
-  this.dispatchEvent(event);
+  this.sendEvent_('copy-progress', event);
 };
 
 /**
  * Dispatch an event of file operation completion (allows to update the UI).
  * @private
  * @param {string} reason Completed file operation: 'movied|copied|deleted'.
  * @param {Array.<Entry>} affectedEntries deleted ot created entries.
  */
 FileCopyManager.prototype.sendOperationEvent_ = function(reason,
                                                          affectedEntries) {
-  var event = new cr.Event('copy-operation-complete');
+  var event = {};
   event.reason = reason;
   event.affectedEntries = affectedEntries;
-  this.dispatchEvent(event);
+  this.sendEvent_('copy-operation-complete', event);
 };
 
 /**
  * Completely clear out the copy queue, either because we encountered an error
  * or completed successfully.
  * @private
  */
 FileCopyManager.prototype.resetQueue_ = function() {
   for (var i = 0; i < this.cancelObservers_.length; i++)
     this.cancelObservers_[i]();
@@ skipping 344 matching lines @@
     self.sendOperationEvent_('copied', [entry]);
     onCopyCompleteBase(entry, size);
   }
 
   function onCopyProgress(entry, size) {
     task.updateFileCopyProgress(entry, size);
     self.sendProgressEvent_('PROGRESS');
   }
 
   function onError(reason, data) {
-    console.log('serviceNextTaskEntry error: ' + reason + ':', data);
+    this.log_('serviceNextTaskEntry error: ' + reason + ':', data);
     errorCallback(new FileCopyManager.Error(reason, data));
   }
 
   function onFilesystemCopyComplete(sourceEntry, targetEntry) {
     // TODO(benchan): We currently do not know the size of data being
     // copied by FileEntry.copyTo(), so task.completedBytes will not be
     // increased. We will address this issue once we need to use
     // task.completedBytes to track the progress.
     self.sendOperationEvent_('copied', [sourceEntry, targetEntry]);
     onCopyCompleteBase(targetEntry, 0);
@@ skipping 120 matching lines @@
         }
       }
       chrome.fileBrowserPrivate.onFileTransfersUpdated.addListener(
           onFileTransfersUpdated);
       chrome.fileBrowserPrivate.transferFile(
         sourceFileUrl, targetFileUrl,
         function() {
           chrome.fileBrowserPrivate.onFileTransfersUpdated.removeListener(
               onFileTransfersUpdated);
           if (chrome.extension.lastError) {
-            console.log(
+            this.log_(
                 'Error copying ' + sourceFileUrl + ' to ' + targetFileUrl);
             onFilesystemError({
               code: chrome.extension.lastError.message,
               toGDrive: task.targetOnGData,
               sourceFileUrl: sourceFileUrl
             });
           } else {
             targetDirEntry.getFile(targetRelativePath, {},
                 function(targetEntry) {
                   targetEntry.getMetadata(function(metadata) {
@@ skipping 100 matching lines @@
       };
 
       writer.write(file);
     }
 
     targetEntry.createWriter(onWriterCreated, errorCallback);
   }
 
   sourceEntry.file(onSourceFileFound, errorCallback);
 };
+