[File Manager] Properly enable/disable Copy and Open for GData files in the offline mode.

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 524 matching lines @@
     this.copyManager_.addEventListener('copy-progress',
                                        this.onCopyProgress_.bind(this));
     this.copyManager_.addEventListener('copy-operation-complete',
         this.onCopyManagerOperationComplete_.bind(this));
 
     var controller = this.fileTransferController_ = new FileTransferController(
         this.directoryModel_.fileList,
         this.directoryModel_.fileListSelection,
         GridItem.bind(null, this),
         this.copyManager_,
-        this.directoryModel_);
+        this.directoryModel_,
+        this.commands_);
     controller.attachDragSource(this.table_.list);
     controller.attachDropTarget(this.table_.list);
     controller.attachDragSource(this.grid_);
     controller.attachDropTarget(this.grid_);
     controller.attachCopyPasteHandlers(this.document_);
     controller.addEventListener('selection-copied',
         this.blinkSelection.bind(this));
     controller.addEventListener('selection-cut',
         this.blinkSelection.bind(this));
   };
@@ skipping 1343 matching lines @@
     if (!this.isOnGData())
       return;
 
     cacheGDataProps(entry, function(entry) {
       if (!entry.gdata_)
         return;
 
       if (entry.gdata_.isHosted) {
         listItem.classList.add('gdata-hosted');
       }
-      if (entry.isDirectory || FileManager.isAvaliableOffline_(entry.gdata_)) {
+      if (entry.isDirectory || FileType.isAvaliableOffline_(entry.gdata_)) {
         listItem.classList.add('gdata-present');
       }
     }.bind(this));
   };
 
   /**
    * Render the Name column of the detail table.
    *
    * Invoked by cr.ui.Table when a file needs to be rendered.
    *
@@ skipping 111 matching lines @@
   };
 
   FileManager.prototype.updateDate_ = function(div, entry) {
     div.textContent = '...';
     this.displayDateInDiv_(
         div, this.metadataCache_.getCached(entry, 'filesystem'));
   };
 
   FileManager.prototype.displayDateInDiv_ = function(div, filesystemProps) {
     if (!filesystemProps) return;
-    if (this.directoryModel_.isSystemDirectoy &&
+    if (this.directoryModel_.isSystemDirectory &&
         filesystemProps.modificationTime.getTime() == 0) {
       // Mount points for FAT volumes have this time associated with them.
       // We'd rather display nothing than this bogus date.
       div.textContent = '';
     } else {
       div.textContent =
           this.shortDateFormatter_.format(filesystemProps.modificationTime);
     }
   };
 
@@ skipping 92 matching lines @@
    */
   FileManager.prototype.summarizeSelection_ = function() {
     var selection = this.selection = {
       entries: [],
       urls: [],
       totalCount: 0,
       fileCount: 0,
       directoryCount: 0,
       bytes: 0,
       showBytes: false,
+      allGDataFilesPresent: false,
       iconType: null,
       indexes: this.currentList_.selectionModel.selectedIndexes
     };
 
     if (!selection.indexes.length) {
       this.updateCommonActionButtons_();
       this.updatePreviewPanelVisibility_();
       cr.dispatchSimpleEvent(this, 'selection-summarized');
       return;
     }
@@ skipping 94 matching lines @@
         }
 
         if (entry.isFile) {
           selection.bytes += filesystem.size;
           selection.showBytes |= filesystem.fileType.type != 'hosted';
         }
       }
 
       this.dispatchEvent(new cr.Event('selection-summarized'));
     }.bind(this));
+
+    if (this.isOnGData()) {
+      FileType.checkOfflineAvailability(
+          selection.entries, selection.urls, function(result) {
+        selection.allGDataFilesPresent = result;
+        this.updateOkButton_();
+      }.bind(this));
+    }
   };
 
   /**
    * Initialize a thumbnail in the bottom pannel to pop up on mouse over.
    * Image's assumed to be just loaded and not inserted into the DOM.
    *
    * @param {HTMLElement} box Element what's going to contain the image.
    * @param {HTMLElement} img Loaded image.
    */
   FileManager.prototype.initThumbnailZoom_ = function(box, img, transform) {
@@ skipping 101 matching lines @@
       self.onResize_();
     }
 
     function setVisibility(visibility) {
       panel.setAttribute('visibility', visibility);
     }
   };
 
 
   FileManager.prototype.isOnGData = function() {
-    return this.directoryModel_ &&
-        this.directoryModel_.rootPath == '/' + DirectoryModel.GDATA_DIRECTORY;
+    return this.directoryModel_.isOnGData;
   };
 
   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
    *     can change before tasks were found, and we should be accurate.
