Update ImportHistory with support for reading history from multiple files.

ui/file_manager/file_manager/common/js/importer_common.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.
 
 // Shared cloud importer namespace
 var importer = importer || {};
 
 /** @enum {string} */
 importer.ScanEvent = {
   FINALIZED: 'finalized',
@@ skipping 25 matching lines @@
 };
 
 /**
  * @typedef {function(
  *     !importer.ScanEvent, importer.ScanResult)}
  */
 importer.ScanObserver;
 
 /**
  * Volume types eligible for the affections of Cloud Import.
- * @private @const {!Array.<!VolumeManagerCommon.VolumeType>}
+ * @private @const {!Array<!VolumeManagerCommon.VolumeType>}
  */
 importer.ELIGIBLE_VOLUME_TYPES_ = [
   VolumeManagerCommon.VolumeType.MTP,
   VolumeManagerCommon.VolumeType.REMOVABLE
 ];
 
 /**
  * @enum {string}
  */
 importer.Destination = {
@@ skipping 80 matching lines @@
       path !== '/MP_ROOT' && path !== '/MP_ROOT/') {
     return false;
   }
 
   console.assert(volumeInfoProvider !== null);
   var volumeInfo = volumeInfoProvider.getVolumeInfo(entry);
   return importer.isEligibleVolume(volumeInfo);
 };
 
 /**
- * @return {!Promise.<boolean>} Resolves with true when Cloud Import feature
+ * @return {!Promise<boolean>} Resolves with true when Cloud Import feature
  *     is enabled.
  */
 importer.importEnabled = function() {
   return new Promise(
       function(resolve, reject) {
         chrome.commandLinePrivate.hasSwitch(
             'disable-cloud-import',
             /** @param {boolean} disabled */
             function(disabled) {
               resolve(!disabled);
@@ skipping 17 matching lines @@
     console.error(
         'Unrecognized message type received from photos app: ' + message);
     return Promise.reject();
   }
 
   var storage = importer.ChromeLocalStorage.getInstance();
   return storage.set(importer.Setting.PHOTOS_APP_ENABLED, message);
 };
 
 /**
- * @return {!Promise.<boolean>} Resolves with true when Cloud Import feature
+ * @return {!Promise<boolean>} Resolves with true when Cloud Import feature
  *     is enabled.
  */
 importer.isPhotosAppImportEnabled = function() {
   var storage = importer.ChromeLocalStorage.getInstance();
   return storage.get(importer.Setting.PHOTOS_APP_ENABLED, false);
 };
 
 /**
  * @param {!Date} date
  * @return {string} The current date, in YYYY-MM-DD format.
  */
 importer.getDirectoryNameForDate = function(date) {
   var padAndConvert = function(i) {
     return (i < 10 ? '0' : '') + i.toString();
   };
 
   var year = date.getFullYear().toString();
   // Months are 0-based, but days aren't.
   var month = padAndConvert(date.getMonth() + 1);
   var day = padAndConvert(date.getDate());
 
   // NOTE: We use YYYY-MM-DD since it sorts numerically.
   // Ideally this would be localized and appropriate sorting would
   // be done behind the scenes.
   return year + '-' + month + '-' + day;
 };
 
 /**
- * @return {!Promise.<number>} Resolves with an integer that is probably
+ * @return {!Promise<number>} Resolves with an integer that is probably
  *     relatively unique to this machine (among a users machines).
  */
 importer.getMachineId = function() {
   var storage = importer.ChromeLocalStorage.getInstance();
   return storage.get(importer.Setting.MACHINE_ID)
       .then(
           function(id) {
             if (id) {
               return id;
             }
             var id = importer.generateMachineId_();
             return storage.set(importer.Setting.MACHINE_ID, id)
                 .then(
                     function() {
                       return id;
                     });
           });
 };
 
 /**
- * @return {!Promise.<string>} Resolves with the filename of this
+ * @return {!Promise<string>} Resolves with the filename of this
  *     machines history file.
  */
 importer.getHistoryFilename = function() {
   return importer.getMachineId().then(
       function(machineId) {
         return machineId + '-import-history.log';
       });
 };
 
 /**
  * @param {number} logId
- * @return {!Promise.<string>} Resolves with the filename of this
+ * @return {!Promise<string>} Resolves with the filename of this
  *     machines debug log file.
  */
 importer.getDebugLogFilename = function(logId) {
   return importer.getMachineId().then(
       function(machineId) {
         return machineId + '-import-debug-' + logId + '.log';
       });
 };
 
 /**
@@ skipping 15 matching lines @@
 importer.Resolver = function() {
   /** @private {boolean} */
   this.settled_ = false;
 
   /** @private {function(T=)} */
   this.resolve_;
 
   /** @private {function(*=)} */
   this.reject_;
 
-  /** @private {!Promise.<T>} */
+  /** @private {!Promise<T>} */
   this.promise_ = new Promise(
       function(resolve, reject) {
         this.resolve_ = resolve;
         this.reject_ = reject;
       }.bind(this));
 
   var settler = function() {
     this.settled_ = true;
   }.bind(this);
 
   this.promise_.then(settler, settler);
 };
 
 importer.Resolver.prototype = /** @struct */ {
   /**
    * @return {function(T=)}
    * @template T
    */
   get resolve() {
     return this.resolve_;
   },
   /**
    * @return {function(*=)}
    * @template T
    */
   get reject() {
     return this.reject_;
   },
   /**
-   * @return {!Promise.<T>}
+   * @return {!Promise<T>}
    * @template T
    */
   get promise() {
     return this.promise_;
   },
   /** @return {boolean} */
   get settled() {
     return this.settled_;
   }
 };
@@ skipping 27 matching lines @@
  * @struct
  *
  * @param {!FileEntry} fileEntry
  */
 importer.PromisingFileEntry = function(fileEntry) {
   /** @private {!FileEntry} */
   this.fileEntry_ = fileEntry;
 };
 
 /**
+ * Convenience method for creating new instances. Can, for example,
+ * be passed to Array.map.
+ *
+ * @param {!FileEntry} entry
+ * @return {!importer.PromisingFileEntry}
+ */
+importer.PromisingFileEntry.create = function(entry) {
+  return new importer.PromisingFileEntry(entry);
+};
+
+/**
  * A "Promisary" wrapper around entry.getWriter.
- * @return {!Promise.<!FileWriter>}
+ * @return {!Promise<!FileWriter>}
  */
 importer.PromisingFileEntry.prototype.createWriter = function() {
   return new Promise(this.fileEntry_.createWriter.bind(this.fileEntry_));
 };
 
 /**
  * A "Promisary" wrapper around entry.file.
- * @return {!Promise.<!File>}
+ * @return {!Promise<!File>}
  */
 importer.PromisingFileEntry.prototype.file = function() {
   return new Promise(this.fileEntry_.file.bind(this.fileEntry_));
 };
 
 /**
- * @return {!Promise.<!Object>}
+ * @return {!Promise<!Object>}
  */
 importer.PromisingFileEntry.prototype.getMetadata = function() {
   return new Promise(this.fileEntry_.getMetadata.bind(this.fileEntry_));
 };
 
 /**
  * This prefix is stripped from URL used in import history. It is stripped
  * to same on disk space, parsing time, and runtime memory.
  * @private @const {string}
  */
@@ skipping 25 matching lines @@
  */
 importer.inflateAppUrl = function(deflated) {
   if (deflated.substring(0, 1) === '$') {
     return importer.APP_URL_PREFIX_ + deflated.substring(1);
   }
   return deflated;
 };
 
 /**
  * @param {!FileEntry} fileEntry
- * @return {!Promise.<string>} Resolves with a "hashcode" consisting of
+ * @return {!Promise<string>} Resolves with a "hashcode" consisting of
  *     just the last modified time and the file size.
  */
 importer.createMetadataHashcode = function(fileEntry) {
   var entry = new importer.PromisingFileEntry(fileEntry);
   return new Promise(
       /**
        * @param {function()} resolve
        * @param {function()} reject
        * @this {importer.PersistentImportHistory}
        */
       function(resolve, reject) {
         entry.getMetadata()
             .then(
                 /**
                  * @param {!Object} metadata
-                 * @return {!Promise.<string>}
+                 * @return {!Promise<string>}
                  * @this {importer.PersistentImportHistory}
                  */
                 function(metadata) {
                   if (!('modificationTime' in metadata)) {
                     reject('File entry missing "modificationTime" field.');
                   } else if (!('size' in metadata)) {
                     reject('File entry missing "size" field.');
                   } else {
                     var secondsSinceEpoch =
                         importer.toSecondsFromEpoch(metadata.modificationTime);
@@ skipping 12 matching lines @@
 importer.toSecondsFromEpoch = function(date) {
   // Since we're parsing a value that only has
   // precision to the second, our last three digits
   // will always be 000. We strip them and end up
   // with seconds.
   var milliseconds = String(Date.parse(date));
   return milliseconds.substring(0, milliseconds.length - 3);
 };
 
 /**
- * Factory interface for creating/accessing synced {@code FileEntry}
- * instances and listening to sync events on those files.
- *
- * @interface
+ * Namespace for ChromeSyncFilesystem related stuffs.
  */
-importer.SyncFileEntryProvider = function() {};
-
-/**
- * Provides accsess to the sync FileEntry owned/managed by this class.
- *
- * @return {!Promise.<!FileEntry>}
- */
-importer.SyncFileEntryProvider.prototype.getSyncFileEntry;
-
-/**
- * Factory for synchronized files based on chrome.syncFileSystem.
- *
- * @constructor
- * @implements {importer.SyncFileEntryProvider}
- * @struct
- *
- * @param {string} fileName
- */
-importer.ChromeSyncFileEntryProvider = function(fileName) {
-
-  /** @private {string} */
-  this.fileName_ = fileName;
-
-  /** @private {!Array.<function()>} */
-  this.syncListeners_ = [];
-
-  /** @private {Promise.<!FileEntry>} */
-  this.fileEntryPromise_ = null;
-};
-
-/**
- * Returns a sync FileEntry. Convenience method for class that just want
- * a file, but don't need to monitor changes.
- * @param {!Promise.<string>} fileNamePromise
- * @return {!Promise.<!FileEntry>}
- */
-importer.ChromeSyncFileEntryProvider.getFileEntry =
-    function(fileNamePromise) {
-  return fileNamePromise.then(
-      function(fileName) {
-        return new importer.ChromeSyncFileEntryProvider(fileName)
-          .getSyncFileEntry();
-      });
-};
-
-/** @override */
-importer.ChromeSyncFileEntryProvider.prototype.getSyncFileEntry = function() {
-  if (this.fileEntryPromise_) {
-    return /** @type {!Promise.<!FileEntry>} */ (this.fileEntryPromise_);
-  };
-
-  this.fileEntryPromise_ = this.getFileSystem_()
-      .then(
-          /**
-           * @param {!FileSystem} fileSystem
-           * @return {!Promise.<!FileEntry>}
-           * @this {importer.ChromeSyncFileEntryProvider}
-           */
-          function(fileSystem) {
-            return this.getFileEntry_(fileSystem);
-          }.bind(this));
-
-  return /** @type {!Promise.<!FileEntry>} */ (this.fileEntryPromise_);
-};
+importer.ChromeSyncFilesystem = {};
 
 /**
  * Wraps chrome.syncFileSystem in a Promise.
  *
- * @return {!Promise.<!FileSystem>}
+ * @return {!Promise<!FileSystem>}
  * @private
  */
-importer.ChromeSyncFileEntryProvider.prototype.getFileSystem_ = function() {
+importer.ChromeSyncFilesystem.getFileSystem_ = function() {
   return new Promise(
-      /**
-       * @param {function()} resolve
-       * @param {function()} reject
-       * @this {importer.ChromeSyncFileEntryProvider}
-       */
       function(resolve, reject) {
         chrome.syncFileSystem.requestFileSystem(
-            /**
-              * @param {FileSystem} fileSystem
-              * @this {importer.ChromeSyncFileEntryProvider}
-              */
+            /** @param {FileSystem} fileSystem */
             function(fileSystem) {
               if (chrome.runtime.lastError) {
                 reject(chrome.runtime.lastError.message);
               } else {
                 resolve(/** @type {!FileSystem} */ (fileSystem));
               }
             });
-      }.bind(this));
+      });
 };
 
 /**
- * @param {!FileSystem} fileSystem
- * @return {!Promise.<!FileEntry>}
- * @private
+ * Returns a sync file entry for the named file, creating it as needed.
+ *
+ * @param {!Promise<string>} fileNamePromise
+ * @return {!Promise<!FileEntry>}
  */
-importer.ChromeSyncFileEntryProvider.prototype.getFileEntry_ =
-    function(fileSystem) {
-  return new Promise(
-      /**
-       * @param {function()} resolve
-       * @param {function()} reject
-       * @this {importer.ChromeSyncFileEntryProvider}
-       */
-      function(resolve, reject) {
-        fileSystem.root.getFile(
-            this.fileName_,
-            {
-              create: true,
-              exclusive: false
-            },
-            resolve,
-            reject);
-      }.bind(this));
+importer.ChromeSyncFilesystem.getOrCreateFileEntry = function(fileNamePromise) {
+  var promise = importer.ChromeSyncFilesystem.getFileSystem_()
+      .then(
+          /**
+           * @param {!FileSystem} fileSystem
+           * @return {!Promise<!FileEntry>}
+           */
+          function(fileSystem) {
+            fileNamePromise.then(
+                /** @param {string} fileName */
+                function(fileName) {
+                  return new Promise(
+                      function(resolve, reject) {
+                        fileSystem.root.getFile(
+                            fileName,
+                            {
+                              create: true,
+                              exclusive: false
+                            },
+                            resolve,
+                            reject);
+                      });
+
+                });
+          });
+
+  return /** @type {!Promise<!FileEntry>} */ (promise);
 };
 
 /**
- * Handles sync events. Checks to see if the event is for the file
- * we track, and sync-direction, and if so, notifies syncListeners.
- *
- * @see https://developer.chrome.com/apps/syncFileSystem
- *     #event-onFileStatusChanged
- *
- * @param {!Object} event Having a structure not unlike: {
- *     fileEntry: Entry,
- *     status: string,
- *     action: (string|undefined),
- *     direction: (string|undefined)}
- *
- * @private
- */
-importer.ChromeSyncFileEntryProvider.prototype.handleSyncEvent_ =
-    function(event) {
-  if (!this.fileEntryPromise_) {
-    return;
-  }
-
-  this.fileEntryPromise_.then(
-      /**
-       * @param {!FileEntry} fileEntry
-       * @this {importer.ChromeSyncFileEntryProvider}
-       */
-      function(fileEntry) {
-        if (event['fileEntry'].fullPath !== fileEntry.fullPath) {
-          return;
-        }
-
-        if (event.direction && event.direction !== 'remote_to_local') {
-          return;
-        }
-
-        if (event.action && event.action !== 'updated') {
-          console.warn(
-              'Unusual sync event action for sync file: ' + event.action);
-          return;
-        }
-
-        this.syncListeners_.forEach(
-            /**
-             * @param {function()} listener
-             * @this {importer.ChromeSyncFileEntryProvider}
-             */
-            function(listener) {
-              // Notify by way of a promise so that it is fully asynchronous
-              // (which can rationalize testing).
-              Promise.resolve().then(listener);
-            }.bind(this));
-      }.bind(this));
-};
-
-/**
  * A basic logging mechanism.
  *
  * @interface
  */
 importer.Logger = function() {};
 
 /**
  * Writes an error message to the logger followed by a new line.
  *
  * @param {string} message
@@ skipping 16 matching lines @@
 importer.Logger.prototype.catcher;
 
 /**
  * A {@code importer.Logger} that persists data in a {@code FileEntry}.
  *
  * @constructor
  * @implements {importer.Logger}
  * @struct
  * @final
  *
- * @param {!Promise.<!FileEntry>} fileEntryPromise
- * @param {!Promise.<!analytics.Tracker>} trackerPromise
+ * @param {!Promise<!FileEntry>} fileEntryPromise
+ * @param {!Promise<!analytics.Tracker>} trackerPromise
  */
 importer.RuntimeLogger = function(fileEntryPromise, trackerPromise) {
 
-  /** @private {!Promise.<!importer.PromisingFileEntry>} */
+  /** @private {!Promise<!importer.PromisingFileEntry>} */
   this.fileEntryPromise_ = fileEntryPromise.then(
       /** @param {!FileEntry} fileEntry */
       function(fileEntry) {
         return new importer.PromisingFileEntry(fileEntry);
       });
 
-  /** @private {!Promise.<!analytics.Tracker>} */
+  /** @private {!Promise<!analytics.Tracker>} */
   this.trackerPromise_ = trackerPromise;
 };
 
 /**
  * Reports an error to analytics.
  *
  * @param {string} context MUST NOT contain any dynamic error content,
  *    only statically defined string will dooooo.
  */
 importer.RuntimeLogger.prototype.reportErrorContext_ = function(context) {
@@ skipping 88 matching lines @@
 /** @private {importer.Logger} */
 importer.logger_ = null;
 
 /**
  * Creates a new logger instance...all ready to go.
  *
  * @return {!importer.Logger}
  */
 importer.getLogger = function() {
   if (!importer.logger_) {
+
     var nextLogId = importer.getNextDebugLogId_();
 
     /** @return {!Promise} */
     var rotator = function() {
       return importer.rotateLogs(
           nextLogId,
-          importer.ChromeSyncFileEntryProvider.getFileEntry);
+          importer.ChromeSyncFilesystem.getOrCreateFileEntry);
     };
 
     // This is a sligtly odd arrangement in service of two goals.
     //
     // 1) Make a logger available synchronously.
     // 2) Nuke old log files before reusing their names.
     //
     // In support of these goals we push the "rotator" between
     // the call to load the file entry and the method that
     // produces the name of the file to load. That method
     // (getDebugLogFilename) returns promise. We exploit this.
     importer.logger_ = new importer.RuntimeLogger(
-        importer.ChromeSyncFileEntryProvider.getFileEntry(
-            /** @type {!Promise.<string>} */ (rotator().then(
+        importer.ChromeSyncFilesystem.getOrCreateFileEntry(
+            /** @type {!Promise<string>} */ (rotator().then(
                 importer.getDebugLogFilename.bind(null, nextLogId)))),
         importer.getTracker_());
   }
 
   return importer.logger_;
 };
 
 /**
  * Fetch analytics.Tracker from background page.
- * @return {!Promise.<!analytics.Tracker>}
+ * @return {!Promise<!analytics.Tracker>}
  * @private
  */
 importer.getTracker_ = function() {
   return new Promise(
       function(resolve, reject) {
         chrome.runtime.getBackgroundPage(
           /** @param {Window=} opt_background */
           function(opt_background) {
             if (chrome.runtime.lastError) {
               reject(chrome.runtime.lastError);
@@ skipping 90 matching lines @@
               } else {
                 resolve(undefined);
               }
             });
       });
 };
 
 /**
  * @param {string} key
  * @param {T=} opt_default
- * @return {!Promise.<T>} Resolves with the value, or {@code opt_default} when
+ * @return {!Promise<T>} Resolves with the value, or {@code opt_default} when
  *     no value entry existis, or {@code undefined}.
  * @template T
  */
 importer.ChromeLocalStorage.prototype.get = function(key, opt_default) {
   return new Promise(
       function(resolve, reject) {
         chrome.storage.local.get(
             key,
             /** @param {Object.<string, ?>} values */
             function(values) {
               if (chrome.runtime.lastError) {
                 reject(chrome.runtime.lastError);
               } else if (key in values) {
                 resolve(values[key]);
               } else {
                 resolve(opt_default);
               }
             });
       });
 };
 
 /** @private @const {!importer.ChromeLocalStorage} */
 importer.ChromeLocalStorage.INSTANCE_ = new importer.ChromeLocalStorage();
 
 /** @return {!importer.ChromeLocalStorage} */
 importer.ChromeLocalStorage.getInstance = function() {
   return importer.ChromeLocalStorage.INSTANCE_;
 };