Shrink space required by history log file

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 349 matching lines @@
 };
 
 /**
  * @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}
+ */
+importer.APP_URL_PREFIX_ =
+    'filesystem:chrome-extension://hhaomjibdihmijegdhdafkllkbggdgoj/external';
+
+/**
+ * Strips non-unique information from the URL. The resulting
+ * value can be reconstituted using {@code importer.inflateAppUrl}.
+ *
+ * @param {string} url
+ * @return {string}
+ */
+importer.deflateAppUrl = function(url) {
+  if (url.substring(0, importer.APP_URL_PREFIX_.length) ===
+      importer.APP_URL_PREFIX_) {
+    return '$' + url.substring(importer.APP_URL_PREFIX_.length);
+  }
+
+  return url;
+};
+
+/**
+ * Reconstitutes a url previous deflated by {@code deflateAppUrl}.
+ * Returns the original string if it can't be inflated.
+ *
+ * @param {string} deflated
+ * @return {string}
+ */
+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
  *     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>}
                  * @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 {
-                    resolve(metadata.modificationTime + '_' + metadata.size);
+                    var secondsSinceEpoch =
+                        importer.toSecondsFromEpoch(metadata.modificationTime);
+                    resolve(secondsSinceEpoch + '_' + metadata.size);
                   }
                 }.bind(this));
-      }.bind(this));
+      }.bind(this))
+      .catch(importer.getLogger().catcher('importer-common-create-hashcode'));
 };
 
 /**
+ * @param {string} date A date string in the form
+ *     expected by Date.parse.
+ * @return {string} The number of seconds from epoch to the date...as a string.
+ */
+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
  */
 importer.SyncFileEntryProvider = function() {};
 
 /**
- * Adds a listener to be notified when the the FileEntry owned/managed
- * by this class is updated via sync.
- *
- * @param {function()} syncListener
- */
-importer.SyncFileEntryProvider.prototype.addSyncListener;
-
-/**
  * 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;
-
-  this.monitorSyncEvents_();
 };
 
 /**
  * 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();
       });
 };
 
-/**
- * Wraps chrome.syncFileSystem.onFileStatusChanged
- * so that we can report to our listeners when our file has changed.
- * @private
- */
-importer.ChromeSyncFileEntryProvider.prototype.monitorSyncEvents_ =
-    function() {
-  chrome.syncFileSystem.onFileStatusChanged.addListener(
-      this.handleSyncEvent_.bind(this));
-};
-
-/** @override */
-importer.ChromeSyncFileEntryProvider.prototype.addSyncListener =
-    function(listener) {
-  if (this.syncListeners_.indexOf(listener) === -1) {
-    this.syncListeners_.push(listener);
-  }
-};
-
 /** @override */
 importer.ChromeSyncFileEntryProvider.prototype.getSyncFileEntry = function() {
   if (this.fileEntryPromise_) {
     return /** @type {!Promise.<!FileEntry>} */ (this.fileEntryPromise_);
   };
 
   this.fileEntryPromise_ = this.getFileSystem_()
       .then(
           /**
            * @param {!FileSystem} fileSystem
@@ skipping 90 matching lines @@
       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.error(
-              'Unexpected sync event action for sync file: ' + event.action);
+          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
@@ skipping 324 matching lines @@
       });
 };
 
 /** @private @const {!importer.ChromeLocalStorage} */
 importer.ChromeLocalStorage.INSTANCE_ = new importer.ChromeLocalStorage();
 
 /** @return {!importer.ChromeLocalStorage} */
 importer.ChromeLocalStorage.getInstance = function() {
   return importer.ChromeLocalStorage.INSTANCE_;
 };