Postpone connecting to GData even more, provide progress indication.

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.
 
 // Setting the src of an img to an empty string can crash the browser, so we
 // use an empty 1x1 gif instead.
 
 /**
  * FileManager constructor.
  *
@@ skipping 536 matching lines @@
     chrome.fileBrowserPrivate.onMountCompleted.addListener(
         this.onMountCompleted_.bind(this));
 
     chrome.fileBrowserPrivate.onFileChanged.addListener(
         this.onFileChanged_.bind(this));
 
     // The list of callbacks to be invoked during the directory rescan after
     // all paste tasks are complete.
     this.pasteSuccessCallbacks_ = [];
 
-    this.setupCurrentDirectory_();
+    var path = this.getPathFromUrlOrParams_();
+    if (path &&
+        DirectoryModel.getRootType(path) == DirectoryModel.RootType.GDATA) {
+      // 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 */);
+      // Will be nulled out if a directory change happens before it fires.
+      this.setupGDataDirectoryAfterMount_ = function() {

[dgozman, 2012/03/28 10:28:30]

Can we do the same trick as in DirectoryModel: add listener and then remove it?

[Vladislav Kaznacheev, 2012/03/28 14:00:57]

Done.

+        this.setupGDataDirectoryAfterMount_ = null;
+        this.setupCurrentDirectory_(false /* blankWhileLoading */);
+      }.bind(this);
+    } else {
+      this.setupCurrentDirectory_(true /* blankWhileLoading */);
+    }
 
     this.summarizeSelection_();
 
     var sortField =
         window.localStorage['sort-field-' + this.dialogType_] || 'cachedMtime_';
     var sortDirection =
         window.localStorage['sort-direction-' + this.dialogType_] || 'desc';
     this.directoryModel_.fileList.sort(sortField, sortDirection);
 
     this.refocus();
@@ skipping 62 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.Table.decorate(this.table_);
     cr.ui.Grid.decorate(this.grid_);
 
     this.downloadsWarning_ =
         this.dialogDom_.querySelector('.downloads-warning');
     var html = util.htmlUnescape(str('DOWNLOADS_DIRECTORY_WARNING'));
     this.downloadsWarning_.lastElementChild.innerHTML = html;
     var link = this.downloadsWarning_.querySelector('a');
     link.addEventListener('click', this.onDownloadsWarningClick_.bind(this));
@@ skipping 145 matching lines @@
     this.rootsList_.itemConstructor = function(entry) {
       return self.renderRoot_(entry);
     };
 
     this.rootsList_.selectionModel = this.directoryModel_.rootsListSelection;
 
     // TODO(dgozman): add "Add a drive" item.
     this.rootsList_.dataModel = this.directoryModel_.rootsList;
     this.directoryModel_.updateRoots(function() {
         self.rootsList_.endBatchUpdates();
-    });
-  };
-
-  FileManager.prototype.initGData_ = function() {
-    metrics.startInterval('Load.GData');
-    chrome.fileBrowserPrivate.addMount('', 'gdata', {});
-    if (this.gdataMountTimer_) {
-      clearTimeout(this.gdataMountTimer_);
-    }
-    this.gdataMountTimer_ = setTimeout(function() {
-      this.gdataMountTimer_ = null;
-      if (this.isOnGData()) {
-        // TODO(kaznacheev): show the message in the file list space.
-        this.alert.show('Could not connect to GData');
-      }
-    }.bind(this), 10 * 1000);
+    }, 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');
+      this.unmountedPanel_.removeAttribute('loading');
+      setTimeout(function() {
+        if (this.gdataLoadingTimer_) {  // Still loading.
+          this.unmountedPanel_.setAttribute('loading', true);
+        }
+      }.bind(this), 500);  // Avoid flicker if the mount is quick.
+    } else {
+      // When retrying we do not hide "Retry" and "Learn more".
+      this.unmountedPanel_.setAttribute('loading', true);
+    }
+
+    if (this.gdataLoadingTimer_)

