Added refresh on filesystem change

chrome/browser/resources/file_manager/js/file_manager.js

 // Copyright (c) 2011 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.
 
 // Setting the src of an img to an empty string can crash the browser, so we
 // use an empty 1x1 gif instead.
 const EMPTY_IMAGE_URI = 'data:image/gif;base64,'
         + 'R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw%3D%3D';
 
 var g_slideshow_data = null;
 
+const GALLERY_ENABLED = true;
+
+// If directory files changes too often, don't rescan directory more than once
+// per specified interval
+const SIMULTANEOUS_RESCAN_INTERVAL = 1000;
+
 /**
  * FileManager constructor.
  *
  * FileManager objects encapsulate the functionality of the file selector
  * dialogs, as well as the full screen file manager application (though the
  * latter is not yet implemented).
  *
  * @param {HTMLElement} dialogDom The DOM node containing the prototypical
  *     dialog UI.
  * @param {DOMFileSystem} filesystem The HTML5 filesystem object representing
@@ skipping 21 matching lines @@
 
   this.selection = null;
 
   this.clipboard_ = null;  // Current clipboard, or null if empty.
 
   this.butterTimer_ = null;
   this.currentButter_ = null;
 
   // True if we should filter out files that start with a dot.
   this.filterFiles_ = true;
+  this.subscribedOnDirectoryChanges_ = false;
+  this.pendingRescanQueue_ = [];
+  this.rescanRunning_ = false;
 
   this.commands_ = {};
 
   this.document_ = dialogDom.ownerDocument;
   this.dialogType_ = this.params_.type || FileManager.DialogType.FULL_PAGE;
 
   metrics.recordEnum('Create', this.dialogType_,
       [FileManager.DialogType.SELECT_FOLDER,
       FileManager.DialogType.SELECT_SAVEAS_FILE,
       FileManager.DialogType.SELECT_OPEN_FILE,
@@ skipping 41 matching lines @@
        this.dialogType_ == FileManager.DialogType.SELECT_OPEN_MULTI_FILE);
 
   // DirectoryEntry representing the current directory of the dialog.
   this.currentDirEntry_ = null;
 
   this.copyManager_ = new FileCopyManager();
   this.copyManager_.addEventListener('copy-progress',
                                      this.onCopyProgress_.bind(this));
 
   window.addEventListener('popstate', this.onPopState_.bind(this));
+  window.addEventListener('unload', this.onUnload_.bind(this));
+
   this.addEventListener('directory-changed',
                         this.onDirectoryChanged_.bind(this));
   this.addEventListener('selection-summarized',
                         this.onSelectionSummarized_.bind(this));
 
   // The list of archives requested to mount. We will show contents once
   // archive is mounted, but only for mounts from within this filebrowser tab.
   this.mountRequests_ = [];
   chrome.fileBrowserPrivate.onMountCompleted.addListener(
       this.onMountCompleted_.bind(this));
 
+  chrome.fileBrowserPrivate.onFileChanged.addListener(
+    this.onFileChanged_.bind(this));
+
   var self = this;
 
   // The list of callbacks to be invoked during the directory rescan after
   // all paste tasks are complete.
   this.pasteSuccessCallbacks_ = [];
 
   // The list of active mount points to distinct them from other directories.
   chrome.fileBrowserPrivate.getMountPoints(function(mountPoints) {
       self.mountPoints_ = mountPoints;
   });
@@ skipping 2711 matching lines @@
     this.updateOkButton_();
 
     this.checkFreeSpace_(this.currentDirEntry_.fullPath);
 
     // New folder should never be enabled in the root or media/ directories.
     this.newFolderButton_.disabled = isSystemDirEntry(this.currentDirEntry_);
 
     this.document_.title = this.currentDirEntry_.fullPath;
 
     var self = this;
+
+    if (this.subscribedOnDirectoryChanges_) {
+      chrome.fileBrowserPrivate.removeFileWatch(event.previousDirEntry.toURL(),
+          function(result) {
+            if (!result) {
+              console.log('Failed to remove file watch');
+            }
+          });
+    }
+
+    if (event.newDirEntry.fullPath != '/') {
+      this.subscribedOnDirectoryChanges_ = true;
+      chrome.fileBrowserPrivate.addFileWatch(event.newDirEntry.toURL(),
+        function(result) {
+          if (!result) {
+            console.log('Failed to add file watch');
+          }
+      });
+    }
+
     this.rescanDirectory_(function() {
         if (event.selectedEntry)
           self.selectEntry(event.selectedEntry);
         if (event.opt_callback) {
           try {
             event.opt_callback();
           } catch (ex) {
             console.error('Caught exception while inovking callback: ', ex);
           }
         }
         // For tests that open the dialog to empty directories, everything
         // is loaded at this point.
         chrome.test.sendMessage('directory-change-complete');
         // PyAuto tests monitor this state by polling this variable
         self.directoryChanged_ = true;
       });
   };
 
   /**
+   * Rescans directory later.
+   * This method should be used if we just want rescan but not actually now.
+   * This helps us not to flood queue with rescan requests.
+   *
+   * @param opt_callback
+   * @param opt_onError
+   */
+   FileManager.prototype.rescanDirectoryLater_ = function(opt_callback,
+                                                          opt_onError) {
+    // It might be massive change, so let's note somehow, that we need
+    // rescanning and then wait some time
+
+    if (this.pendingRescanQueue_.length == 0) {
+      this.pendingRescanQueue_.push({onSuccess:opt_callback,
+                                     onError:opt_onError});
+
+      // If rescan isn't going to run without
+      // our interruption, then say that we need to run it
+      if (!this.rescanRunning_) {
+        setTimeout(this.rescanDirectory_.bind(this),
+            SIMULTANEOUS_RESCAN_INTERVAL);
+      }
+    }
+   }
+
+
+  /**
    * Rescans the current directory, refreshing the list. It decreases the
    * probability that two such calls are pending simultaneously.
    *
-   * @param {function()} opt_callback Optional function to invoke when the
-   *     rescan is complete.
-   * @param {string} delayMS Delay during which next rescanDirectory calls
-   *     can happen.
-   */
-
-  FileManager.prototype.rescanDirectory_ = function(opt_callback, delayMS) {
-    var self = this;
-    function done(count) {
-      // Variable count is introduced because we only want to do callbacks, that
-      // were in the queue at the moment of rescanDirectoryNow invocation.
-      while (count--) {
-        var callback = self.rescanDirectory_.callbacks.shift();
-        callback();
-      }
-    }
-
-    // callbacks is a queue of callbacks that need to be called after rescaning
-    // directory is done. We push callback to the end and pop form the front.
-    // When we get to actually call rescanDirectoryNow_ we need to remember how
-    // many callbacks were in a queue at the time, not to call callbacks that
-    // arrived in the middle of execution (they may depend on rescaning being
-    // done after they called rescanDirectory_).
-    if (!this.rescanDirectory_.callbacks)
-      this.rescanDirectory_.callbacks = [];
-
-    if (opt_callback)
-      this.rescanDirectory_.callbacks.push(opt_callback);
-
-    delayMS = delayMS || 100;
-
-    // Assumes rescanDirectoryNow_ takes less than 100 ms. If not there is
-    // a possible overlap between two calls.
-    if (delayMS < 100)
-      delayMS = 100;
-
-    if (this.rescanDirectory_.handle)
-      clearTimeout(this.rescanDirectory_.handle);
-    var currentQueueLength = self.rescanDirectory_.callbacks.length;
-    this.rescanDirectory_.handle = setTimeout(function () {
-        self.rescanDirectoryNow_(function() {
-            done(currentQueueLength);
-          });
-      }, delayMS);
-  };
-
-  /**
-   * Rescans the current directory immediately, refreshing the list. Should NOT
-   * be used in most cases. Instead use rescanDirectory_.
+   * This method tries to queue request if rescan is already running, and
+   * processes this request later. Anyway callback would be called after
+   * processing.
+   *
+   * If no rescan is running, then method starts rescanning immediately.
    *
    * @param {function()} opt_callback Optional function to invoke when the
    *     rescan is complete.
+   *
+   * @param {function()} opt_onError Optional function to invoke when the
+   *     rescan fails.
    */
