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

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 {boolean} showGData Defines whether GData root should be should
- *   (regardless of its mounts status).
  * @param {MetadataCache} metadataCache The metadata cache service.
  */
-function DirectoryModel(root, singleSelection, showGData, metadataCache) {
+function DirectoryModel(root, singleSelection, metadataCache) {
   this.root_ = root;
   this.metadataCache_ = metadataCache;
   this.fileList_ = new cr.ui.ArrayDataModel([]);
   this.fileListSelection_ = singleSelection ?
       new cr.ui.ListSingleSelectionModel() : new cr.ui.ListSelectionModel();
 
-  this.showGData_ = showGData;
-
   this.runningScan_ = null;
   this.pendingScan_ = null;
   this.rescanTimeout_ = undefined;
   this.scanFailures_ = 0;
 
   // DirectoryEntry representing the current directory of the dialog.
   this.currentDirEntry_ = root;
 
   this.fileList_.prepareSort = this.prepareSort_.bind(this);
 
@@ skipping 45 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).
+ */
+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 extends cr.EventTarget.
  */
 DirectoryModel.prototype.__proto__ = cr.EventTarget.prototype;
 
 /**
  * @return {cr.ui.ArrayDataModel} Files in the current directory.
  */
 DirectoryModel.prototype.getFileList = function() {
   return this.fileList_;
 };
@@ skipping 832 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 {boolean} resolveGData See comment for updateRoots.
+ * @param {number} gdataAccess One of GDATA_ACCESS_* constants.
  */
-DirectoryModel.prototype.resolveRoots_ = function(callback, resolveGData) {
+DirectoryModel.prototype.resolveRoots_ = function(callback, gdataAccess) {
   var groups = {
     downloads: null,
     archives: null,
     removables: null,
     gdata: null
   };
   var self = this;
 
   metrics.startInterval('Load.Roots');
   function done() {
@@ skipping 17 matching lines @@
   function onDownloads(entry) {
     groups.downloads = [entry];
     done();
   }
 
   function onDownloadsError(error) {
     groups.downloads = [];
     done();
   }
 
-  function onGData(entry) {
-    console.log('GData found:', entry);
+  function onGDataMounted(entry) {
+    console.log('GData mounted:', entry);
     self.unmountedGDataEntry_ = null;
     groups.gdata = [entry];
     done();
   }
 
-  function onGDataError(error) {
-    console.log('GData error: ' + error);
+  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_];
     done();
   }
 
   var root = this.root_;
   root.getDirectory(DirectoryModel.DOWNLOADS_DIRECTORY, { create: false },
                     onDownloads, onDownloadsError);
   util.readDirectory(root, DirectoryModel.ARCHIVE_DIRECTORY,
                      append.bind(this, 'archives'));
   util.readDirectory(root, DirectoryModel.REMOVABLE_DIRECTORY,
                      append.bind(this, 'removables'));
-  if (this.showGData_) {
-    if (resolveGData) {
-      root.getDirectory(DirectoryModel.GDATA_DIRECTORY, { create: false },
-                        onGData, onGDataError);
-    } else {
-      onGDataError('lazy mount');
-    }
+
+  if (gdataAccess == DirectoryModel.GDATA_ACCESS_FULL) {
+    root.getDirectory(DirectoryModel.GDATA_DIRECTORY, { create: false },
+                      onGDataMounted, onGDataNotMounted);
+  } else if (gdataAccess == DirectoryModel.GDATA_ACCESS_LAZY) {
+    onGDataNotMounted();
   } else {
     groups.gdata = [];
   }
 };
 
 /**
-* @param {function} opt_callback Called when all roots are resolved.
-* @param {boolean} opt_resolveGData If true GData should be resolved for real,
-*                                   If false a stub entry should be created.
-*/
-DirectoryModel.prototype.updateRoots = function(opt_callback,
-                                                opt_resolveGData) {
+ * @param {function} callback Called when all roots are resolved.
+ * @param {number} gdataAccess One of GDATA_ACCESS_* constants.
+ */
+DirectoryModel.prototype.updateRoots = function(callback, gdataAccess) {
   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_();
 
-    if (opt_callback)
-      opt_callback();
-  }, opt_resolveGData);
+    callback();

[dgozman, 2012/05/14 08:52:54]

I hope, you've checked that callback was never null.

[Vladislav Kaznacheev, 2012/05/14 09:45:42]

Yes, of course. There are only 3 call sites, all with meaningful callbacks.
On 2012/05/14 08:52:54, dgozman wrote:

+  }, gdataAccess);
 };
 
 /**
  * Change root. In case user already opened the root, the last selected
  * directory will be selected.
  * @param {string} rootPath The path of the root.
  */
 DirectoryModel.prototype.changeRoot = function(rootPath) {
   if (this.currentDirByRoot_[rootPath]) {
     var onFail = this.changeDirectory.bind(this, rootPath);
@@ skipping 223 matching lines @@
 /**
  * @private
  */
 DirectoryModel.Scanner.prototype.recordMetrics_ = function() {
   metrics.recordInterval('DirectoryScan');
   if (this.dir_.fullPath ==
       '/' + DirectoryModel.DOWNLOADS_DIRECTORY) {
     metrics.recordMediumCount('DownloadsCount', this.list_.length);
   }
 };