[File Manager] Add/remove Google Drive folder in the open File Manager when Drive enabled/disabled …

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 353 matching lines @@
     // 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.networkConnectionState_ = null;
+    var queryGDataPreferences = function() {
+      chrome.fileBrowserPrivate.getGDataPreferences(
+          this.onGDataPreferencesChanged_.bind(this));
+    }.bind(this);
+    queryGDataPreferences();
+    chrome.fileBrowserPrivate.onGDataPreferencesChanged.
+        addListener(queryGDataPreferences);
+
     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_()) {
@@ skipping 11 matching lines @@
         this.setupCurrentDirectory_(
             invokeHandler, false /* blankWhileOpeningAFile */);
       }.bind(this);
       this.directoryModel_.addEventListener('directory-changed',
           this.setupCurrentDirectoryPostponed_);
     } else {
       this.setupCurrentDirectory_(
           invokeHandler, true /* blankWhileOpeningAFile */);
     }
 
+    if (this.isGDataEnabled())
+      this.setupGDataWelcome_();
+
     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 156 matching lines @@
       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);
-
     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');
 
     this.filePopup_ = null;
 
     this.dialogDom_.querySelector('#search-box').addEventListener(
         'input', this.onSearchBoxUpdate_.bind(this));
 
     // Populate the static localized strings.
     i18nTemplate.process(this.document_, localStrings.templateData);
   };
 
   /**
    * Constructs table and grid (heavy operation).
    **/
   FileManager.prototype.initFileList_ = function() {
     // Always sharing the data model between the detail/thumb views confuses
     // them.  Instead we maintain this bogus data model, and hook it up to the
     // view that is not in use.
     this.emptyDataModel_ = new cr.ui.ArrayDataModel([]);
     this.emptySelectionModel_ = new cr.ui.ListSelectionModel();
 
-    var sigleSelection =
+    var singleSelection =
         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(),
+        singleSelection,
         this.metadataCache_);
 
-    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);
     });
     dataModel.setCompareFunction('modificationTime',
                                  this.compareMtime_.bind(this));
     dataModel.setCompareFunction('size',
@@ skipping 32 matching lines @@
       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);