@@ skipping 166 matching lines @@
         // For internal tasks we do not listen to the event to avoid
         // handling the same task instance from multiple tabs.
         // So, we manually execute the task.
         this.onFileTaskExecute_(task_parts[1], urls);
       }
     }.bind(this));
   };
 
   FileManager.prototype.executeIfAvailable_ = function(urls, callback) {
     if (this.isOnGDataOffline()) {
-      chrome.fileBrowserPrivate.getGDataFileProperties(urls, function(props) {
-        for (var i = 0; i != props.length; i++) {
-          if (!FileManager.isAvaliableOffline_(props[i])) {
-            this.alert.showHtml(
-                str('OFFLINE_HEADER'),
-                strf(
-                    urls.length == 1 ?
-                        'OFFLINE_MESSAGE' :
-                        'OFFLINE_MESSAGE_PLURAL',
-                    str('OFFLINE_COLUMN_LABEL')));
-            return;
-          }
+      FileType.checkOfflineAvailability(
+          null /* entries */, urls, function(result) {
+        if (!result) {
+          this.alert.showHtml(
+              str('OFFLINE_HEADER'),
+              strf(
+                  urls.length == 1 ?
+                      'OFFLINE_MESSAGE' :
+                      'OFFLINE_MESSAGE_PLURAL',
+                  str('OFFLINE_COLUMN_LABEL')));
+          return;
         }
         callback(urls);
       }.bind(this));
     } else {
       callback(urls);
     }
   };
 
-  FileManager.isAvaliableOffline_ = function(gdata) {
-    return gdata.isPresent && !gdata.isHosted;
-  };
-
   FileManager.prototype.isOffline = function() {
     return !navigator.onLine;
   };
 
   FileManager.prototype.onOnlineOffline_ = function() {
     if (this.isOffline()) {
       console.log('OFFLINE');
       this.dialogContainer_.setAttribute('offline', true);
     } else {
       console.log('ONLINE');
       this.dialogContainer_.removeAttribute('offline');
     }
     this.directoryModel_.offline = this.isOffline();
+    this.updateOkButton_();
   };
 
   FileManager.prototype.isOnGDataOffline = function() {
     return this.isOnGData() && this.isOffline();
   };
 
   FileManager.prototype.isOnReadonlyDirectory = function() {
     return this.directoryModel_.readonly;
   };
 
@@ skipping 657 matching lines @@
         if (listItem)
           listItem.querySelector('input[type="checkbox"]').checked = true;
       }
     }
     var selectAllCheckbox =
         this.document_.getElementById('select-all-checkbox');
     if (selectAllCheckbox)
       this.updateSelectAllCheckboxState_(selectAllCheckbox);
   };
 
+  /**
+    * 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 available.
+    */
+  FileManager.prototype.isSelectionAvailable = function() {
+    return !this.isOnGDataOffline() || this.selection.allGDataFilesPresent;
+  };
+
   FileManager.prototype.updateOkButton_ = function(event) {
     var selectable;
 
-    if (this.dialogType_ == FileManager.DialogType.SELECT_FOLDER) {
+    if (!this.selection) {
+      selectable = false;
+    } else if (this.dialogType_ == FileManager.DialogType.SELECT_FOLDER) {
       selectable = this.selection.directoryCount == 1 &&
           this.selection.fileCount == 0;
     } else if (this.dialogType_ == FileManager.DialogType.SELECT_OPEN_FILE) {
-      selectable = (this.selection.directoryCount == 0 &&
+      selectable = (this.isSelectionAvailable() &&
+                    this.selection.directoryCount == 0 &&
                     this.selection.fileCount == 1);
     } else if (this.dialogType_ ==
                FileManager.DialogType.SELECT_OPEN_MULTI_FILE) {
-      selectable = (this.selection.directoryCount == 0 &&
+      selectable = (this.isSelectionAvailable() &&
+                    this.selection.directoryCount == 0 &&
                     this.selection.fileCount >= 1);
     } else if (this.dialogType_ == FileManager.DialogType.SELECT_SAVEAS_FILE) {
       if (this.isOnReadonlyDirectory()) {
         selectable = false;
       } else {
         selectable = !!this.filenameInput_.value;
       }
     } else if (this.dialogType_ == FileManager.DialogType.FULL_PAGE) {
       // No "select" buttons on the full page UI.
       selectable = true;
@@ skipping 1010 matching lines @@
 
       handleSplitterDragEnd: function(e) {
         Splitter.prototype.handleSplitterDragEnd.apply(this, arguments);
         this.ownerDocument.documentElement.classList.remove('col-resize');
       }
     };
 
     customSplitter.decorate(splitterElement);
   };
 })();