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 IMAGE_EDITOR_ENABLED = false;
 
+// If directory files changes too often, don't rescan directory more than once
+// per specified interva;

[rginda, 2011/08/31 00:32:58]

typo: s/;/l./

[Dmitry Zvorygin, 2011/09/12 11:12:23]

Done.

+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.rescanPending_ = [];

[rginda, 2011/08/31 00:32:58]

rescanPending_ and rescanRunning_ are *very* similar names, but one is a list
and one is a boolean.  I suggest a single 'pendingRescanQueue_' array, and test
its length to see if there is a rescan in progress?  Also a comment to the
effect of "// Queue of pending rescanDirectory_() calls."

[Dmitry Zvorygin, 2011/09/12 11:12:23]

We need both array and flag because we empty array on rescan start.

On 2011/08/31 00:32:58, rginda wrote:

+  this.rescanRunning_ = false;
 
   this.commands_ = {};
 
   this.document_ = dialogDom.ownerDocument;
   this.dialogType_ = this.params_.type || FileManager.DialogType.FULL_PAGE;
 
   this.alert = new cr.ui.dialogs.AlertDialog(this.dialogDom_);
   this.confirm = new cr.ui.dialogs.ConfirmDialog(this.dialogDom_);
   this.prompt = new cr.ui.dialogs.PromptDialog(this.dialogDom_);
 
@@ skipping 36 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 active mount points to distinct them from other directories.
   chrome.fileBrowserPrivate.getMountPoints(function(mountPoints) {
       self.mountPoints_ = mountPoints;
   });
 
   chrome.fileBrowserHandler.onExecute.addListener(
     this.onFileTaskExecute_.bind(this));
 
@@ skipping 2206 matching lines @@
 
     this.updateCommands_();
     this.updateOkButton_();
 
     // 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');
+            }
+          });
+    }
+
+    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);
         // For tests that open the dialog to empty directories, everything
         // is loaded at this point.
         chrome.test.sendMessage('directory-change-complete');
       });
   };
 
   /**
    * Update the UI when a disk is mounted or unmounted.
    *
    * @param {string} path The path that has been mounted or unmounted.
    */
   FileManager.prototype.onDiskChanged_ = function(event) {
     if (event.eventType == 'added') {
       this.changeDirectory(event.volumeInfo.mountPath);
     } else if (event.eventType == 'removed') {
       if (this.currentDirEntry_ &&
           isParentPath(event.volumeInfo.mountPath,
                        this.currentDirEntry_.fullPath)) {
         this.changeDirectory(getParentPath(event.volumeInfo.mountPath));
       }
     }
   };
 
   /**
    * Rescan the current directory, refreshing the list.
    *

[rginda, 2011/08/31 00:32:58]

Please add some description of the new queuing nature of rescanDirectory_.

[Dmitry Zvorygin, 2011/09/12 11:12:23]

Done.

    * @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.rescanDirectory_ = function(opt_callback) {
-    var self = this;
-    var reader;
-
-    function onReadSome(entries) {
-      if (entries.length == 0) {
-        if (opt_callback)
-          opt_callback();
-        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

[rginda, 2011/08/31 00:32:58]

rescanDirectory_ is getting pretty large, can this condition be moved into its
own function?

[Dmitry Zvorygin, 2011/09/12 11:12:23]

I think it's little useless because that function would be used only once from
rescanDirectory_ only. Later maybe I'll rewrite this a little.

+      this.rescanPending_.push({onSuccess:opt_callback, onError:opt_onError});
+
+      if (this.rescanRunning_) {

[rginda, 2011/08/31 00:32:58]

No braces necessary here.

[Dmitry Zvorygin, 2011/09/12 11:12:23]

Done.

+        return;
+      }
+
+      this.rescanRunning_ = true;
+
+      // Save list of items to notify locally in case we'll receive new requests

[rginda, 2011/08/31 00:32:58]

I don't think this comment is enough to describe what's going on here.  How
about something like...

// 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.

[Dmitry Zvorygin, 2011/09/12 11:12:23]

Done.

+      // to refresh while refreshing
+      var callbacks = this.rescanPending_;
+
+      this.rescanPending_ = [];
+
+      var self = this;
+      var reader;
+
+      function onError() {
+
+        for (var i= 0; i < callbacks.length; i++) {
+          if (callbacks[i].onError) {

[rginda, 2011/08/31 00:32:58]

No braces.

[Dmitry Zvorygin, 2011/09/12 11:12:23]

Done.

+            callbacks[i].onError();

[rginda, 2011/08/31 00:32:58]

If any of these callbacks throw, rescanRunning will be left true forever.

[Dmitry Zvorygin, 2011/09/12 11:12:23]

Done.

+          }
+        }
+
+        if (self.rescanPending_.length > 0) {
+          setTimeout(self.rescanDirectory_.bind(self),
+              SIMULTANEOUS_RESCAN_INTERVAL);
+        }
+
+        self.rescanRunning_ = false;
+      }
+
+      function onReadSome(entries) {
+        if (entries.length == 0) {
+
+          for (var i= 0; i < callbacks.length; i++) {
+            if (callbacks[i].onSuccess) {
+              callbacks[i].onSuccess();

[rginda, 2011/08/31 00:32:58]

Same issue with failed callbacks here.  Also, unnecessary braces.

[Dmitry Zvorygin, 2011/09/12 11:12:23]

Done.

+            }
+          }
+
+          if (self.rescanPending_.length > 0) {
+            setTimeout(self.rescanDirectory_.bind(self),
+                SIMULTANEOUS_RESCAN_INTERVAL);
+          }
+
+          self.rescanRunning_ = false;
+          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);
 
@@ skipping 40 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) {
+    // It might be massive change, so let's note somehow, that we need

[rginda, 2011/08/31 00:32:58]

How about just moving this code into a 'rescanDirectoryLater_' function, located
close to 'rescanDirectory_'?

+    // rescanning and then wait some time
+
+    if (this.rescanPending_.length == 0) {
+      this.rescanPending_.push({onSuccess:undefined, onError:undefined});
+
+      // 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);
+      }
+    }
+  };
+
   /**
    * 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 499 matching lines @@
 
     if (msg) {
       console.log('no no no');
       this.alert.show(msg, onAccept);
       return false;
     }
 
     return true;
   };
 })();