+    }, this.getGDataAccessMode_());
   };
 
   /**
    * @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');
@@ skipping 36 matching lines @@
 
   FileManager.prototype.clearGDataLoadingTimer_ = function(message) {
     if (this.gdataLoadingTimer_) {
       clearTimeout(this.gdataLoadingTimer_);
       this.gdataLoadingTimer_ = null;
     }
   };
 
   FileManager.prototype.onGDataUnreachable_ = function(message) {
     console.warn(message);
+    this.gdataMounted_ = false;
+    this.gdataMountInfo_ = null;
+    this.clearGDataLoadingTimer_();
     if (this.isOnGData()) {
       this.unmountedPanel_.removeAttribute('loading');
       this.unmountedPanel_.setAttribute('error', true);
       this.unmountedPanel_.setAttribute('retry', true);
     }
   };
 
   FileManager.prototype.initGDataUnmountedPanel_ = function() {
     if (this.unmountedPanel_.firstElementChild)
       return;
@@ skipping 1579 matching lines @@
       setVisibility('visible');
       self.previewThumbnails_.textContent = '';
       self.onResize_();
     }
 
     function setVisibility(visibility) {
       panel.setAttribute('visibility', visibility);
     }
   };
 
-  FileManager.isGDataEnabled = function() {
-    return str('ENABLE_GDATA') == '1';
+  FileManager.prototype.isGDataEnabled = function() {
+    return this.getGDataPreferences_().driveEnabled;
+  };
+
+  FileManager.prototype.updateGDataAccess_ = function() {
+    if (this.isGDataEnabled())
+      this.setupGDataWelcome_();
+    else
+      this.cleanupGDataWelcome_();
+
+    var changeDirectory = !this.isGDataEnabled() && this.isOnGData();
+
+    this.directoryModel_.updateRoots(function() {
+      if (changeDirectory)
+        this.directoryModel_.changeDirectory(
+            this.directoryModel_.getDefaultDirectory());
+    }.bind(this), this.getGDataAccessMode_());
+  };
+
+  FileManager.prototype.getGDataAccessMode_ = function() {
+     if (!this.isGDataEnabled())
+       return DirectoryModel.GDATA_ACCESS_DISABLED;
+     if (!this.gdataMounted_)
+       return DirectoryModel.GDATA_ACCESS_LAZY;
+     return DirectoryModel.GDATA_ACCESS_FULL;
   };
 
   FileManager.prototype.isOnGData = function() {
     return this.directoryModel_ &&
         this.directoryModel_.getCurrentRootPath() ==
             '/' + DirectoryModel.GDATA_DIRECTORY;
   };
 
   FileManager.prototype.isStartingOnGData_ = function() {
     var path = this.getPathFromUrlOrParams_();
     return path &&
-        FileManager.isGDataEnabled() &&
+        this.isGDataEnabled() &&
         DirectoryModel.getRootType(path) == DirectoryModel.RootType.GDATA;
   };
 
   FileManager.prototype.getMetadataProvider = function() {
     return this.metadataProvider_;
   };
 
   /**
    * Callback called when tasks for selected files are determined.
    * @param {Object} selection Selection is passed here, since this.selection
@@ skipping 212 matching lines @@
           }.bind(this));
           return;
         }
         callback(urls);
       }.bind(this));
     } else {
       callback(urls);
     }
   };
 
+  FileManager.prototype.getGDataPreferences_ = function() {
+    return this.gdataPreferences_ ||
+      { driveEnabled: str('ENABLE_GDATA') == '1' };
+  };
+
+  FileManager.prototype.getNetworkConnectionState_ = function() {
+    return this.networkConnectionState_ || {};
+  };
+
   FileManager.prototype.onNetworkConnectionChanged_ = function(state) {
-    console.log(state.online, state.type);
+    console.log(state.online ? 'online' : 'offline', state.type);
     this.networkConnectionState_ = state;
     this.directoryModel_.setOffline(!state.online);
     this.updateConnectionState_();
   };
 
   FileManager.prototype.onGDataPreferencesChanged_ = function(preferences) {
+    var gdataWasEnabled = this.isGDataEnabled();
     this.gdataPreferences_ = preferences;
+    if (gdataWasEnabled != this.isGDataEnabled())
+      this.updateGDataAccess_();
+
     if (preferences.cellularDisabled)
       this.syncButton.setAttribute('checked', 'checked');
     else
       this.syncButton.removeAttribute('checked');
 
     if (!preferences.hostedFilesDisabled)
       this.hostedButton.setAttribute('checked', 'checked');
     else
       this.hostedButton.removeAttribute('checked');
 
     this.updateConnectionState_();
   };
 
   FileManager.prototype.updateConnectionState_ = function() {
     if (this.isOffline())
       this.dialogContainer_.setAttribute('connection', 'offline');
     else if (this.isOnMeteredConnection())
       this.dialogContainer_.setAttribute('connection', 'metered');
     else
       this.dialogContainer_.removeAttribute('connection');
   };
 
   FileManager.prototype.isOnMeteredConnection = function() {
-    return this.gdataPreferences_ &&
-        this.gdataPreferences_.cellularDisabled &&
-        this.networkConnectionState_ &&
-        this.networkConnectionState_.online &&
-        this.networkConnectionState_.type == 'cellular';
+    return this.getGDataPreferences_().cellularDisabled &&
+        this.getNetworkConnectionState_().online &&
+        this.getNetworkConnectionState_().type == 'cellular';
   };
 
   FileManager.prototype.isOffline = function() {
-    return this.networkConnectionState_ && !this.networkConnectionState_.online;
+    return !this.getNetworkConnectionState_().online;
   };
 
   FileManager.prototype.isOnReadonlyDirectory = function() {
     return this.directoryModel_.isReadOnly();
   };
 
   /**
    * Event handler called when some volume was mounted or unmouted.
    */
   FileManager.prototype.onMountCompleted_ = function(event) {
@@ skipping 16 matching lines @@
         // 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;
         }
       }
     }
 
@@ skipping 44 matching lines @@
         }
       }
 
       // 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), this.getGDataAccessMode_());
     }.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) {
@@ skipping 772 matching lines @@
       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 */);
+        if (event.newDirEntry.error)
+          this.onGDataUnreachable_('File error ' + event.newDirEntry.error);
+        else
+          this.initGData_(true /* directory changed */);
       }
     } else {
       this.dialogContainer_.removeAttribute('gdata');
     }
   };
 
   FileManager.prototype.findListItemForEvent_ = function(event) {
     return this.findListItemForNode_(event.srcElement);
   };
 
@@ skipping 835 matching lines @@
 
       handleSplitterDragEnd: function(e) {
         Splitter.prototype.handleSplitterDragEnd.apply(this, arguments);
         this.ownerDocument.documentElement.classList.remove('col-resize');
       }
     };
 
     customSplitter.decorate(splitterElement);
   };
 