[dgozman, 2012/03/28 10:28:30]

How is this possible?

[Vladislav Kaznacheev, 2012/03/28 14:00:57]

Added a comment:
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

On 2012/03/28 10:28:30, dgozman wrote:

+      return;
+
+    metrics.startInterval('Load.GData');
+    chrome.fileBrowserPrivate.addMount('', 'gdata', {});
+
+    this.gdataLoadingTimer_ = setTimeout(function() {
+          this.gdataLoadingTimer_ = null;
+          this.onGDataUnreachable_('GData load timeout');
+        }.bind(this),
+        10 * 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);
+    }
+  };
+
+  FileManager.prototype.initGDataUnmountedPanel_ = function() {
+    if (this.unmountedPanel_.firstElementChild)
+      return;
+
+    var loading = this.document_.createElement('div');
+    loading.className = 'gdata loading';
+    loading.textContent = strf('GDATA_LOADING', str('GDATA_PRODUCT_NAME'));
+    this.unmountedPanel_.appendChild(loading);
+
+    var error = this.document_.createElement('div');
+    error.className = 'gdata error';
+    error.textContent = strf('GDATA_CANNOT_REACH', str('GDATA_PRODUCT_NAME'));
+    this.unmountedPanel_.appendChild(error);
+
+    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);
+
+    var learnMore = this.document_.createElement('div');
+    learnMore.className = 'gdata learn-more';
+    this.unmountedPanel_.appendChild(learnMore);
+
+    var learnMoreLink = this.document_.createElement('a');
+    learnMoreLink.textContent = str('GDATA_LEARN_MORE');
+    learnMoreLink.href = 'javascript://';  // TODO: Set a proper link URL.
+    learnMoreLink.className = 'gdata learn-more';
+    learnMore.appendChild(learnMoreLink);
+  };
+
+  /**
    * Get the icon type for a given Entry.
    *
    * @param {Entry} entry An Entry subclass (FileEntry or DirectoryEntry).
    * @return {string}
    */
   FileManager.prototype.getIconType = function(entry) {
     if (!('cachedIconType_' in entry))
       entry.cachedIconType_ = this.computeIconType_(entry);
     return entry.cachedIconType_;
   };
@@ skipping 677 matching lines @@
     this.rootsList_.redraw();
     this.truncateBreadcrumbs_();
   };
 
   FileManager.prototype.resolvePath = function(
       path, resultCallback, errorCallback) {
     return util.resolvePath(this.filesystem_.root, path, resultCallback,
                             errorCallback);
   };
 
+  FileManager.prototype.getPathFromUrlOrParams_ = function() {
+    return location.hash ?  // Location hash has the highest priority.
+        decodeURI(location.hash.substr(1)) :
+        this.params_.defaultPath;
+  };
+
   /**
    * 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} blankWhileLoading
    */
