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

chrome/browser/resources/file_manager/js/file_manager.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.
 
 /**
  * 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).
@@ skipping 10 matching lines @@
                  {};
 
   this.listType_ = null;
 
   this.selection = null;
 
   this.butterTimer_ = null;
   this.currentButter_ = null;
   this.butterLastShowTime_ = 0;
 
-  this.watchedDirectoryUrl_ = null;
   this.filesystemObserverId_ = null;
   this.gdataObserverId_ = null;
 
   this.commands_ = {};
 
   this.thumbnailUrlCache_ = {};
 
   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,
       FileManager.DialogType.SELECT_OPEN_MULTI_FILE,
       FileManager.DialogType.FULL_PAGE]);
 
   // TODO(dgozman): This will be changed to LocaleInfo.
   this.locale_ = new v8Locale(navigator.language);
 
   this.initFileSystem_();
+  this.volumeManager_ = VolumeManager.getInstance();
   this.initDom_();
   this.initDialogType_();
   this.dialogDom_.style.opacity = '1';
 }
 
 FileManager.prototype = {
   __proto__: cr.EventTarget.prototype
 };
 
 // Anonymous "namespace".
@@ skipping 138 matching lines @@
 
     if (parent_path[parent_path.length - 1] != '/')
       parent_path += '/';
 
     if (child_path[child_path.length - 1] != '/')
       child_path += '/';
 
     return child_path.indexOf(parent_path) == 0;
   }
 
- /**
-  * Normalizes path not to start with /
-  *
-  * @param {string} path The file path.
-  */
-  function normalizeAbsolutePath(x) {
-    if (x[0] == '/')
-      return x.slice(1);
-    else
-      return x;
-  }
-
   function removeChildren(element) {
     element.textContent = '';
   }
 
   // Public statics.
 
   /**
    * List of dialog types.
    *
    * Keep this in sync with FileManagerDialog::GetDialogTypeAsString, except
@@ skipping 14 matching lines @@
         type == FileManager.DialogType.SELECT_SAVEAS_FILE ||
         type == FileManager.DialogType.SELECT_OPEN_FILE ||
         type == FileManager.DialogType.SELECT_OPEN_MULTI_FILE;
   };
 
   FileManager.ListType = {
     DETAIL: 'detail',
     THUMBNAIL: 'thumb'
   };
 
+  FileManager.FileWatcher = function(fileManager) {
+    FileWatcher.call(this,
+                     fileManager.filesystem_.root,
+                     fileManager.directoryModel_,
+                     fileManager.volumeManager_);
+    this.metadataCache_ = fileManager.metadataCache_;
+
+    this.filesystemChanngeHandler_ =

[dgozman, 2012/05/16 14:31:46]

typo here and below: chaNNge

+        fileManager.updateMetadataInUI_.bind(fileManager, 'filesystem');
+    this.gdataChanngeHandler_ =
+        fileManager.updateMetadataInUI_.bind(fileManager, 'gdata');
+
+    this.filesystemObserverId_ = null;
+    this.gdataObserverId_ = null;
+  };
+
+  FileManager.FileWatcher.prototype.__proto__ = FileWatcher.prototype;
+
+  FileManager.FileWatcher.prototype.changeWatchedEntry = function(entry) {
+    FileWatcher.prototype.changeWatchedEntry.call(this, entry);
+
+    if (this.filesystemObserverId_)
+      this.metadataCache_.removeObserver(this.filesystemObserverId_);
+    if (this.gdataObserverId_)
+      this.metadataCache_.removeObserver(this.gdataObserverId_);
+    this.filesystemObserverId_ = null;
+    this.gdataObserverId_ = null;
+    if (!entry)
+      return;
+
+    this.filesystemObserverId_ = this.metadataCache_.addObserver(
+        entry,
+        MetadataCache.CHILDREN,
+        'filesystem',
+        this.filesystemChanngeHandler_);
+
+    if (DirectoryModel.getRootType(entry.fullPath) ==
+        DirectoryModel.RootType.GDATA) {
+      this.gdataObserverId_ = this.metadataCache_.addObserver(
+          entry,
+          MetadataCache.CHILDREN,
+          'gdata',
+          this.gdataChanngeHandler_);
+    }
+  };
+
   /**
    * Load translated strings.
    */
   FileManager.initStrings = function(callback) {
     chrome.fileBrowserPrivate.getStrings(function(strings) {
       localStrings = new LocalStrings(strings);
       if (callback)
         callback();
     });
   };
@@ skipping 10 matching lines @@
     util.UNITS = [str('SIZE_KB'),
                   str('SIZE_MB'),
                   str('SIZE_GB'),
                   str('SIZE_TB'),
                   str('SIZE_PB')];
 
     metrics.startInterval('Load.FileSystem');
 
     var self = this;
 
-    // The list of active mount points to distinct them from other directories.
-    chrome.fileBrowserPrivate.getMountPoints(function(mountPoints) {
-      self.setMountPoints_(mountPoints);
-      onDone();
-    });
-
-    function onDone() {
-      if (self.mountPoints_ && self.filesystem_)
-        self.init_();
-    }
-
     chrome.fileBrowserPrivate.requestLocalFileSystem(function(filesystem) {
       metrics.recordInterval('Load.FileSystem');
       self.filesystem_ = filesystem;
-      onDone();
+      self.init_();
     });
   };
 
