Move content deduplication into the scan process.

ui/file_manager/file_manager/background/js/media_scanner.js

 // Copyright 2014 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.
 
 /**
  * Class representing the results of a scan operation.
  *
  * @interface
  */
 importer.MediaScanner = function() {};
@@ skipping 15 matching lines @@
 importer.MediaScanner.prototype.addObserver;
 
 /**
  * Remove a previously registered observer.
  *
  * @param {!importer.ScanObserver} observer
  */
 importer.MediaScanner.prototype.removeObserver;
 
 /**
- * Class representing the results of a scan operation.
- *
- * @interface
- */
-importer.ScanResult = function() {};
-
-/**
- * @return {boolean} true if scanning is complete.
- */
-importer.ScanResult.prototype.isFinal;
-
-/**
- * @return {boolean} true if scanning is invalidated.
- */
-importer.ScanResult.prototype.isInvalidated;
-
-/**
- * Returns all files entries discovered so far. The list will be
- * complete only after scanning has completed and {@code isFinal}
- * returns {@code true}.
- *
- * @return {!Array.<!FileEntry>}
- */
-importer.ScanResult.prototype.getFileEntries;
-
-/**
- * Returns a promise that fires when scanning is complete.
- *
- * @return {!Promise.<!importer.ScanResult>}
- */
-importer.ScanResult.prototype.whenFinal;
-
-/**
- * @return {!importer.ScanResult.Statistics}
- */
-importer.ScanResult.prototype.getStatistics;
-
-/**
- * @typedef {{
- *   scanDuration: number,
- *   newFileCount: number,
- *   duplicateFileCount: number,
- *   sizeBytes: number
- * }}
- */
-importer.ScanResult.Statistics;
-
-/**
  * Recursively scans through a list of given files and directories, and creates
  * a list of media files.
  *
  * @constructor
  * @struct
  * @implements {importer.MediaScanner}
  *
  * @param {function(!FileEntry): !Promise.<string>} hashGenerator
- * @param {!importer.HistoryLoader} historyLoader
+ * @param {function(!FileEntry, !importer.Destination):
+ *     !Promise<!importer.Disposition>} dispositionChecker
  * @param {!importer.DirectoryWatcherFactory} watcherFactory
  */