-  FileManager.prototype.initGDataWelcomeBanners_ = function() {
+  FileManager.prototype.setupGDataWelcome_ = function() {
+    this.gdataWelcomeHandler_ = this.createGDataWelcomeHandler_();
+    if (this.gdataWelcomeHandler_) {
+      this.directoryModel_.addEventListener('scan-completed',
+          this.gdataWelcomeHandler_);
+      this.directoryModel_.addEventListener('rescan-completed',
+          this.gdataWelcomeHandler_);
+    }
+  };
+
+  FileManager.prototype.cleanupGDataWelcome_ = function() {
+    this.showGDataWelcome_('none');
+
+    if (this.gdataWelcomeHandler_) {
+      this.directoryModel_.removeEventListener('scan-completed',
+          this.gdataWelcomeHandler_);
+      this.directoryModel_.removeEventListener('rescan-completed',
+          this.gdataWelcomeHandler_);
+      this.gdataWelcomeHandler_ = null;
+    }
+  };
+
+  FileManager.prototype.showGDataWelcome_ = function(type) {
+    if (this.dialogContainer_.getAttribute('gdrive-welcome') != type) {
+      this.dialogContainer_.setAttribute('gdrive-welcome', type);
+      this.requestResize_(200);  // Resize only after the animation is done.
+    }
+  };
+
+  FileManager.prototype.createGDataWelcomeHandler_ = function() {
     var WELCOME_HEADER_COUNTER_KEY = 'gdataWelcomeHeaderCounter';
     var WELCOME_HEADER_COUNTER_LIMIT = 5;
 
     function getHeaderCounter() {
       return parseInt(localStorage[WELCOME_HEADER_COUNTER_KEY] || '0');
     }
 
     if (getHeaderCounter() >= WELCOME_HEADER_COUNTER_LIMIT)
-      return;
+      return null;
 
     function createDiv(className, parent) {
       var div = parent.ownerDocument.createElement('div');
       div.className = className;
       parent.appendChild(div);
       return div;
     }
 
     var self = this;
 
-    var RESIZE_DELAY = 200; // Resize only after the animation is done.
+    function showBanner(type, messageId) {
+      if (!self.dialogContainer_.hasAttribute('gdrive-welcome-style')) {
+        self.dialogContainer_.setAttribute('gdrive-welcome-style', true);
+        var style = self.document_.createElement('link');
+        style.rel = 'stylesheet';
+        style.href = 'css/gdrive_welcome.css';
+        self.document_.head.appendChild(style);
+        style.onload = function() { showBanner(type, messageId) };
+        return;
+      }
 
-    function showBanner(type, messageId) {
-      self.dialogContainer_.setAttribute('gdrive-welcome', type);
-      self.requestResize_(RESIZE_DELAY);
+      self.showGDataWelcome_(type);
 
       var container = self.dialogDom_.querySelector('.gdrive-welcome.' + type);
       if (container.firstElementChild)
         return;  // Do not re-create.
 
       var wrapper = createDiv('gdrive-welcome-wrapper', container);
       createDiv('gdrive-welcome-icon', wrapper);
 
       var close = createDiv('cr-dialog-close', wrapper);
       close.addEventListener('click', closeBanner);
@@ skipping 16 matching lines @@
 
       var dismiss = createDiv('gdrive-welcome-dismiss plain-link', links);
       dismiss.textContent = str('GDATA_WELCOME_DISMISS');
       dismiss.addEventListener('click', closeBanner);
     }
 
     var previousDirWasOnGData = false;
 
     function maybeShowBanner() {
       if (!self.isOnGData()) {
-        self.dialogContainer_.removeAttribute('gdrive-welcome');
-        self.requestResize_(RESIZE_DELAY);
+        self.showGDataWelcome_('none');
         previousDirWasOnGData = false;
         return;
       }
 
       var counter = getHeaderCounter();
 
       if (self.directoryModel_.getFileList().length == 0 && counter == 0) {
         // Only show the full page banner if the header banner was never shown.
         // Do not increment the counter.
         showBanner('page', 'GDATA_WELCOME_TEXT_LONG');
       } else if (counter < WELCOME_HEADER_COUNTER_LIMIT) {
         // We do not want to increment the counter when the user navigates
         // between different directories on GDrive, but we increment the counter
         // once anyway to prevent the full page banner from showing.
         if (!previousDirWasOnGData || counter == 0)
           localStorage[WELCOME_HEADER_COUNTER_KEY] = ++counter;
         showBanner('header', 'GDATA_WELCOME_TEXT_SHORT');
       } else {
         closeBanner();
       }
       previousDirWasOnGData = true;
     }
 
     function closeBanner() {
-      self.directoryModel_.removeEventListener('scan-completed',
-          maybeShowBanner);
-      self.directoryModel_.removeEventListener('rescan-completed',
-          maybeShowBanner);
-
-      self.dialogContainer_.removeAttribute('gdrive-welcome');
-      self.requestResize_(RESIZE_DELAY);
-
+      self.cleanupGDataWelcome_();
       // Stop showing the welcome banner.
       localStorage[WELCOME_HEADER_COUNTER_KEY] = WELCOME_HEADER_COUNTER_LIMIT;
     }
 
-    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);
+    return maybeShowBanner;
   };
 })();