-  FileManager.prototype.setMountPoints_ = function(mountPoints) {
-    this.mountPoints_ = mountPoints;
-    // Add gdata mount info if present.
-    if (this.gdataMounted_)
-      this.mountPoints_.push(this.gdataMountInfo_);
-  };
-
   /**
    * Continue initializing the file manager after resolving roots.
    */
   FileManager.prototype.init_ = function() {
     metrics.startInterval('Load.DOM');
     this.initCommands_();
 
     this.metadataCache_ = MetadataCache.createFull();
 
     this.shortDateFormatter_ =
@@ skipping 11 matching lines @@
 
     this.table_.startBatchUpdates();
     this.grid_.startBatchUpdates();
 
     this.initFileList_();
     this.initDialogs_();
 
     window.addEventListener('popstate', this.onPopState_.bind(this));
     window.addEventListener('unload', this.onUnload_.bind(this));
 
-    this.directoryModel_.addEventListener('directory-changed',
+    var dm = this.directoryModel_;
+    dm.addEventListener('directory-changed',
                                           this.onDirectoryChanged_.bind(this));
     var self = this;
-    this.directoryModel_.addEventListener('begin-update-files', function() {
+    dm.addEventListener('begin-update-files', function() {
       self.currentList_.startBatchUpdates();
     });
-    this.directoryModel_.addEventListener('end-update-files', function() {
+    dm.addEventListener('end-update-files', function() {
       self.restoreItemBeingRenamed_();
       self.currentList_.endBatchUpdates();
     });
-    this.directoryModel_.addEventListener('scan-started',
-        this.showSpinnerLater_.bind(this));
-    this.directoryModel_.addEventListener('scan-completed',
-        this.showSpinner_.bind(this, false));
-    this.directoryModel_.addEventListener('scan-completed',
-        this.refreshCurrentDirectoryMetadata_.bind(this));
-    this.directoryModel_.addEventListener('rescan-completed',
-        this.refreshCurrentDirectoryMetadata_.bind(this));
+    dm.addEventListener('scan-started', this.showSpinnerLater_.bind(this));
+    dm.addEventListener('scan-completed', this.showSpinner_.bind(this, false));
+    dm.addEventListener('scan-completed',
+                        this.refreshCurrentDirectoryMetadata_.bind(this));
+    dm.addEventListener('rescan-completed',
+                        this.refreshCurrentDirectoryMetadata_.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_ = [];
-    this.unmountRequests_ = [];
-    chrome.fileBrowserPrivate.onMountCompleted.addListener(
-        this.onMountCompleted_.bind(this));
-
-    chrome.fileBrowserPrivate.onFileChanged.addListener(
-        this.onFileChanged_.bind(this));
-
+    this.setupCurrentDirectory_(true /* page loading */);
     this.networkConnectionState_ = null;
     var queryNetworkConnectionState = function() {
       chrome.fileBrowserPrivate.getNetworkConnectionState(
           this.onNetworkConnectionChanged_.bind(this));
     }.bind(this);
     queryNetworkConnectionState();
     chrome.fileBrowserPrivate.onNetworkConnectionChanged.
         addListener(queryNetworkConnectionState);
 
-    var invokeHandler = !this.params_.selectOnly;
-    if (this.isStartingOnGData_()) {
-      // We are opening on a GData path. Mount GData and show
-      // "Loading Google Docs" message until the directory content loads.
-      this.dialogContainer_.setAttribute('unmounted', true);
-      this.initGData_(true /* dirChanged */);
-      // This is a one-time handler (will be nulled out on the first call).
-      this.setupCurrentDirectoryPostponed_ = function(event) {
-        this.directoryModel_.removeEventListener('directory-changed',
-           this.setupCurrentDirectoryPostponed_);
-        this.setupCurrentDirectoryPostponed_ = null;
-        if (event) // If called as an event handler just exit silently.
-          return;
-        this.setupCurrentDirectory_(
-            invokeHandler, false /* blankWhileOpeningAFile */);
-      }.bind(this);
-      this.directoryModel_.addEventListener('directory-changed',
-          this.setupCurrentDirectoryPostponed_);
-    } else {
-      this.setupCurrentDirectory_(
-          invokeHandler, true /* blankWhileOpeningAFile */);
-    }
-
     this.summarizeSelection_();
 
     var sortField =
         window.localStorage['sort-field-' + this.dialogType_] ||
         'modificationTime';
     var sortDirection =
         window.localStorage['sort-direction-' + this.dialogType_] || 'desc';
     this.directoryModel_.sortFileList(sortField, sortDirection);
 
     this.refocus();
@@ skipping 93 matching lines @@
     this.filenameInput_ = this.dialogDom_.querySelector('.filename-input');
     this.taskItems_ = this.dialogDom_.querySelector('#tasks');
     this.okButton_ = this.dialogDom_.querySelector('.ok');
     this.cancelButton_ = this.dialogDom_.querySelector('.cancel');
     this.deleteButton_ = this.dialogDom_.querySelector('#delete-button');
     this.table_ = this.dialogDom_.querySelector('.detail-table');
     this.grid_ = this.dialogDom_.querySelector('.thumbnail-grid');
     this.spinner_ = this.dialogDom_.querySelector('.spinner');
     this.showSpinner_(false);
     this.butter_ = this.dialogDom_.querySelector('.butter-bar');
-    this.unmountedPanel_ = this.dialogDom_.querySelector('.unmounted-panel');
 
     cr.ui.decorate('#gdata-settings', cr.ui.MenuButton);
     cr.ui.Table.decorate(this.table_);
     cr.ui.Grid.decorate(this.grid_);
 
     this.document_.addEventListener('keydown', this.onKeyDown_.bind(this));
     // Disable the default browser context menu.
     this.document_.addEventListener('contextmenu',
                                     function(e) { e.preventDefault() });
 
@@ skipping 29 matching lines @@
 
     this.decorateSplitter(
         this.dialogDom_.querySelector('div.sidebar-splitter'));
 
     this.dialogContainer_ = this.dialogDom_.querySelector('.dialog-container');
     this.dialogDom_.querySelector('#detail-view').addEventListener(
         'click', this.onDetailViewButtonClick_.bind(this));
     this.dialogDom_.querySelector('#thumbnail-view').addEventListener(
         'click', this.onThumbnailViewButtonClick_.bind(this));
 
-    // When we show the page for the first time we want to avoid
-    // the GDrive settings button animation, so we set the attribute ASAP.
-    if (this.isStartingOnGData_())
-      this.dialogContainer_.setAttribute('gdata', true);
-
     this.syncButton = this.dialogDom_.querySelector('#gdata-sync-settings');
     this.syncButton.addEventListener('click', this.onGDataPrefClick_.bind(
         this, 'cellularDisabled', false /* not inverted */));
 
     this.hostedButton = this.dialogDom_.querySelector('#gdata-hosted-settings');
     this.hostedButton.addEventListener('click', this.onGDataPrefClick_.bind(
         this, 'hostedFilesDisabled', true /* inverted */));
 
     this.gdataPreferences_ = null;
     var queryGDataPreferences = function() {
       chrome.fileBrowserPrivate.getGDataPreferences(
           this.onGDataPreferencesChanged_.bind(this));
     }.bind(this);
     queryGDataPreferences();
-    chrome.fileBrowserPrivate.onGDataPreferencesChanged.
-        addListener(queryGDataPreferences);
+    // TODO(serya): uncomment
+    //chrome.fileBrowserPrivate.onGDataPreferencesChanged.
+    //    addListener(queryGDataPreferences);
 
     cr.ui.ComboButton.decorate(this.taskItems_);
     this.taskItems_.addEventListener('select',
         this.onTaskItemClicked_.bind(this));
 
     this.dialogDom_.ownerDocument.defaultView.addEventListener(
         'resize', this.onResize_.bind(this));
 
     if (str('ASH') == '1')
       this.dialogDom_.setAttribute('ash', 'true');
@@ skipping 19 matching lines @@
 
     var sigleSelection =
         this.dialogType_ == FileManager.DialogType.SELECT_OPEN_FILE ||
         this.dialogType_ == FileManager.DialogType.SELECT_FOLDER ||
         this.dialogType_ == FileManager.DialogType.SELECT_SAVEAS_FILE;
 
     this.directoryModel_ = new DirectoryModel(
         this.filesystem_.root,
         sigleSelection,
         FileManager.isGDataEnabled(),
-        this.metadataCache_);
+        this.metadataCache_,
+        this.volumeManager_);
+
+    this.fileWatcher_ = new FileManager.FileWatcher(this);
+    this.fileWatcher_.start();
 
     if (FileManager.isGDataEnabled())
       this.initGDataWelcomeBanners_();
 
     var dataModel = this.directoryModel_.getFileList();
     var collator = this.collator_;
     // TODO(dgozman): refactor comparison functions together with
     // render/update/display.
     dataModel.setCompareFunction('name', function(a, b) {
       return collator.compare(a.name, b.name);
@@ skipping 17 matching lines @@
     this.initGrid_();
     this.initRootsList_();
 
     var listType = FileManager.ListType.DETAIL;
     if (FileManager.DialogType.isModal(this.dialogType_))
       listType = window.localStorage['listType-' + this.dialogType_] ||
           FileManager.ListType.DETAIL;
     this.setListType(listType);
 
     this.textSearchState_ = {text: '', date: new Date()};
+
+    this.volumeManager_.addEventListener('gdata-status-changed',
+        this.updateGDataStatus_.bind(this, 'status-change'));
   };
 
   FileManager.prototype.initRootsList_ = function() {
     this.rootsList_ = this.dialogDom_.querySelector('#roots-list');
     cr.ui.List.decorate(this.rootsList_);
-    this.rootsList_.startBatchUpdates();
 
     var self = this;
     this.rootsList_.itemConstructor = function(entry) {
       return self.renderRoot_(entry);
     };
 
     this.rootsList_.selectionModel =
         this.directoryModel_.getRootsListSelectionModel();
 
     // TODO(dgozman): add "Add a drive" item.
     this.rootsList_.dataModel = this.directoryModel_.getRootsList();
-    this.directoryModel_.updateRoots(function() {
-        self.rootsList_.endBatchUpdates();
-    }, false);
   };
 
-  /**
-   * @param {boolean} dirChanged True if we just changed to GData directory,
-   *                             False if "Retry" button clicked.
-   */
-  FileManager.prototype.initGData_ = function(dirChanged) {
-    this.initGDataUnmountedPanel_();
-
-    this.unmountedPanel_.removeAttribute('error');
-    if (dirChanged) {
-      // When changing to GData directory we want to see a clear panel.
-      this.unmountedPanel_.removeAttribute('retry');
-      if (this.gdataLoadingTimer_) {  // Show immediately if already loading.
-        this.unmountedPanel_.setAttribute('loading', true);
-      } else {
-        this.unmountedPanel_.removeAttribute('loading');
-        setTimeout(function() {
-          if (this.gdataLoadingTimer_) {  // Still loading.
-            this.unmountedPanel_.setAttribute('loading', true);
-          }
-        }.bind(this), 500);
+  FileManager.prototype.updateGDataStatus_ = function(reason) {
+    var node = this.dialogContainer_;
+    if (this.isOnGData()) {
+      var status = this.volumeManager_.getGDataStatus();
+      if (status == VolumeManager.GDataStatus.MOUNTING ||
+          status == VolumeManager.GDataStatus.ERROR) {
+        this.initGDataUnmountedPanel_();
+        var retryButton = this.document_.querySelector(
+            '#unmounted-panel button.retry');
+        if (status == VolumeManager.GDataStatus.ERROR)
+          retryButton.hidden = false;
+        else if (reason == 'directory-change')
+          retryButton.hidden = true;
       }
+      node.setAttribute('gdata', status);
     } else {
-      // When retrying we do not hide "Retry" and "Learn more".
-      this.unmountedPanel_.setAttribute('loading', true);
+      node.removeAttribute('gdata');
     }
-
-    // If the user changed to another directory and then back to GData we
-    // re-enter this method while the timer is still active. In this case
-    // we only update the UI but do not request the mount again.
-    if (this.gdataLoadingTimer_)
-      return;
-
-    metrics.startInterval('Load.GData');
-    chrome.fileBrowserPrivate.addMount('', 'gdata', {},
-                                       function(sourcePath) {});
-
-    // This timer could fire before the mount succeeds. We will silently
-    // replace the error message with the correct directory contents.
-    this.gdataLoadingTimer_ = setTimeout(function() {
-          this.gdataLoadingTimer_ = null;
-          this.onGDataUnreachable_('GData load timeout');
-        }.bind(this),
-        15 * 60 * 1000);
-  };
-
-  FileManager.prototype.clearGDataLoadingTimer_ = function(message) {
-    if (this.gdataLoadingTimer_) {
-      clearTimeout(this.gdataLoadingTimer_);
-      this.gdataLoadingTimer_ = null;
-    }
-  };
-
-  FileManager.prototype.onGDataUnreachable_ = function(message) {
-    console.warn(message);
-    if (this.isOnGData()) {
-      this.unmountedPanel_.removeAttribute('loading');
-      this.unmountedPanel_.setAttribute('error', true);
-      this.unmountedPanel_.setAttribute('retry', true);
-    }
+    console.log('gdata status: ', node.getAttribute('gdata'));
   };
 
   FileManager.prototype.initGDataUnmountedPanel_ = function() {
-    if (this.unmountedPanel_.firstElementChild)
+    var panel = this.document_.querySelector('#unmounted-panel');
+    if (panel.firstElementChild)
       return;
 
-    var loading = this.document_.createElement('div');
-    loading.className = 'gdata loading';
-    loading.textContent = str('GDATA_LOADING');
-    this.unmountedPanel_.appendChild(loading);
+    function create(tag, className) {
+      var div = panel.ownerDocument.createElement(tag);
+      div.className = className;
+      return div;
+    }
 
-    var spinnerBox = this.document_.createElement('div');
-    spinnerBox.className = 'spinner-box';
-    loading.appendChild(spinnerBox);
+    function append(tag, className, opt_textContent) {
+      var div = create(tag, className);
+      div.textContent = opt_textContent || '';
+      panel.appendChild(div);
+      return div;
+    }
 
-    var spinner = this.document_.createElement('div');
-    spinner.className = 'spinner';
-    spinnerBox.appendChild(spinner);
-
-    var progress = this.document_.createElement('div');
-    progress.className = 'gdata progress';
-    this.unmountedPanel_.appendChild(progress);
-
+    append('div', 'gdata loading', str('GDATA_LOADING'));
+    append('div', 'spinner-box').appendChild(create('div', 'spinner'));
+    var progress = append('div', 'gdata progress');
     chrome.fileBrowserPrivate.onDocumentFeedFetched.addListener(
         function(fileCount) {
           progress.textContent = strf('GDATA_LOADING_PROGRESS', fileCount);
         });
 
-    var error = this.document_.createElement('div');
-    error.className = 'gdata error';
-    error.textContent = strf('GDATA_CANNOT_REACH', str('GDATA_PRODUCT_NAME'));
-    this.unmountedPanel_.appendChild(error);
+    append('div', 'gdata error', strf('GDATA_CANNOT_REACH',
+                                      str('GDATA_PRODUCT_NAME')));
 
-    var retry = this.document_.createElement('button');
-    retry.className = 'gdata retry';
-    retry.textContent = str('GDATA_RETRY');
-    retry.onclick = this.initGData_.bind(this, false /* retry */);
-    this.unmountedPanel_.appendChild(retry);
+    append('button', 'gdata retry', str('GDATA_RETRY'));
+        // onclick = this.initGData_.bind(this, false);
 
-    var learnMore = this.document_.createElement('div');
-    learnMore.className = 'gdata learn-more plain-link';
-    learnMore.textContent = str('GDATA_LEARN_MORE');
-    learnMore.addEventListener('click',
-        this.onExternalLinkClick_.bind(this, GOOGLE_DRIVE_ERROR_HELP_URL));
-    this.unmountedPanel_.appendChild(learnMore);
+    append('div', 'gdata learn-more plain-link', str('GDATA_LEARN_MORE')).
+        onclick = this.onExternalLinkClick_.bind(this,
+            GOOGLE_DRIVE_ERROR_HELP_URL);
   };
 
   FileManager.prototype.onDataModelSplice_ = function(event) {
     var checkbox = this.document_.querySelector('#select-all-checkbox');
     if (checkbox)
       this.updateSelectAllCheckboxState_(checkbox);
   };
 
   FileManager.prototype.onDataModelPermuted_ = function(event) {
     var sortStatus = this.directoryModel_.getFileList().sortStatus;
@@ skipping 530 matching lines @@
 
       case 'delete':
         this.deleteEntries(this.selection.entries);
         return;
 
       case 'newfolder':
         this.onNewFolderCommand_(event);
         return;
 
       case 'unmount':
-        this.unmountVolume_(this.directoryModel_.getCurrentRootDirEntry());
+        this.unmountVolume_(
+            this.directoryModel_.getCurrentRootDirEntry());
         return;
 
       case 'format':
         var entry = this.directoryModel_.getCurrentRootDirEntry();
         this.confirm.show(str('FORMATTING_WARNING'), function() {
           chrome.fileBrowserPrivate.formatDevice(entry.toURL());
         });
 
         return;
     }
   };
 
   /**
    * Respond to the back and forward buttons.
    */
   FileManager.prototype.onPopState_ = function(event) {
     this.closeFilePopup_();
     // Nothing left to do if the current directory is not changing. This happens
     // if we are exiting the Gallery.
     if (this.getPathFromUrlOrParams_() ==
         this.directoryModel_.getCurrentDirEntry().fullPath)
       return;
-    this.setupCurrentDirectory_(true /* invokeHandler */);
+    this.setupCurrentDirectory_(false /* page loading */);
   };
 
   FileManager.prototype.requestResize_ = function(timeout) {
     setTimeout(this.onResize_.bind(this), timeout || 0);
   };
 
   /**
    * Resize details and thumb views to fit the new window size.
    */
   FileManager.prototype.onResize_ = function() {
@@ skipping 33 matching lines @@
   };
 
   /**
    * Restores current directory and may be a selected item after page load (or
    * reload) or popping a state (after click on back/forward). If location.hash
    * is present it means that the user has navigated somewhere and that place
    * will be restored. defaultPath primarily is used with save/open dialogs.
    * Default path may also contain a file name. Freshly opened file manager
    * window has neither.
    *
-   * @param {boolean} invokeHandler Whether to invoke the default handler on
-   *                                the selected file.
-   * @param {boolean} opt_blankWhileOpeningAFile Whether to show fade over
-   *                                             the file manager.
+   * @param {boolean} pageLoading True if pase is loading,
+                                  false if popping state.
    */
-  FileManager.prototype.setupCurrentDirectory_ =
-      function(invokeHandler, opt_blankWhileOpeningAFile) {
+  FileManager.prototype.setupCurrentDirectory_ = function(pageLoading) {
     var path = this.getPathFromUrlOrParams_();
 
     if (!path) {
       this.directoryModel_.setupDefaultPath();
       return;
     }
 
+    if (DirectoryModel.getRootType(path) == DirectoryModel.RootType.GDATA) {
+      if (!FileManager.isGDataEnabled()) {
+        this.directoryModel_.setupDefaultPath();
+        return;
+      }
+
+      // Reflect immediatelly in the UI we are on GData and display
+      // mounting UI.
+      this.directoryModel_.setupPath('/' + DirectoryModel.GDATA_DIRECTORY);
+
+      var tracker = this.directoryModel_.createDirectoryChangeTracker();
+      // Expected finish of setupPath to GData.
+      tracker.exceptInitialChange = true;
+      tracker.start();
+      this.volumeManager_.mountGData(function() {
+        tracker.stop();
+        if (!tracker.hasChanged) {
+          this.finishSetupCurrentDirectory_(path, pageLoading);
+        }
+      }.bind(this), function(error) {
+        tracker.stop();
+      });
+    } else {
+      this.finishSetupCurrentDirectory_(path, pageLoading);
+    }
+  };
+
+  FileManager.prototype.finishSetupCurrentDirectory_ = function(
+      path, pageLoading) {
+    var invokeHandler = pageLoading && !this.params_.selectOnly;
     // In the FULL_PAGE mode if the hash path points to a file we might have
     // to invoke a task after selecting it.
     // If the file path is in params_ we only want to select the file.
-    if (invokeHandler && location.hash &&
-        this.dialogType_ == FileManager.DialogType.FULL_PAGE) {
+    if (this.dialogType_ == FileManager.DialogType.FULL_PAGE &&
+        location.hash && invokeHandler) {
       // To prevent the file list flickering for a moment before the action
       // is executed we hide it under a white div.
       var shade;
-      if (opt_blankWhileOpeningAFile) {
+      if (pageLoading) {
         shade = this.document_.createElement('div');
         shade.className = 'overlay-pane';
         shade.style.backgroundColor = 'white';
         this.document_.body.appendChild(shade);
       }
       function removeShade() {
         if (shade)
           shade.parentNode.removeChild(shade);
       }
 
@@ skipping 315 matching lines @@
       }
     };
     li.addEventListener('mousedown', handleClick);
     li.addEventListener(cr.ui.TouchHandler.EventType.TOUCH_START, handleClick);
 
     var rootType = DirectoryModel.getRootType(entry.fullPath);
 
     var div = this.document_.createElement('div');
     div.className = 'root-label';
 
-    var icon = rootType;
-    var deviceNumber = this.getDeviceNumber(entry);
-
-    if (deviceNumber != undefined) {
-      var mountCondition = this.mountPoints_[deviceNumber].mountCondition;
-      if (mountCondition == 'unknown_filesystem' ||
-          mountCondition == 'unsupported_filesystem')
-        icon = 'unreadable';
-    }
-
-    div.setAttribute('icon', icon);
-
     div.textContent = this.getRootLabel_(entry.fullPath);
     li.appendChild(div);
 
     if (rootType == DirectoryModel.RootType.ARCHIVE ||
         rootType == DirectoryModel.RootType.REMOVABLE) {
-      if (entry.unmounting) {
-        li.setAttribute('disabled', 'disabled');
-      } else {
-        var eject = this.document_.createElement('div');
-        eject.className = 'root-eject';
-        eject.addEventListener('click', function(event) {
-          event.stopPropagation();
-          this.unmountVolume_(entry);
-        }.bind(this));
-        // Block other mouse handlers.
-        eject.addEventListener('mouseup', function(e) { e.stopPropagation() });
-        eject.addEventListener('mousedown', function(e) { e.stopPropagation() });
-        li.appendChild(eject);
+      var eject = this.document_.createElement('div');
+      eject.className = 'root-eject';
+      eject.addEventListener('click', function(event) {
+        event.stopPropagation();
+        this.unmountVolume_(entry);
+      }.bind(this));
+      // Block other mouse handlers.
+      eject.addEventListener('mouseup', function(e) { e.stopPropagation() });
+      eject.addEventListener('mousedown', function(e) { e.stopPropagation() });
+      li.appendChild(eject);
 
-        cr.ui.contextMenuHandler.setContextMenu(li, this.rootsContextMenu_);
-      }
+      cr.ui.contextMenuHandler.setContextMenu(li, this.rootsContextMenu_);
     }
 
     cr.defineProperty(li, 'lead', cr.PropertyKind.BOOL_ATTR);
     cr.defineProperty(li, 'selected', cr.PropertyKind.BOOL_ATTR);
+
+    var icon = rootType;
+    var mountCondition = this.volumeManager_.getMountCondition(entry.fullPath);
+
+    if (mountCondition == 'unknown_filesystem' ||
+        mountCondition == 'unsupported_filesystem') {
+      icon = 'unreadable';
+    }
+    div.setAttribute('icon', icon);
+
     return li;
   };
 
   /**
    * Unmounts device.
    * @param {Entry} entry The entry to unmount.
    */
   FileManager.prototype.unmountVolume_ = function(entry) {
-    this.directoryModel_.prepareUnmount(entry.fullPath);
-    this.unmountRequests_.push(entry.fullPath);
-    chrome.fileBrowserPrivate.removeMount(entry.toURL());
+    listItem = this.rootsList_.getListItem(entry);
+    listItem && listItem.setAttribute('disabled');

[dgozman, 2012/05/16 14:31:46]

Don't like this syntax.

+    var self = this;
+    this.volumeManager_.unmount(entry.fullPath, function() {},
+                                function(error) {
+      listItem && listItem.removeAttribute('disabled');
+      self.alert.show(strf('UNMOUNT_FAILED', error.message));
+    });
   };
 
   FileManager.prototype.updateGDataStyle_ = function(
       listItem, entry, gdata) {
     if (!this.isOnGData() || !gdata)
       return;
 
     if (!entry.isDirectory) {
       if (!gdata.availableOffline)
         listItem.classList.add('dim-offline');
@@ skipping 357 matching lines @@
           selection.bytes += filesystem.size;
         }
       }
 
       this.dispatchEvent(new cr.Event('selection-summarized'));
     }.bind(this));
 
     if (this.isOnGData()) {
       this.metadataCache_.get(selection.urls, 'gdata', function(props) {
         selection.allGDataFilesPresent =
-            props.filter(function(p) {return !p.availableOffline}).length == 0;
+            props.filter(function(p) {return p && !p.availableOffline}).length == 0;

[dgozman, 2012/05/16 14:31:46]

- long line
- this actually should be |!(p && p.availableOffline)|

         this.updateOkButton_();
       }.bind(this));
     }
   };
 
   /**
     * Check if all the files in the current selection are available. The only
     * case when files might be not available is when the selection contains
     * uncached GData files and the browser is offline.
     * @return {boolean} True if all files in the current selection are
@@ skipping 411 matching lines @@
   };
 
   FileManager.prototype.isOffline = function() {
     return this.networkConnectionState_ && !this.networkConnectionState_.online;
   };
 
   FileManager.prototype.isOnReadonlyDirectory = function() {
     return this.directoryModel_.isReadOnly();
   };
 
-  /**
-   * Event handler called when some volume was mounted or unmouted.
-   */
-  FileManager.prototype.onMountCompleted_ = function(event) {
-    var changeDirectoryTo = null;
-
-    if (event && event.mountType == 'gdata') {
-      var mounted = (event.eventType == 'mount');
-      metrics.recordInterval('Load.GData');
-      console.log('GData ' + (mounted ? 'mounted' : 'unmounted'));
-      if (mounted && event.status == 'success') {
-        this.gdataMounted_ = true;
-        this.gdataMountInfo_ = {
-          'mountPath': event.mountPath,
-          'sourcePath': event.sourcePath,
-          'mountType': event.mountType,
-          'mountCondition': event.status
-        };
-        // Not calling clearGDataLoadingTimer_ here because we want to keep
-        // "Loading Google Docs" message until the directory loads. It is OK if
-        // the timer fires after the mount because onDirectoryChanged_ will hide
-        // the unmounted panel.
-        if (this.setupCurrentDirectoryPostponed_) {
-          this.setupCurrentDirectoryPostponed_(false /* execute */);
-        } else if (this.isOnGData() &&
-                   this.directoryModel_.getCurrentDirEntry().unmounted) {
-          // We are currently on an unmounted GData directory, force a rescan.
-          changeDirectoryTo = this.directoryModel_.getCurrentRootPath();
-        }
-      } else {
-        this.gdataMounted_ = false;
-        this.gdataMountInfo_ = null;
-        this.clearGDataLoadingTimer_();
-        this.onGDataUnreachable_('GData ' +
-            (mounted ? ('mount failed: ' + event.status) : 'unmounted'));
-        if (this.setupCurrentDirectoryPostponed_) {
-          this.setupCurrentDirectoryPostponed_(true /* cancel */);
-          // Change to unmounted GData root.
-          changeDirectoryTo = '/' + DirectoryModel.GDATA_DIRECTORY;
-        }
+  // TODO(serya): close tab on unmount.
+  FileManager.prototype.onVolumeUnmounted_ = function(event) {
+    if (event.mountPath == dm.getCurrentRootPath()) {
+      if (this.params_.mountTriggered && !event.requested) {
+        // TODO(serya): What if 2 USB sticks plugged?
+        chrome.tabs.getCurrent(function(tab) {
+          chrome.tabs.remove(tab.id);
+        });
       }
     }
-
-    chrome.fileBrowserPrivate.getMountPoints(function(mountPoints) {
-      this.setMountPoints_(mountPoints);
-
-      if (event.eventType == 'mount') {
-        // Mount request finished - remove it.
-        // Currently we only request mounts for archive files.
-        var index = this.mountRequests_.indexOf(event.sourcePath);
-        if (index != -1) {
-          this.mountRequests_.splice(index, 1);
-          if (event.status == 'success') {
-            // Successful mount requested from this tab, go to the drive root.
-            changeDirectoryTo = event.mountPath;
-          } else {
-            // Request initiated from this tab failed, report the error.
-            var fileName = event.sourcePath.split('/').pop();
-            this.alert.show(
-                strf('ARCHIVE_MOUNT_FAILED', fileName, event.status));
-          }
-        }
-      }
-
-      if (event.eventType == 'unmount') {
-        // Unmount request finished - remove it.
-        var index = this.unmountRequests_.indexOf(event.mountPath);
-        if (index != -1) {
-          this.unmountRequests_.splice(index, 1);
-          if (event.status != 'success')
-            this.alert.show(strf('UNMOUNT_FAILED', event.status));
-        }
-
-        if (event.status == 'success' &&
-            event.mountPath == this.directoryModel_.getCurrentRootPath()) {
-          if (this.params_.mountTriggered && index == -1) {
-            // This device mount was the reason this File Manager instance was
-            // created. Now the device is unmounted from another instance
-            // or the user removed the device manually. Close this instance.
-            // window.close() sometimes doesn't work.
-            chrome.tabs.getCurrent(function(tab) {
-              chrome.tabs.remove(tab.id);
-            });
-            return;
-          }
-          // Current directory just unmounted. Move to the 'Downloads'.
-          changeDirectoryTo = this.directoryModel_.getDefaultDirectory();
-        }
-      }
-
-      // Even if something failed root list should be rescanned.
-      // Failed mounts can "give" us new devices which might be formatted,
-      // so we have to refresh root list then.
-      this.directoryModel_.updateRoots(function() {
-        if (changeDirectoryTo) {
-          this.directoryModel_.changeDirectory(changeDirectoryTo);
-        }
-      }.bind(this), this.gdataMounted_);
-    }.bind(this));
   };
 
   /**
    * Event handler called when some internal task should be executed.
    */
   FileManager.prototype.onFileTaskExecute_ = function(id, urls) {
     if (id == 'play') {
       var position = 0;
       if (urls.length == 1) {
         // If just a single audio file is selected pass along every audio file
         // in the directory.
         var selectedUrl = urls[0];
         urls = this.getAllUrlsInCurrentDirectory_().filter(FileType.isAudio);
         position = urls.indexOf(selectedUrl);
       }
       chrome.mediaPlayerPrivate.play(urls, position);
     } else if (id == 'mount-archive') {
       var self = this;
+      var tracker = this.directoryModel_.createDirectoryChangeTracker();
+      tracker.start();
       this.resolveSelectResults_(urls, function(urls) {
         for (var index = 0; index < urls.length; ++index) {
-          // Url in MountCompleted event won't be escaped, so let's make sure
-          // we don't use escaped one in mountRequests_.
-          var unescapedUrl = unescape(urls[index]);
-          chrome.fileBrowserPrivate.addMount(unescapedUrl, 'file', {},
-            function(sourcePath) {
-              self.mountRequests_.push(sourcePath);
+          var path = /^filesystem:[\w-]*:\/\/[\w]*\/external(\/.*)$/.
+              exec(urls[index])[1];
+          if (!path)
+            continue;
+          path = decodeURIComponent(path);
+          self.volumeManager_.mountArchive(path, function(mountPath) {
+            console.log('Mounted at: ', mountPath);
+            tracker.stop();
+            if (!tracker.hasChanged)
+              self.directoryModel_.changeDirectory(mountPath);
+          }, function(error) {
+            tracker.stop();
+            self.alert.show(strf('ARCHIVE_MOUNT_FAILED',
+                                 error.fileName, error.message));
           });
         }
       });
     } else if (id == 'format-device') {
       this.confirm.show(str('FORMATTING_WARNING'), function() {
         chrome.fileBrowserPrivate.formatDevice(urls[0]);
       });
     } else if (id == 'gallery') {
       this.openGallery_(urls);
     } else if (id == 'view-pdf' || id == 'view-in-browser' ||
         id == 'install-crx' || id == 'open-hosted') {
       chrome.fileBrowserPrivate.viewFiles(urls, 'default', function(success) {
         if (!success)
           console.error('chrome.fileBrowserPrivate.viewFiles failed', urls);
       });
     }
   };
 
-  FileManager.prototype.getDeviceNumber = function(entry) {
-    if (!entry.isDirectory) return undefined;
-    for (var i = 0; i < this.mountPoints_.length; i++) {
-      if (normalizeAbsolutePath(entry.fullPath) ==
-          normalizeAbsolutePath(this.mountPoints_[i].mountPath)) {
-        return i;
-      }
-    }
-    return undefined;
-  };
-
   /**
    * Show a modal-like file viewer/editor on top of the File Manager UI.
    *
    * @param {HTMLElement} popup Popup element.
    * @param {function} closeCallback Function to call after the popup is closed.
    */
   FileManager.prototype.openFilePopup_ = function(popup, closeCallback) {
     this.closeFilePopup_();
     this.filePopup_ = popup;
     this.filePopupCloseCallback_ = closeCallback;
@@ skipping 577 matching lines @@
       return true;
     }
     if (!this.okButton_.disabled) {
       this.onOk_();
       return true;
     }
     return false;
   };
 
   FileManager.prototype.onDirectoryAction = function(entry) {
-    var deviceNumber = this.getDeviceNumber(entry);
-    if (deviceNumber != undefined &&
-        this.mountPoints_[deviceNumber].mountCondition ==
-        'unknown_filesystem') {
+    var mountCondition = this.volumeManager_.getMountCondition(entry.fullPath);
+    if (mountCondition == 'unknown_filesystem') {
       return this.showButter(str('UNKNOWN_FILESYSTEM_WARNING'));
-    } else if (deviceNumber != undefined &&
-               this.mountPoints_[deviceNumber].mountCondition ==
-               'unsupported_filesystem') {
+    } else if (mountCondition == 'unsupported_filesystem') {
       return this.showButter(str('UNSUPPORTED_FILESYSTEM_WARNING'));
     } else {
       return this.directoryModel_.changeDirectory(entry.fullPath);
     }
   };
 
   /**
    * Show or hide the "Low disk space" warning.
    * @param {boolean} show True if the box need to be shown.
    */
@@ skipping 53 matching lines @@
 
     // Sometimes we rescan the same directory (when mounting GData lazily first,
     // then for real). Do not update the location then.
     if (event.newDirEntry.fullPath != event.previousDirEntry.fullPath) {
       this.updateLocation_(event.initial, event.newDirEntry.fullPath);
     }
 
     this.checkFreeSpace_(this.getCurrentDirectory());
 
     this.updateTitle_();
-
-    if (this.filesystemObserverId_)
-      this.metadataCache_.removeObserver(this.filesystemObserverId_);
-    if (this.gdataObserverId_)
-      this.metadataCache_.removeObserver(this.gdataObserverId_);
-
-    this.filesystemObserverId_ = this.metadataCache_.addObserver(
-        this.directoryModel_.getCurrentDirEntry(),
-        MetadataCache.CHILDREN,
-        'filesystem',
-        this.updateMetadataInUI_.bind(this, 'filesystem'));
-
-    if (this.isOnGData()) {
-      this.gdataObserverId_ = this.metadataCache_.addObserver(
-          this.directoryModel_.getCurrentDirEntry(),
-          MetadataCache.CHILDREN,
-          'gdata',
-          this.updateMetadataInUI_.bind(this, 'gdata'));
-    }
-
-    var self = this;
-
-    if (this.watchedDirectoryUrl_) {
-      if (this.watchedDirectoryUrl_ != event.previousDirEntry.toURL()) {
-        console.warn('event.previousDirEntry does not match File Manager state',
-            event, this.watchedDirectoryUrl_);
-      }
-      chrome.fileBrowserPrivate.removeFileWatch(this.watchedDirectoryUrl_,
-          function(result) {
-            if (!result) {
-              console.log('Failed to remove file watch');
-            }
-          });
-      this.watchedDirectoryUrl_ = null;
-    }
-
-    if (event.newDirEntry.fullPath != '/' && !event.newDirEntry.unmounted) {
-      this.watchedDirectoryUrl_ = event.newDirEntry.toURL();
-      chrome.fileBrowserPrivate.addFileWatch(this.watchedDirectoryUrl_,
-        function(result) {
-          if (!result) {
-            console.log('Failed to add file watch');
-            this.watchedDirectoryUrl_ = null;
-          }
-        }.bind(this));
-    }
-
-    if (event.newDirEntry.unmounted)
-      this.dialogContainer_.setAttribute('unmounted', true);
-    else {
-      this.dialogContainer_.removeAttribute('unmounted');
-      // Need to resize explicitly because the list container had display:none.
-      this.onResize_();
-    }
-
-    if (this.isOnGData()) {
-      this.dialogContainer_.setAttribute('gdata', true);
-      if (event.newDirEntry.unmounted) {
-        this.initGData_(true /* directory changed */);
-      }
-    } else {
-      this.dialogContainer_.removeAttribute('gdata');
-    }
+    this.updateGDataStatus_('directory-change');
   };
 
   FileManager.prototype.findListItemForEvent_ = function(event) {
     return this.findListItemForNode_(event.srcElement);
   };
 
   FileManager.prototype.findListItemForNode_ = function(node) {
     var item = this.currentList_.getListItemAncestor(node);
     // TODO(serya): list should check that.
     return item && this.currentList_.isItem(item) ? item : null;
   };
 
   /**
    * Unload handler for the page.  May be called manually for the file picker
    * dialog, because it closes by calling extension API functions that do not
    * return.
    */
   FileManager.prototype.onUnload_ = function() {
-    if (this.watchedDirectoryUrl_) {
-      chrome.fileBrowserPrivate.removeFileWatch(
-          this.watchedDirectoryUrl_,
-          function(result) {
-            if (!result) {
-              console.log('Failed to remove file watch');
-            }
-          });
-      this.watchedDirectoryUrl_ = null;
-    }
-  };
-
-  FileManager.prototype.onFileChanged_ = function(event) {
-    // We receive a lot of events even in folders we are not interested in.
-    if (encodeURI(event.fileUrl) == this.getCurrentDirectoryURL())
-      this.directoryModel_.rescanLater();
+    this.fileWatcher_.stop();
   };
 
   FileManager.prototype.initiateRename_ = function() {
     var item = this.currentList_.ensureLeadItemExists();
     if (!item)
       return;
     var label = item.querySelector('.filename-label');
     var input = this.renameInput_;
 
     input.value = label.textContent;
@@ skipping 905 matching lines @@
 
     this.directoryModel_.addEventListener('scan-completed', maybeShowBanner);
     this.directoryModel_.addEventListener('rescan-completed', maybeShowBanner);
 
     var style = this.document_.createElement('link');
     style.rel = 'stylesheet';
     style.href = 'css/gdrive_welcome.css';
     this.document_.head.appendChild(style);
   };
 })();
+