-importer.DefaultMediaScanner = function(
-    hashGenerator, historyLoader, watcherFactory) {
-
-  /** @private {!importer.HistoryLoader} */
-  this.historyLoader_ = historyLoader;
+importer.DefaultMediaScanner =
+    function(hashGenerator, dispositionChecker, watcherFactory) {
 
   /**
    * A little factory for DefaultScanResults which allows us to forgo
    * the saving it's dependencies in our fields.
    * @return {!importer.DefaultScanResult}
    */
   this.createScanResult_ = function() {
     return new importer.DefaultScanResult(hashGenerator);
   };
 
   /** @private {!Array.<!importer.ScanObserver>} */
   this.observers_ = [];
 
   /**
+   * @param {!FileEntry} entry
+   * @param {!importer.Destination} destination
+   * @return {!Promise<!importer.Disposition>}
+   */
+  this.getDisposition_ = dispositionChecker;
+
+  /**
    * @private {!importer.DirectoryWatcherFactory}
    * @const
    */
   this.watcherFactory_ = watcherFactory;
 };
 
 /** @override */
 importer.DefaultMediaScanner.prototype.addObserver = function(observer) {
   this.observers_.push(observer);
 };
@@ skipping 127 matching lines @@
 /**
  * Finds all files beneath directory.
  *
  * @param {!importer.DefaultScanResult} scan
  * @param {!FileEntry} entry
  * @return {!Promise}
  * @private
  */
 importer.DefaultMediaScanner.prototype.onFileEntryFound_ =
     function(scan, entry) {
-  return this.hasHistoryDuplicate_(entry)
+  return this.getDisposition_(entry, importer.Destination.GOOGLE_DRIVE)
       .then(
           /**
-           * @param {boolean} duplicate
+           * @param {!importer.Disposition} disposition The disposition
+           *     of the entry. Either some sort of dupe, or an original.
            * @return {!Promise}
            * @this {importer.DefaultMediaScanner}
            */
-          function(duplicate) {
-            return duplicate ?
-                this.onDuplicateFileFound_(scan, entry) :
-                this.onUniqueFileFound_(scan, entry);
+          function(disposition) {
+            return disposition === importer.Disposition.ORIGINAL ?
+                this.onUniqueFileFound_(scan, entry) :
+                this.onDuplicateFileFound_(scan, entry, disposition);
           }.bind(this));
 };
 
 /**
  * Adds a newly discovered file to the given scan result.
  *
  * @param {!importer.DefaultScanResult} scan
  * @param {!FileEntry} entry
  * @return {!Promise}
  * @private
@@ skipping 17 matching lines @@
             }
           }.bind(this));
 };
 
 /**
  * Adds a duplicate file to the given scan result.  This is to track the number
  * of duplicates that are being encountered.
  *
  * @param {!importer.DefaultScanResult} scan
  * @param {!FileEntry} entry
+ * @param {!importer.Disposition} disposition
  * @return {!Promise}
  * @private
  */
 importer.DefaultMediaScanner.prototype.onDuplicateFileFound_ =
-    function(scan, entry) {
-  scan.addDuplicateEntry(entry);
+    function(scan, entry, disposition) {
+  scan.addDuplicateEntry(entry, disposition);
   return Promise.resolve();
 };
 
 /**
- * @param {!FileEntry} entry
- * @return {!Promise.<boolean>} True if there is a history-entry-duplicate
- *     for the file.
- * @private
+ * Class representing the results of a scan operation.
+ *
+ * @interface
  */
-importer.DefaultMediaScanner.prototype.hasHistoryDuplicate_ = function(entry) {
-  return this.historyLoader_.getHistory()
-      .then(
-          /**
-           * @param {!importer.ImportHistory} history
-           * @return {!Promise}
-           * @this {importer.DefaultMediaScanner}
-           */
-          function(history) {
-            return Promise.all([
-              history.wasCopied(entry, importer.Destination.GOOGLE_DRIVE),
-              history.wasImported(entry, importer.Destination.GOOGLE_DRIVE)
-            ]).then(
-                /**
-                 * @param {!Array.<boolean>} results
-                 * @return {!Promise}
-                 * @this {importer.DefaultMediaScanner}
-                 */
-                function(results) {
-                  return results[0] || results[1];
-                }.bind(this));
-          }.bind(this));
-};
+importer.ScanResult = function() {};
+
+/**
+ * @return {boolean} true if scanning is complete.
+ */
+importer.ScanResult.prototype.isFinal;
+
+/**
+ * @return {boolean} true if scanning is invalidated.
+ */
+importer.ScanResult.prototype.isInvalidated;
+
+/**
+ * Returns all files entries discovered so far. The list will be
+ * complete only after scanning has completed and {@code isFinal}
+ * returns {@code true}.
+ *
+ * @return {!Array<!FileEntry>}
+ */
+importer.ScanResult.prototype.getFileEntries;
+
+/**
+ * Returns a promise that fires when scanning is complete.
+ *
+ * @return {!Promise<!importer.ScanResult>}
+ */
+importer.ScanResult.prototype.whenFinal;
+
+/**
+ * @return {!importer.ScanResult.Statistics}
+ */
+importer.ScanResult.prototype.getStatistics;
+
+/**
+ * @typedef {{
+ *   scanDuration: number,
+ *   newFileCount: number,
+ *   duplicates: !Object<!importer.Disposition, number>,
+ *   sizeBytes: number
+ * }}
+ */
+importer.ScanResult.Statistics;
 
 /**
  * Results of a scan operation. The object is "live" in that data can and
  * will change as the scan operation discovers files.
  *
  * <p>The scan is complete, and the object will become static once the
  * {@code whenFinal} promise resolves.
  *
  * @constructor
  * @struct
@@ skipping 17 matching lines @@
    * Hashcodes of all files included captured by this result object so-far.
    * Used to dedupe newly discovered files against other files withing
    * the ScanResult.
    * @private {!Object.<string, !FileEntry>}
    */
   this.fileHashcodes_ = {};
 
   /** @private {number} */
   this.totalBytes_ = 0;
 
-  /** @private {number} */
-  this.duplicateFileCount_ = 0;
+  /** @private {!Object<!importer.Disposition, number>} */
+  this.duplicates_ = {};
 
   /**
    * The point in time when the scan was started.
    * @type {Date}
    */
   this.scanStarted_ = new Date();
 
   /**
    * The point in time when the last scan activity occured.
    * @type {Date}
@@ skipping 66 matching lines @@
         return this.createHashcode_(entry)
             .then(
                 /**
                  * @param {string} hashcode
                  * @this {importer.DefaultScanResult}
                  */
                 function(hashcode) {
                   this.lastScanActivity_ = new Date();
 
                   if (hashcode in this.fileHashcodes_) {
-                    this.addDuplicateEntry(entry);
+                    this.addDuplicateEntry(
+                        entry,
+                        importer.Disposition.SCAN_DUPLICATE);
                     return false;
                   }
 
                   entry.size = metadata.size;
                   this.totalBytes_ += metadata.size;
                   this.fileHashcodes_[hashcode] = entry;
                   this.fileEntries_.push(entry);
                   return true;
                 }.bind(this));
 
     }.bind(this));
 };
 
 /**
  * Logs the fact that a duplicate file entry was discovered during the scan.
  * @param {!FileEntry} entry
+ * @param {!importer.Disposition} disposition
  */
-importer.DefaultScanResult.prototype.addDuplicateEntry = function(entry) {
-  this.duplicateFileCount_++;
+importer.DefaultScanResult.prototype.addDuplicateEntry =
+    function(entry, disposition) {
+  if (!(disposition in this.duplicates_)) {
+    this.duplicates_[disposition] = 0;
+  }
+  this.duplicates_[disposition]++;
 };
 
 /** @override */
 importer.DefaultScanResult.prototype.getStatistics = function() {
   return {
     scanDuration:
         this.lastScanActivity_.getTime() - this.scanStarted_.getTime(),
     newFileCount: this.fileEntries_.length,
-    duplicateFileCount: this.duplicateFileCount_,
+    duplicates: this.duplicates_,
     sizeBytes: this.totalBytes_
   };
 };
 
 /**
  * Watcher for directories.
  * @interface
  */
 importer.DirectoryWatcher = function() {};
 
@@ skipping 61 matching lines @@
   if (!this.watchedDirectories_[event.entry.toURL()])
     return;
   this.triggered = true;
   for (var url in this.watchedDirectories_) {
     chrome.fileManagerPrivate.removeFileWatch(url, function() {});
   }
   chrome.fileManagerPrivate.onDirectoryChanged.removeListener(
       assert(this.listener_));
   this.callback_();
 };