-  FileManager.prototype.rescanDirectoryNow_ = function(opt_callback) {
-    var self = this;
-    var reader;
-
-    function rescanDone() {
-      metrics.recordTime('ScanDirectory');
-      if (self.currentDirEntry_.fullPath == DOWNLOADS_DIRECTORY)
-        metrics.reportCount("DownloadsCount", self.dataModel_.length);
-      if (opt_callback)
-        opt_callback();
-    }
-
-    metrics.startInterval('ScanDirectory');
-
-    function onReadSome(entries) {
-      if (entries.length == 0) {
-        rescanDone();
-        return;
-      }
-
-      // Splice takes the to-be-spliced-in array as individual parameters,
-      // rather than as an array, so we need to perform some acrobatics...
-      var spliceArgs = [].slice.call(entries);
-
-      // Hide files that start with a dot ('.').
-      // TODO(rginda): User should be able to override this.  Support for other
-      // commonly hidden patterns might be nice too.
-      if (self.filterFiles_) {
-        spliceArgs = spliceArgs.filter(function(e) {
-          return e.name.substr(0, 1) != '.';
-        });
-      }
-
-      spliceArgs.unshift(0, 0);  // index, deleteCount
-      self.dataModel_.splice.apply(self.dataModel_, spliceArgs);
-
-      // Keep reading until entries.length is 0.
-      reader.readEntries(onReadSome);
-    };
-
+  FileManager.prototype.rescanDirectory_ = function(opt_callback, opt_onError) {
     // Updated when a user clicks on the label of a file, used to detect
     // when a click is eligible to trigger a rename.  Can be null, or
     // an object with 'path' and 'date' properties.
     this.lastLabelClick_ = null;
 
     // Clear the table first.
     this.dataModel_.splice(0, this.dataModel_.length);
     this.currentList_.selectionModel.clear();
 
     this.updateBreadcrumbs_();
 
     if (this.currentDirEntry_.fullPath != '/') {
+      // Add current request to pending result list
+      this.pendingRescanQueue_.push({
+            onSuccess:opt_callback,
+            onError:opt_onError
+          });
+
+      if (this.rescanRunning_)
+        return;
+
+      this.rescanRunning_ = true;
+
+      // The current list of callbacks is saved and reset.  Subsequent
+      // calls to rescanDirectory_ while we're still pending will be
+      // saved and will cause an additional rescan to happen after a delay.
+      var callbacks = this.pendingRescanQueue_;
+
+      this.pendingRescanQueue_ = [];
+
+      var self = this;
+      var reader;
+
+      function onError() {
+        if (self.pendingRescanQueue_.length > 0) {
+          setTimeout(self.rescanDirectory_.bind(self),
+              SIMULTANEOUS_RESCAN_INTERVAL);
+        }
+
+        self.rescanRunning_ = false;
+
+        for (var i= 0; i < callbacks.length; i++) {
+          if (callbacks[i].onError)
+            try {
+              callbacks[i].onError();
+            } catch (ex) {
+              console.error('Caught exception while notifying about error: ' +
+                          name, ex);
+            }
+        }
+      }
+
+      function onReadSome(entries) {
+        if (entries.length == 0) {
+          if (self.pendingRescanQueue_.length > 0) {
+            setTimeout(self.rescanDirectory_.bind(self),
+                SIMULTANEOUS_RESCAN_INTERVAL);
+          }
+
+          self.rescanRunning_ = false;
+          for (var i= 0; i < callbacks.length; i++) {
+            if (callbacks[i].onSuccess)
+              try {
+                callbacks[i].onSuccess();
+              } catch (ex) {
+                console.error('Caught exception while notifying about error: ' +
+                            name, ex);
+              }
+          }
+
+          return;
+        }
+
+        // Splice takes the to-be-spliced-in array as individual parameters,
+        // rather than as an array, so we need to perform some acrobatics...
+        var spliceArgs = [].slice.call(entries);
+
+        // Hide files that start with a dot ('.').
+        // TODO(rginda): User should be able to override this. Support for other
+        // commonly hidden patterns might be nice too.
+        if (self.filterFiles_) {
+          spliceArgs = spliceArgs.filter(function(e) {
+              return e.name.substr(0, 1) != '.';
+            });
+        }
+
+        spliceArgs.unshift(0, 0);  // index, deleteCount
+        self.dataModel_.splice.apply(self.dataModel_, spliceArgs);
+
+        // Keep reading until entries.length is 0.
+        reader.readEntries(onReadSome, onError);
+      };
+
       // If not the root directory, just read the contents.
       reader = this.currentDirEntry_.createReader();
-      reader.readEntries(onReadSome);
+      reader.readEntries(onReadSome, onError);
       return;
     }
 
     // Otherwise, use the provided list of root subdirectories, since the
     // real local filesystem root directory (the one we use outside the
     // harness) can't be enumerated yet.
     var spliceArgs = [].slice.call(this.rootEntries_);
     spliceArgs.unshift(0, 0);  // index, deleteCount
-    self.dataModel_.splice.apply(self.dataModel_, spliceArgs);
+    this.dataModel_.splice.apply(this.dataModel_, spliceArgs);
 
     rescanDone();
   };
 
   FileManager.prototype.findListItem_ = function(event) {
     var node = event.srcElement;
     while (node) {
       if (node.tagName == 'LI')
         break;
       node = node.parentNode;
@@ skipping 30 matching lines @@
     if (event.button != 1)
       return;
 
     var li = this.findListItem_(event);
     if (!li) {
       console.log('li not found', event);
       return;
     }
   };
 
+  FileManager.prototype.onUnload_ = function(event) {
+    if (this.subscribedOnDirectoryChanges_) {
+      chrome.fileBrowserPrivate.removeFileWatch(event.previousDirEntry.toURL(),
+          function(result) {
+            if (!result) {
+              console.log('Failed to remove file watch');
+            }
+          });
+    }
+  };
+
+  FileManager.prototype.onFileChanged_ = function(event) {
+    // We receive a lot of events even in folders we are not interested in.
+    if (event.fileUrl == this.currentDirEntry_.toURL())
+      this.rescanDirectoryLater_();
+  };
+
   /**
    * Determine whether or not a click should initiate a rename.
    *
    * Renames can happen on mouse click if the user clicks on a label twice,
    * at least a half second apart.
    */
   FileManager.prototype.allowRenameClick_ = function(event, row) {
     if (this.dialogType_ != FileManager.DialogType.FULL_PAGE ||
         this.currentDirEntry_.name == '' ||
         isSystemDirEntry(this.currentDirEntry_)) {
@@ skipping 587 matching lines @@
           });
       }, onError);
 
       function onError(err) {
         console.log('Error while checking free space: ' + err);
         setTimeout(doCheck, 1000 * 60);
       }
     }
   }
 })();