-  FileManager.prototype.setupCurrentDirectory_ = function() {
+  FileManager.prototype.setupCurrentDirectory_ = function(blankWhileLoading) {
+    var path = this.getPathFromUrlOrParams_();
 
-    if (location.hash) {
-      // Location hash has the highest priority.
-      var path = decodeURI(location.hash.substr(1));
+    if (!path) {
+      this.directoryModel_.setupDefaultPath();

[dgozman, 2012/03/28 10:28:30]

We ignore blankWhileLoading since default path is never gdata?
This makes generic name blankWhileLoading really pointless.
And a comment would be nice anyway.

[Vladislav Kaznacheev, 2012/03/28 14:00:57]

It only affects the case when we (think that we) are opening 
 a file, which is never the case with the default path. I renamed the parameter
to blankWhileOpeningAFile. On 2012/03/28 10:28:30, dgozman wrote:

+      return;
+    }
 
-      // In the FULL_PAGE mode if the path points to a file we might have
-      // to invoke a task after selecting it.
-      if (this.dialogType_ == FileManager.DialogType.FULL_PAGE) {
-        // To prevent the file list flickering for a moment before the action
-        // is executed we hide it under a white div.
-        var shade = this.document_.createElement('div');
+    // 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 (location.hash &&
+        this.dialogType_ == FileManager.DialogType.FULL_PAGE) {
+      // To prevent the file list flickering for a moment before the action
+      // is executed we hide it under a white div.
+      var shade;
+      if (blankWhileLoading) {
+        shade = this.document_.createElement('div');
         shade.className = 'overlay-pane';
         shade.style.backgroundColor = 'white';
         this.document_.body.appendChild(shade);
-        function removeShade() { shade.parentNode.removeChild(shade) }
-
-        // Keep track of whether the path is identified as an existing leaf
-        // node.  Note that onResolve is guaranteed to be called (exactly once)
-        // before onLoadedActivateLeaf.
-        var foundLeaf = true;
-        function onResolve(baseName, leafName, exists) {
-          if (!exists || leafName == '') {
-            // Non-existent file or a directory. Remove the shade immediately.
-            removeShade();
-            foundLeaf = false;
-          }
-        }
-
-        // TODO(kaznacheev): refactor dispatchDefaultTask to accept an array
-        // of urls instead of a selection. This will remove the need to wait
-        // until the selection is done.
-        var self = this;
-        function onLoadedActivateLeaf() {
-          if (foundLeaf) {
-            // There are 3 ways we can get here:
-            // 1. Invoked from file_manager_util::ViewFile. This can only
-            //    happen for 'gallery' and 'mount-archive' actions.
-            // 2. Reloading a Gallery page. Must be an image or a video file.
-            // 3. A user manually entered a URL pointing to a file.
-            if (FileType.isImageOrVideo(path)) {
-              self.dispatchInternalTask_('gallery', self.selection.urls);
-            } else if (FileType.getMediaType(path) == 'archive') {
-              self.dispatchInternalTask_('mount-archive', self.selection.urls);
-            } else {
-              // Manually entered path, do nothing, remove the shade ASAP.
-              removeShade();
-              return;
-            }
-            setTimeout(removeShade, 1000);
-          }
-        }
-        this.directoryModel_.setupPath(path, onLoadedActivateLeaf, onResolve);
-
-        return;
+      }
+      function removeShade() {
+        if (shade)
+          shade.parentNode.removeChild(shade);
       }
 
-      this.directoryModel_.setupPath(path);
+      // Keep track of whether the path is identified as an existing leaf
+      // node.  Note that onResolve is guaranteed to be called (exactly once)
+      // before onLoadedActivateLeaf.
+      var foundLeaf = true;
+      function onResolve(baseName, leafName, exists) {
+        if (!exists || leafName == '') {
+          // Non-existent file or a directory. Remove the shade immediately.
+          removeShade();
+          foundLeaf = false;
+        }
+      }
+
+      // TODO(kaznacheev): refactor dispatchDefaultTask to accept an array
+      // of urls instead of a selection. This will remove the need to wait
+      // until the selection is done.
+      var self = this;
+      function onLoadedActivateLeaf() {
+        if (foundLeaf) {
+          // There are 3 ways we can get here:
+          // 1. Invoked from file_manager_util::ViewFile. This can only
+          //    happen for 'gallery' and 'mount-archive' actions.
+          // 2. Reloading a Gallery page. Must be an image or a video file.
+          // 3. A user manually entered a URL pointing to a file.
+          if (FileType.isImageOrVideo(path)) {
+            self.dispatchInternalTask_('gallery', self.selection.urls);
+          } else if (FileType.getMediaType(path) == 'archive') {
+            self.dispatchInternalTask_('mount-archive', self.selection.urls);
+          } else {
+            // Manually entered path, do nothing, remove the shade ASAP.
+            removeShade();
+            return;
+          }
+          setTimeout(removeShade, 1000);
+        }
+      }
+      this.directoryModel_.setupPath(path, onLoadedActivateLeaf, onResolve);
       return;
     }
 
-    if (this.params_.defaultPath) {
-      var path = this.params_.defaultPath;
-      if (this.dialogType_ == FileManager.DialogType.SELECT_SAVEAS_FILE) {
-        this.directoryModel_.setupPath(path, undefined,
-            function(basePath, leafName) {
-              this.filenameInput_.value = leafName;
-              this.selectDefaultPathInFilenameInput_();
-            }.bind(this));
-        return;
-      }
-
-      this.directoryModel_.setupPath(path);
+    if (this.dialogType_ == FileManager.DialogType.SELECT_SAVEAS_FILE) {
+      this.directoryModel_.setupPath(path, undefined,
+          function(basePath, leafName) {
+            this.filenameInput_.value = leafName;
+            this.selectDefaultPathInFilenameInput_();
+          }.bind(this));
       return;
     }
 
-    this.directoryModel_.setupDefaultPath();
+    this.directoryModel_.setupPath(path);
   };
 
   /**
    * Tweak the UI to become a particular kind of dialog, as determined by the
    * dialog type parameter passed to the constructor.
    */
   FileManager.prototype.initDialogType_ = function() {
     var defaultTitle;
     var okLabel = str('OPEN_LABEL');
 
@@ skipping 888 matching lines @@
 
     if (selection.tasksList.length > 0) {
       this.dispatchFileTask_(selection.tasksList[0].taskId, selection.urls);
       return;
     }
 
     if (selection.urls.length == 1) {
       // We don't have tasks, so try the default browser action.
       // We only do that for single selection to avoid confusion.
 
+      var self = this;
       function callback(success) {
         if (!success && selection.entries.length == 1)
-          this.alert.showHtml(
+          self.alert.showHtml(

[dgozman, 2012/03/28 10:28:30]

Callback is bound below.

[Vladislav Kaznacheev, 2012/03/28 14:00:57]

It was not bound enough:) because the parameter to executeIfAvaliable was not
bound. I fixed it properly now.
On 2012/03/28 10:28:30, dgozman wrote:

               unescape(selection.entries[0].name),
               strf('NO_ACTION_FOR_FILE', NO_ACTION_FOR_FILE_URL),
               function() {});
       }
 
       this.executeIfAvailable_(selection.urls, function(urls) {
         chrome.fileBrowserPrivate.viewFiles(urls, 'default',
             callback.bind(this));
       });
     }
@@ skipping 56 matching lines @@
     }
   };
 
   /**
    * Event handler called when some volume was mounted or unmouted.
    */
   FileManager.prototype.onMountCompleted_ = function(event) {
     var self = this;
 
     var changeDirectoryTo = null;
+    var setupInitialDirectory = false;
 
     if (event && event.mountType == 'gdata') {
       metrics.recordInterval('Load.GData');
-      if (this.gdataMountTimer_) {
-        clearTimeout(this.gdataMountTimer_);
-        this.gdataMountTimer_ = null;
-      }
+      console.log("GData mounted");
+      // Not calling clearGDataLoadingTimer_ here because we want to keep

[dgozman, 2012/03/28 10:28:30]

Is the following possible?
- requesting gdata mount
- it mount successfully
- starting rescan
- timer fires, we show error message (problem here)
- rescan complete, we show contents

[Vladislav Kaznacheev, 2012/03/28 14:00:57]

Yes. This is intended (see
http://code.google.com/p/chromium-os/issues/detail?id=28298#c1).
Added a comment at the timer creation point.

On 2012/03/28 10:28:30, dgozman wrote:

+      // "Loading Google Docs" message until the directory loads. It is OK if
+      // the timer fires after the mount because onDirectoryChanged_will hide

[dgozman, 2012/03/28 10:28:30]

typo: onDirectoryChanged_will

[Vladislav Kaznacheev, 2012/03/28 14:00:57]

Done.

+      // the unmounted panel.
       if (event.status == 'success') {
         this.gdataMounted_ = true;
         this.gdataMountInfo_ = {
           "mountPath": event.mountPath,
           "sourceUrl": event.sourceUrl,
           "mountType": event.mountType,
           "mountCondition": event.status
         };
-        if (this.isOnGData()) {
+        if (self.setupGDataDirectoryAfterMount_) {
+          setupInitialDirectory = true;
+        } else if (this.isOnGData() &&
+            this.directoryModel_.currentEntry.unmounted) {
           // We are currently on an unmounted GData directory, force a rescan.
           changeDirectoryTo = this.directoryModel_.rootPath;
         }
       } else {
+        this.clearGDataLoadingTimer_();
+        this.onGDataUnreachable_('GData mount failed: ' +  event.status);
         this.gdataMounted_ = false;
         this.gdataMountInfo_ = null;
       }
     }
 
     chrome.fileBrowserPrivate.getMountPoints(function(mountPoints) {
       self.setMountPoints_(mountPoints);
       if (event.eventType == 'mount') {
         // Mount request finished - remove it.
         var index = self.mountRequests_.indexOf(event.sourceUrl);
@@ skipping 34 matching lines @@
           return;
         }
         // Current durectory just unmounted. Move to the 'Downloads'.
         changeDirectoryTo = '/' + DirectoryModel.DOWNLOADS_DIRECTORY;
       }
 
       // 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.
       self.directoryModel_.updateRoots(function() {
+        if (setupInitialDirectory && self.setupGDataDirectoryAfterMount_) {

[dgozman, 2012/03/28 10:28:30]

I think, setupInitialDirectory is true if and only if
setupGDataDirectoryAfterMount_ is not null.

[Vladislav Kaznacheev, 2012/03/28 14:00:57]

I got rid of this variable completely.

On 2012/03/28 10:28:30, dgozman wrote:

+          self.setupGDataDirectoryAfterMount_();
+        }
         if (changeDirectoryTo) {
           self.directoryModel_.changeDirectory(changeDirectoryTo);
         }
-      });
+      }, self.gdataMounted_);
     });
   };
 
   /**
    * 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 869 matching lines @@
       }
       chrome.fileBrowserPrivate.removeFileWatch(this.watchedDirectoryUrl_,
           function(result) {
             if (!result) {
               console.log('Failed to remove file watch');
             }
           });
       this.watchedDirectoryUrl_ = null;
     }
 
-    if (event.newDirEntry.fullPath != '/') {
+    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));
     }
 
     this.updateVolumeMetadata_();
 
+    if (event.newDirEntry.unmounted)
+      this.dialogContainer_.setAttribute('unmounted', true);
+    else
+      this.dialogContainer_.removeAttribute('unmounted');
+
     if (this.isOnGData()) {
       this.dialogContainer_.setAttribute('gdata', true);
-      if (!this.requestedGDataMount_) {  // Request GData mount only once.
-        this.requestedGDataMount_ = true;
-        this.initGData_();
+      if (event.newDirEntry.unmounted) {
+        this.initGData_(true /* directory changed */);
       }
     } else {
       this.dialogContainer_.removeAttribute('gdata');
     }
+
+    // Manual directory change cancels the GData directory setup.
+    this.setupGDataDirectoryAfterMount_ = null;
   };
 
   FileManager.prototype.updateVolumeMetadata_ = function() {
     var dm = this.directoryModel_;
     if (!dm) return;
 
     // Only request metadata for removable devices and archives.
     var rootType = dm.rootType;
     if (rootType != DirectoryModel.RootType.REMOVABLE &&
         rootType != DirectoryModel.RootType.ARCHIVE)
@@ skipping 840 matching lines @@
           });
       }, onError);
 
       function onError(err) {
         console.log('Error while checking free space: ' + err);
         setTimeout(doCheck, 1000 * 60);
       }
     }
   }
 })();