Refactoring file manager: moving volume mounting related code to a separate class.

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

 // Copyright (c) 2012 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.
 
 // If directory files changes too often, don't rescan directory more than once
 // per specified interval
 var SIMULTANEOUS_RESCAN_INTERVAL = 1000;
 // Used for operations that require almost instant rescan.
 var SHORT_RESCAN_INTERVAL = 100;
 
 /**
  * Data model of the file manager.
  *
  * @constructor
  * @param {DirectoryEntry} root File system root.
  * @param {boolean} singleSelection True if only one file could be selected
  *                                  at the time.
  * @param {MetadataCache} metadataCache The metadata cache service.
+ * @param {VolumeManager} volumeManager The volume manager.
+ * @param {boolean} isGDataEnabled True if GDATA enabled (initial value).
  */
-function DirectoryModel(root, singleSelection, metadataCache) {
+function DirectoryModel(root, singleSelection,
+                        metadataCache, volumeManager, isGDataEnabled) {
   this.root_ = root;
   this.metadataCache_ = metadataCache;
   this.fileList_ = new cr.ui.ArrayDataModel([]);
   this.fileListSelection_ = singleSelection ?
       new cr.ui.ListSingleSelectionModel() : new cr.ui.ListSelectionModel();
 
   this.runningScan_ = null;
   this.pendingScan_ = null;
   this.rescanTimeout_ = undefined;
   this.scanFailures_ = 0;
+  this.gDataEnabled_ = isGDataEnabled;
 
   // DirectoryEntry representing the current directory of the dialog.
   this.currentDirEntry_ = root;
 
   this.fileList_.prepareSort = this.prepareSort_.bind(this);
 
   this.rootsList_ = new cr.ui.ArrayDataModel([]);
   this.rootsListSelection_ = new cr.ui.ListSingleSelectionModel();
   this.rootsListSelection_.addEventListener(
       'change', this.onRootChange_.bind(this));
 
   /**
    * A map root.fullPath -> currentDirectory.fullPath.
    * @private
    * @type {Object.<string, string>}
    */
   this.currentDirByRoot_ = {};
 
   // The map 'name' -> callback. Callbacks are function(entry) -> boolean.
   this.filters_ = {};
   this.setFilterHidden(true);
 
-  /**
-   * @private
-   * @type {Object.<string, boolean>}
-   */
-  this.volumeReadOnlyStatus_ = {};
+  this.volumeManager_ = volumeManager;
 
   /**
    * Directory in which search results are displayed. Not null iff search
    * results are being displayed.
    * @private
    * @type {Entry}
    */
   this.searchDirEntry_ = null;
 
   /**
@@ skipping 31 matching lines @@
 * The name of the downloads directory.
 */
 DirectoryModel.DOWNLOADS_DIRECTORY = 'Downloads';
 
 /**
 * The name of the gdata provider directory.
 */
 DirectoryModel.GDATA_DIRECTORY = 'drive';
 
 /**
- * GData access mode: disabled (no GData root displayed in the list).
+ * Fake entry to be used in currentDirEntry_ when current directory is
+ * unmounted GDATA.
+ * @private
  */
-DirectoryModel.GDATA_ACCESS_DISABLED = 0;
-
-/**
- * GData access mode: lazy (GData root displayed, no content is fetched yet).
- */
-DirectoryModel.GDATA_ACCESS_LAZY = 1;
-
-/**
- * GData access mode: full (GData root displayed, content is available).
- */
-DirectoryModel.GDATA_ACCESS_FULL = 2;
+DirectoryModel.fakeGDataEntry_ = {
+  fullPath: '/' + DirectoryModel.GDATA_DIRECTORY
+};
 
 /**
  * Root path used for displaying gdata content search results.
  * Search results will be shown in directory 'GDATA_SEARCH_ROOT_PATH/query'.
  *
  * @const
  * @type {string}
  */
 DirectoryModel.GDATA_SEARCH_ROOT_PATH = '/drive/.search';
 
 /**
  * @const
  * @type {Array.<string>}
  */
 DirectoryModel.GDATA_SEARCH_ROOT_COMPONENTS = ['', 'drive', '.search'];
 
 /**
  * DirectoryModel extends cr.EventTarget.
  */
 DirectoryModel.prototype.__proto__ = cr.EventTarget.prototype;
 
 /**
+ * Fills the root list and starts tracking changes.
+ */
+DirectoryModel.prototype.start = function() {
+  var volumesChangeHandler = this.onMountChanged_.bind(this);
+  this.volumeManager_.addEventListener('change', volumesChangeHandler);
+  this.updateRoots_();
+};
+
+/**
  * @return {cr.ui.ArrayDataModel} Files in the current directory.
  */
 DirectoryModel.prototype.getFileList = function() {
   return this.fileList_;
 };
 
 /**
  * @return {MetadataCache} Metadata cache.
  */
 DirectoryModel.prototype.getMetadataCache = function() {
   return this.metadataCache_;
 };
 
 /**
+ * Sets whether GDATA appears in the roots list and
+ * if it could be used as current directory.
+ * @param {boolead} enabled True if GDATA enabled.
+ */
+DirectoryModel.prototype.setGDataEnabled = function(enabled) {
+  if (this.gDataEnabled_ == enabled)
+    return;
+  this.gDataEnabled_ = enabled;
+  this.updateRoots_();
+  if (!enabled && this.getCurrentRootType() == DirectoryModel.RootType.GDATA)
+    this.changeDirectory(this.getDefaultDirectory());
+};
+
+/**
  * Sort the file list.
  * @param {string} sortField Sort field.
  * @param {string} sortDirection "asc" or "desc".
  */
 DirectoryModel.prototype.sortFileList = function(sortField, sortDirection) {
   this.fileList_.sort(sortField, sortDirection);
 };
 
 /**
  * @return {cr.ui.ListSelectionModel|cr.ui.ListSingleSelectionModel} Selection
@@ skipping 52 matching lines @@
   return this.getSearchOrCurrentDirEntry() != this.getCurrentDirEntry();
 };
 
 /**
  * @param {strin} path Path to check.
  * @return {boolean} True if the |path| is read only.
  */
 DirectoryModel.prototype.isPathReadOnly = function(path) {
   switch (DirectoryModel.getRootType(path)) {
     case DirectoryModel.RootType.REMOVABLE:
-      return !!this.volumeReadOnlyStatus_[DirectoryModel.getRootPath(path)];
+      return !!this.volumeManager_.isReadOnly(DirectoryModel.getRootPath(path));
     case DirectoryModel.RootType.ARCHIVE:
       return true;
     case DirectoryModel.RootType.DOWNLOADS:
       return false;
     case DirectoryModel.RootType.GDATA:
       return this.isOffline();
     default:
       return true;
   }
 };
@@ skipping 121 matching lines @@
 
 /**
  * @return {string} Root path for the current directory (parent directory is
  *     not navigatable for the user).
  */
 DirectoryModel.prototype.getCurrentRootPath = function() {
   return DirectoryModel.getRootPath(this.currentDirEntry_.fullPath);
 };
 
 /**
+ * @return {DirectoryModel.RootType} A root type.
+ */
+DirectoryModel.prototype.getCurrentRootType = function() {
+  return DirectoryModel.getRootType(this.currentDirEntry_.fullPath);
+};
+
+/**
  * @return {cr.ui.ListSingleSelectionModel} Root list selection model.
  */
 DirectoryModel.prototype.getRootsListSelectionModel = function() {
   return this.rootsListSelection_;
 };
 
 /**
  * Add a filter for directory contents.
  * @param {string} name An identifier of the filter (used when removing it).
  * @param {function(Entry):boolean} filter Hide file if false.
@@ skipping 155 matching lines @@
   }
 
   var onDone = function() {
     cr.dispatchSimpleEvent(this, 'scan-completed');
     callback();
   }.bind(this);
 
   // Clear the table first.
   this.fileList_.splice(0, this.fileList_.length);
   cr.dispatchSimpleEvent(this, 'scan-started');
-  if (this.currentDirEntry_ == this.unmountedGDataEntry_) {
-    onDone();
-    return;
-  }
   this.runningScan_ = this.createScanner_(this.fileList_, onDone);
   this.runningScan_.run();
 };
 
 /**
  * @private
  * @param {Array.<Entry>} entries Files.
  * @param {function} callback Callback on done.
  */
 DirectoryModel.prototype.prefetchCacheForSorting_ = function(entries,
@@ skipping 231 matching lines @@
 };
 
 /**
  * Resolves absolute directory path. Handles GData stub.
  * @param {string} path Path to the directory.
  * @param {function(DirectoryEntry} successCallback Success callback.
  * @param {function(FileError} errorCallback Error callback.
  */
 DirectoryModel.prototype.resolveDirectory = function(path, successCallback,
                                                      errorCallback) {
-  if (this.unmountedGDataEntry_ &&
-      DirectoryModel.getRootType(path) == DirectoryModel.RootType.GDATA) {
-    // TODO(kaznacheeev): Currently if path points to some GData subdirectory
-    // and GData is not mounted we will change to the fake GData root and
-    // ignore the rest of the path. Consider remembering the path and
-    // changing to it once GDdata is mounted. This is only relevant for cases
-    // when we open the File Manager with an URL pointing to GData (e.g. via
-    // a bookmark).
-    successCallback(this.unmountedGDataEntry_);
-    return;
+  if (DirectoryModel.getRootType(path) == DirectoryModel.RootType.GDATA) {
+    if (!this.isGDataMounted_()) {
+      if (path == DirectoryModel.fakeGDataEntry_.fullPath)
+        successCallback(DirectoryModel.fakeGDataEntry_);
+      else  // Subdirectory.
+        errorCallback({ code: FileError.NOT_FOUND_ERR });
+      return;
+    }
   }
 
   if (path == '/') {
     successCallback(this.root_);
     return;
   }
 
   this.root_.getDirectory(path, {create: false},
                           successCallback, errorCallback);
 };
@@ skipping 37 matching lines @@
  * changed.
  *
  * @private
  * @param {boolean} initial True if it comes from setupPath and
  *                          false if caused by an user action.
  * @param {DirectoryEntry} dirEntry The absolute path to the new directory.
  * @param {function} opt_callback Executed if the directory loads successfully.
  */
 DirectoryModel.prototype.changeDirectoryEntry_ = function(initial, dirEntry,
                                                           opt_callback) {
+  if (dirEntry == DirectoryModel.fakeGDataEntry_)
+    this.volumeManager_.mountGData(function() {}, function() {});
+
   this.clearSearch_();
   var previous = this.currentDirEntry_;
   this.currentDirEntry_ = dirEntry;
   function onRescanComplete() {
     if (opt_callback)
       opt_callback();
     // For tests that open the dialog to empty directories, everything
     // is loaded at this point.
     chrome.test.sendMessage('directory-change-complete');
   }
   this.updateRootsListSelection_();
   this.scan_(onRescanComplete);
   this.currentDirByRoot_[this.getCurrentRootPath()] = dirEntry.fullPath;
 
   var e = new cr.Event('directory-changed');
   e.previousDirEntry = previous;
   e.newDirEntry = dirEntry;
   e.initial = initial;
   this.dispatchEvent(e);
 };
 
 /**
+ * Creates an object wich could say wether directory has changed while it has
+ * been active or not. Designed for long operations that should be canncelled
+ * if the used change current directory.
+ * @return {Object} Created object.
+ */
+DirectoryModel.prototype.createDirectoryChangeTracker = function() {
+  var tracker = {
+    dm_: this,
+    active_: false,
+    hasChanged: false,
+    exceptInitialChange: false,
+
+    start: function() {
+      if (!this.active_) {
+        this.dm_.addEventListener('directory-changed',
+                                  this.onDirectoryChange_);
+        this.active_ = true;
+        this.hasChanged = false;
+      }
+    },
+
+    stop: function() {
+      if (this.active_) {
+        this.dm_.removeEventListener('directory-changed',
+                                     this.onDirectoryChange_);
+        active_ = false;
+      }
+    },
+
+    onDirectoryChange_: function(event) {
+      // this == tracker.dm_ here.
+      if (tracker.exceptInitialChange && event.initial)
+        return;
+      tracker.stop();
+      tracker.hasChanged = true;
+    }
+  };
+  return tracker;
+};
+
+/**
  * Change the state of the model to reflect the specified path (either a
  * file or directory).
  *
  * @param {string} path The root path to use
  * @param {function=} opt_loadedCallback Invoked when the entire directory
  *     has been loaded and any default file selected.  If there are any
  *     errors loading the directory this will not get called (even if the
  *     directory loads OK on retry later). Will NOT be called if another
  *     directory change happened while setupPath was in progress.
  * @param {function=} opt_pathResolveCallback Invoked as soon as the path has
  *     been resolved, and called with the base and leaf portions of the path
  *     name, and a flag indicating if the entry exists. Will be called even
  *     if another directory change happened while setupPath was in progress,
  *     but will pass |false| as |exist| parameter.
  */
 DirectoryModel.prototype.setupPath = function(path, opt_loadedCallback,
                                               opt_pathResolveCallback) {
-  var overridden = false;
-  function onExternalDirChange() { overridden = true }
-  this.addEventListener('directory-changed', onExternalDirChange);
+  var tracker = this.createDirectoryChangeTracker();
+  tracker.start();
 
-  var resolveCallback = function(exists) {
-    this.removeEventListener('directory-changed', onExternalDirChange);
-    if (opt_pathResolveCallback)
-      opt_pathResolveCallback(baseName, leafName, exists && !overridden);
-  }.bind(this);
+  var self = this;
+  function resolveCallback(directoryPath, fileName, exists) {
+    tracker.stop();
+    if (!opt_pathResolveCallback)
+      return;
+    opt_pathResolveCallback(directoryPath, fileName,
+                            exists && !tracker.hasChanged);
+  }
 
-  var changeDirectoryEntry = function(entry, initial, exists, opt_callback) {
-    resolveCallback(exists);
-    if (!overridden)
-      this.changeDirectoryEntry_(initial, entry, opt_callback);
-  }.bind(this);
+  function changeDirectoryEntry(directoryEntry, initial, opt_callback) {
+    tracker.stop();
+    if (!tracker.hasChanged)
+      self.changeDirectoryEntry_(initial, directoryEntry, opt_callback);
+  }
 
   var INITIAL = true;
   var EXISTS = true;
 
-  // Split the dirname from the basename.
-  var ary = path.match(/^(?:(.*)\/)?([^\/]*)$/);
+  function changeToDefault() {
+    var def = self.getDefaultDirectory();
+    self.resolveDirectory(def, function(directoryEntry) {
+      resolveCallback(def, '', !EXISTS);
+      changeDirectoryEntry(directoryEntry, INITIAL);
+    }, function(error) {
+      console.error('Failed to resolve default directory: ' + def, error);
+      resolveCallback('/', '', !EXISTS);
+    });
+  }
 
-  if (!ary) {
-    console.warn('Unable to split default path: ' + path);
-    changeDirectoryEntry(this.root_, INITIAL, !EXISTS);
+  function noParentDirectory(error) {
+    console.log('Can\'t resolve parent directory: ' + path, error);
+    changeToDefault();
+  }
+
+  if (DirectoryModel.isSystemDirectory(path)) {
+    changeToDefault();
     return;
   }
 
-  var baseName = ary[1];
-  var leafName = ary[2];
-
-  function onLeafFound(baseDirEntry, leafEntry) {
-    if (leafEntry.isDirectory) {
-      baseName = path;
-      leafName = '';
-      changeDirectoryEntry(leafEntry, INITIAL, EXISTS);
-      return;
+  this.resolveDirectory(path, function(directoryEntry) {
+    resolveCallback(directoryEntry.fullPath, '', !EXISTS);
+    changeDirectoryEntry(directoryEntry, INITIAL);
+  }, function(error) {
+    // Usually, leaf does not exist, because it's just a suggested file name.
+    var fileExists = error.code == FileError.TYPE_MISMATCH_ERR;
+    if (fileExists || error.code == FileError.NOT_FOUND_ERR) {
+      var nameDelimiter = path.lastIndexOf('/');
+      var parentDirectoryPath = path.substr(0, nameDelimiter);
+      if (DirectoryModel.isSystemDirectory(parentDirectoryPath)) {
+        changeToDefault();
+        return;
+      }
+      self.resolveDirectory(parentDirectoryPath,
+                            function(parentDirectoryEntry) {
+        var fileName = path.substr(nameDelimiter + 1);
+        resolveCallback(parentDirectoryEntry.fullPath, fileName, fileExists);
+        changeDirectoryEntry(parentDirectoryEntry,
+                             !INITIAL /*HACK*/,
+                             function() {
+                               self.selectEntry(fileName);
+                               if (opt_loadedCallback)
+                                 opt_loadedCallback();
+                             });
+        // TODO(kaznacheev): Fix history.replaceState for the File Browser and
+        // change !INITIAL to INITIAL. Passing |false| makes things
+        // less ugly for now.
+      }, noParentDirectory);
+    } else {
+      // Unexpected errors.
+      console.error('Directory resolving error: ', error);
+      changeToDefault();
     }
-
-    // Leaf is an existing file, cd to its parent directory and select it.
-    changeDirectoryEntry(baseDirEntry,
-                         !INITIAL /*HACK*/,
-                         EXISTS,
-                         function() {
-                           this.selectEntry(leafEntry.name);
-                           if (opt_loadedCallback)
-                             opt_loadedCallback();
-                         }.bind(this));
-    // TODO(kaznacheev): Fix history.replaceState for the File Browser and
-    // change !INITIAL to INITIAL. Passing |false| makes things
-    // less ugly for now.
-  }
-
-  function onLeafError(baseDirEntry, err) {
-    // Usually, leaf does not exist, because it's just a suggested file name.
-    if (err.code != FileError.NOT_FOUND_ERR)
-      console.log('Unexpected error resolving default leaf: ' + err);
-    // |baseDirEntry| would point to a system directory if we are trying
-    // to change to a non-existing removable drive or an archive.
-    // Try to change to the default directory then.
-    if (DirectoryModel.isSystemDirectory(baseDirEntry.fullPath))
-      onBaseError(err);
-    else
-      changeDirectoryEntry(baseDirEntry, INITIAL, !EXISTS);
-  }
-
-  var onBaseError = function(err) {
-    console.log('Unexpected error resolving default base "' +
-                baseName + '": ' + err);
-    if (path != this.getDefaultDirectory()) {
-      // Can't find the provided path, let's go to default one instead.
-      resolveCallback(!EXISTS);
-      if (!overridden)
-        this.setupDefaultPath(opt_loadedCallback);
-    } else {
-      // Well, we can't find the downloads dir. Let's just show something,
-      // or we will get an infinite recursion.
-      changeDirectoryEntry(this.root_, opt_loadedCallback, INITIAL, !EXISTS);
-    }
-  }.bind(this);
-
-  var onBaseFound = function(baseDirEntry) {
-    if (!leafName) {
-      // Default path is just a directory, cd to it and we're done.
-      changeDirectoryEntry(baseDirEntry, INITIAL, !EXISTS);
-      return;
-    }
-
-    util.resolvePath(this.root_, path,
-                     onLeafFound.bind(this, baseDirEntry),
-                     onLeafError.bind(this, baseDirEntry));
-  }.bind(this);
-
-  var root = this.root_;
-  if (!baseName)
-    baseName = this.getDefaultDirectory();
-  root.getDirectory(baseName, {create: false}, onBaseFound, onBaseError);
+  });
 };
 
 /**
  * @param {function} opt_callback Callback on done.
  */
 DirectoryModel.prototype.setupDefaultPath = function(opt_callback) {
   this.setupPath(this.getDefaultDirectory(), opt_callback);
 };
 
 /**
@@ skipping 51 matching lines @@
                                                         callback) {
   this.metadataCache_.get(entries, 'filesystem', function(properties) {
     callback();
   });
 };
 
 /**
  * Get root entries asynchronously.
  * @private
  * @param {function(Array.<Entry>)} callback Called when roots are resolved.
- * @param {number} gdataAccess One of GDATA_ACCESS_* constants.
  */
-DirectoryModel.prototype.resolveRoots_ = function(callback, gdataAccess) {
+DirectoryModel.prototype.resolveRoots_ = function(callback) {
   var groups = {
     downloads: null,
     archives: null,
     removables: null,
     gdata: null
   };
   var self = this;
 
   metrics.startInterval('Load.Roots');
   function done() {
     for (var i in groups)
       if (!groups[i])
         return;
 
-    self.updateVolumeReadOnlyStatus_(groups.removables);
     callback(groups.downloads.
              concat(groups.gdata).
              concat(groups.archives).
              concat(groups.removables));
     metrics.recordInterval('Load.Roots');
   }
 
   function append(index, values, opt_error) {
     groups[index] = values;
     done();
   }
 
-  function onDownloads(entry) {
-    groups.downloads = [entry];
+  function appendSingle(index, entry) {
+    groups[index] = [entry];
     done();
   }
 
-  function onDownloadsError(error) {
-    groups.downloads = [];
-    done();
-  }
-
-  function onGDataMounted(entry) {
-    console.log('GData mounted:', entry);
-    self.unmountedGDataEntry_ = null;
-    groups.gdata = [entry];
-    done();
-  }
-
-  function onGDataNotMounted(error) {
-    console.log('GData not mounted: ' + (error || 'lazy'));
-    self.unmountedGDataEntry_ = {
-      unmounted: true,  // Clients use this field to distinguish a fake root.
-      error: error,
-      toURL: function() { return '' },
-      fullPath: '/' + DirectoryModel.GDATA_DIRECTORY
-    };
-    groups.gdata = [self.unmountedGDataEntry_];
+  function onSingleError(index, error, defaultValue) {
+    groups[index] = defailtValue || [];
     done();
   }
 
   var root = this.root_;
-  root.getDirectory(DirectoryModel.DOWNLOADS_DIRECTORY, { create: false },
-                    onDownloads, onDownloadsError);
+  function readSingle(dir, index, opt_defaultValue) {
+    root.getDirectory(dir, { create: false },
+                      appendSingle.bind(this, index),
+                      onSingleError.bind(this, index, opt_defaultValue));
+  }
+
+  readSingle(DirectoryModel.DOWNLOADS_DIRECTORY, 'downloads');
   util.readDirectory(root, DirectoryModel.ARCHIVE_DIRECTORY,
                      append.bind(this, 'archives'));
   util.readDirectory(root, DirectoryModel.REMOVABLE_DIRECTORY,
                      append.bind(this, 'removables'));
 
-  if (gdataAccess == DirectoryModel.GDATA_ACCESS_FULL) {
-    root.getDirectory(DirectoryModel.GDATA_DIRECTORY, { create: false },
-                      onGDataMounted, onGDataNotMounted);
-  } else if (gdataAccess == DirectoryModel.GDATA_ACCESS_LAZY) {
-    onGDataNotMounted();
+  if (this.gDataEnabled_) {
+    var fake = [DirectoryModel.fakeGDataEntry_];
+    if (this.isGDataMounted_())
+      readSingle(DirectoryModel.GDATA_DIRECTORY, 'gdata', fake);
+    else
+      groups.gdata = fake;
   } else {
     groups.gdata = [];
   }
 };
 
 /**
- * @param {function} callback Called when all roots are resolved.
- * @param {number} gdataAccess One of GDATA_ACCESS_* constants.
+ * Updates the roots list.
+ * @private
  */
-DirectoryModel.prototype.updateRoots = function(callback, gdataAccess) {
+DirectoryModel.prototype.updateRoots_ = function() {
   var self = this;
   this.resolveRoots_(function(rootEntries) {
     var dm = self.rootsList_;
     var args = [0, dm.length].concat(rootEntries);
     dm.splice.apply(dm, args);
 
     self.updateRootsListSelection_();
-
-    callback();
-  }, gdataAccess);
+  });
 };
 
 /**
  * Find roots list item by root path.
  *
  * @param {string} path Root path.
  * @return {number} Index of the item.
  * @private
  */
 DirectoryModel.prototype.findRootsListItem_ = function(path) {
   var roots = this.rootsList_;
   for (var index = 0; index < roots.length; index++) {
     if (roots.item(index).fullPath == path)
       return index;
   }
   return -1;
 };
 
 /**
  * @private
  */
 DirectoryModel.prototype.updateRootsListSelection_ = function() {
   var rootPath = DirectoryModel.getRootPath(this.currentDirEntry_.fullPath);
   this.rootsListSelection_.selectedIndex = this.findRootsListItem_(rootPath);
 };
 
 /**
- * @param {Array.<DirectoryEntry>} roots Removable volumes entries.
+ * @return {true} True if GDATA mounted.
  * @private
  */
-DirectoryModel.prototype.updateVolumeReadOnlyStatus_ = function(roots) {
-  var status = this.volumeReadOnlyStatus_ = {};
-  for (var i = 0; i < roots.length; i++) {
-    status[roots[i].fullPath] = false;
-    chrome.fileBrowserPrivate.getVolumeMetadata(roots[i].toURL(),
-        function(systemMetadata, path) {
-          status[path] = !!(systemMetadata && systemMetadata.isReadOnly);
-        }.bind(null, roots[i].fullPath));
+DirectoryModel.prototype.isGDataMounted_ = function() {
+  return this.volumeManager_.isMounted('/' + DirectoryModel.GDATA_DIRECTORY);
+};
+
+/**
+ * Handler for the VolumeManager's event.
+ * @private
+ */
+DirectoryModel.prototype.onMountChanged_ = function() {
+  this.updateRoots_();
+
+  if (this.getCurrentRootType() != DirectoryModel.RootType.GDATA)
+    return;
+
+  var mounted = this.isGDataMounted_();
+  if (this.currentDirEntry_ == DirectoryModel.fakeGDataEntry_) {
+    if (mounted) {
+      // Change fake entry to real one and rescan.
+      function onGotDirectory(entry) {
+        if (this.currentDirEntry_ == DirectoryModel.fakeGDataEntry_) {
+          this.currentDirEntry_ = entry;
+          this.rescan();
+        }
+      }
+      this.root_.getDirectory('/' + DirectoryModel.GDATA_DIRECTORY, {},
+                              onGotDirectory.bind(this));
+    }
+  } else if (!mounted) {
+    // Current entry unmounted. replace with fake one.
+    if (this.currentDirEntry_.fullPath ==
+        DirectoryModel.fakeGDataEntry_.fullPath) {
+      // Replace silently and rescan.
+      this.currentDirEntry_ = DirectoryModel.fakeGDataEntry_;
+      this.rescan();
+    } else {
+      this.changeDirectoryEntry_(false, DirectoryModel.fakeGDataEntry_);
+    }
   }
 };
 
-/**
- * Prepare the root for the unmount.
- *
- * @param {string} rootPath The path to the root.
- */
-DirectoryModel.prototype.prepareUnmount = function(rootPath) {
-  var index = this.findRootsListItem_(rootPath);
-  if (index == -1) {
-    console.error('Unknown root entry', rootPath);
-    return;
-  }
-  var entry = this.rootsList_.item(index);
-
-  // We never need to remove this attribute because even if the unmount fails
-  // the onMountCompleted handler calls updateRoots which creates a new entry
-  // object for this volume.
-  entry.unmounting = true;
-
-  // Re-place the entry into the roots data model to force re-rendering.
-  this.rootsList_.splice(index, 1, entry);
-
-  if (rootPath == this.rootPath) {
-    // TODO(kaznacheev): Consider changing to the most recently used root.
-    this.changeDirectory(this.getDefaultDirectory());
-  }
-};
-
 /**
  * @param {string} path Path
  * @return {boolean} If current directory is system.
  */
 DirectoryModel.isSystemDirectory = function(path) {
+  path = path.replace(/\/+$/, '');
   return path == '/' + DirectoryModel.REMOVABLE_DIRECTORY ||
          path == '/' + DirectoryModel.ARCHIVE_DIRECTORY;
 };
 
 /**
  * Performs search and displays results. The search type is dependent on the
  * current directory. If we are currently on gdata, server side content search
  * over gdata mount point. If the current directory is not on the gdata, file
  * name search over current directory wil be performed.
  *
@@ skipping 101 matching lines @@
  * @return {string} The name of the root.
  */
 DirectoryModel.getRootName = function(path) {
   var root = DirectoryModel.getRootPath(path);
   var index = root.lastIndexOf('/');
   return index == -1 ? root : root.substring(index + 1);
 };
 
 /**
  * @param {string} path A path.
- * @return {string} A root type.
+ * @return {DirectoryModel.RootType} A root type.
  */
 DirectoryModel.getRootType = function(path) {
   function isTop(dir) {
     return path.substr(1, dir.length) == dir;
   }
 
   if (isTop(DirectoryModel.DOWNLOADS_DIRECTORY))
     return DirectoryModel.RootType.DOWNLOADS;
   if (isTop(DirectoryModel.GDATA_DIRECTORY))
     return DirectoryModel.RootType.GDATA;
@@ skipping 70 matching lines @@
  * Cancel scanner.
  */
 DirectoryModel.Scanner.prototype.cancel = function() {
   this.cancelled_ = true;
 };
 
 /**
  * Start scanner.
  */
 DirectoryModel.Scanner.prototype.run = function() {
+  if (this.dir_ == DirectoryModel.fakeGDataEntry_) {
+    if (!this.cancelled_)
+      this.successCallback_();
+    return;
+  }
+
   metrics.startInterval('DirectoryScan');
 
   this.reader_ = this.dir_.createReader();
   this.readNextChunk_();
 };
 
 /**
  * @private
  */
 DirectoryModel.Scanner.prototype.readNextChunk_ = function() {
@@ skipping 36 matching lines @@
 /**
  * @private
  */
 DirectoryModel.Scanner.prototype.recordMetrics_ = function() {
   metrics.recordInterval('DirectoryScan');
   if (this.dir_.fullPath ==
       '/' + DirectoryModel.DOWNLOADS_DIRECTORY) {
     metrics.recordMediumCount('DownloadsCount', this.list_.length);
   }
 };
+
+/**
+ * @constructor
+ * @param {DirectoryEntry} root Root entry.
+ * @param {DirectoryModel} directoryModel Model to watch.
+ * @param {VolumeManager} volumeManager Manager to watch.
+ */
+function FileWatcher(root, directoryModel, volumeManager) {
+  this.root_ = root;
+  this.dm_ = directoryModel;
+  this.vm_ = volumeManager;
+  this.watchedDirectoryEntry_ = null;
+  this.updateWatchedDirectoryBound_ =
+      this.updateWatchedDirectory_.bind(this);
+  this.onFileChangedBound_ =
+      this.onFileChanged_.bind(this);
+}
+
+/**
+ * Starts watching.
+ */
+FileWatcher.prototype.start = function() {
+  chrome.fileBrowserPrivate.onFileChanged.addListener(
+        this.onFileChangedBound_);
+
+  this.dm_.addEventListener('directory-changed',
+      this.updateWatchedDirectoryBound_);
+  this.vm_.addEventListener('changed',
+      this.updateWatchedDirectoryBound_);
+
+  this.updateWatchedDirectory_();
+};
+
+/**
+ * Stops watching (must be called before page unload).
+ */
+FileWatcher.prototype.stop = function() {
+  chrome.fileBrowserPrivate.onFileChanged.removeListener(
+        this.onFileChangedBound_);
+
+  this.dm_.removeEventListener('directory-changed',
+      this.updateWatchedDirectoryBound_);
+  this.vm_.removeEventListener('changed',
+      this.updateWatchedDirectoryBound_);
+
+  if (this.watchedDirectoryEntry_)
+    this.changeWatchedEntry(null);
+};
+
+/**
+ * @param {Object} event chrome.fileBrowserPrivate.onFileChanged event.
+ * @private
+ */
+FileWatcher.prototype.onFileChanged_ = function(event) {
+  if (encodeURI(event.fileUrl) == this.watchedDirectoryEntry_.toURL())
+    this.onFileInWatchedDirectoryChanged();
+};
+
+/**
+ * Called when file in the watched directory changed.
+ */
+FileWatcher.prototype.onFileInWatchedDirectoryChanged = function() {
+  this.dm_.rescanLater();
+};
+
+/**
+ * Called when directory changed or volumes mounted/unmounted.
+ * @private
+ */
+FileWatcher.prototype.updateWatchedDirectory_ = function() {
+  var current = this.watchedDirectoryEntry_;
+  switch (this.dm_.getCurrentRootType()) {
+    case DirectoryModel.RootType.GDATA:
+      if (!this.vm_.isMounted('/' + DirectoryModel.GDATA_DIRECTORY))
+         break;
+    case DirectoryModel.RootType.DOWNLOADS:
+    case DirectoryModel.RootType.REMOVABLE:
+      if (!current || current.fullPath != this.dm_.getCurrentDirPath()) {
+        // TODO(serya): Changed in readonly removable directoried don't
+        //              need to be tracked.
+        this.root_.getDirectory(this.dm_.getCurrentDirPath(), {},
+                                this.changeWatchedEntry.bind(this),
+                                this.changeWatchedEntry.bind(this, null));
+      }
+      return;
+  }
+  if (current)
+    this.changeWatchedEntry(null);
+};
+
+/**
+ * @param {Entry?} entry Null if no directory need to be watched or
+ *                       directory to watch.
+ */
+FileWatcher.prototype.changeWatchedEntry = function(entry) {
+  if (this.watchedDirectoryEntry_) {
+    chrome.fileBrowserPrivate.removeFileWatch(
+        this.watchedDirectoryEntry_.toURL(),
+        function(result) {
+          if (!result) {
+            console.log('Failed to remove file watch');
+          }
+        });
+  }
+  this.watchedDirectoryEntry_ = entry;
+
+  if (this.watchedDirectoryEntry_) {
+    chrome.fileBrowserPrivate.addFileWatch(
+        this.watchedDirectoryEntry_.toURL(),
+        function(result) {
+          if (!result) {
+            console.log('Failed to add file watch');
+            if (this.watchedDirectoryEntry_ == entry)
+              this.watchedDirectoryEntry_ = null;
+          }
+        }.bind(this));
+  }
+};
+
+/**
+ * @return {DirectoryEntry} Current watched directory entry.
+ */
+FileWatcher.prototype.getWatchedDirectoryEntry = function() {
+  return this.watchedDirectoryEntry_;
+};