[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 391 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_.getFileList(),
         this.directoryModel_.getFileListSelection(),
         GridItem.bind(null, this),
         this.copyManager_,
-        this.directoryModel_);
+        this.directoryModel_,
+        this.metadataCache_);
     controller.attachDragSource(this.table_.list);
     controller.attachDropTarget(this.table_.list);
     controller.attachDragSource(this.grid_);
     controller.attachDropTarget(this.grid_);
     controller.attachDropTarget(this.rootsList_, true);
     controller.attachCopyPasteHandlers(this.document_);
     controller.addEventListener('selection-copied',
         this.blinkSelection.bind(this));
     controller.addEventListener('selection-cut',
         this.blinkSelection.bind(this));
@@ skipping 1559 matching lines @@
       var url = urls[index];
       if (!(url in items)) continue;
       var listItem = items[url];
       var entry = entries[url];
       var props = properties[index];
       if (type == 'filesystem') {
         this.displayDateInDiv_(listItem.querySelector('.date'), props);
         this.displaySizeInDiv_(listItem.querySelector('.size'), props);
         this.displayTypeInDiv_(listItem.querySelector('.type'), props);
       } else if (type == 'gdata') {
-        this.displayOfflineInDiv_(listItem.querySelector('.offline'), props);
+        var offline = listItem.querySelector('.offline');
+        if (offline)  // This column is only present in full page mode.
+          this.displayOfflineInDiv_(offline, props);
         this.displayGDataStyleInItem_(listItem, entry, props);
       }
     }
   };
 
   /**
    * Restore the item which is being renamed while refreshing the file list. Do
    * nothing if no item is being renamed or such an item disappeared.
    *
    * While refreshing file list it gets repopulated with new file entries.
@@ skipping 31 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()) {
+      this.metadataCache_.get(selection.urls, 'gdata', function(props) {
+        selection.allGDataFilesPresent =
+            props.filter(function(p) {return !p.availableOffline}).length == 0;
+        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
+   *                    available.
+    */
+  FileManager.prototype.isSelectionAvailable = function() {
+    return !this.isOnGDataOffline() || this.selection.allGDataFilesPresent;
+  };
+
+  /**
    * 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) {
     var width = img.width;
     var height = img.height;
     var THUMBNAIL_SIZE = 45;
@@ skipping 288 matching lines @@
         // 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()) {
       this.metadataCache_.get(urls, 'gdata', function(props) {
-        for (var i = 0; i != props.length; i++) {
-          if (!props[i].availableOffline) {
-            this.alert.showHtml(
-                str('OFFLINE_HEADER'),
-                strf(
-                    urls.length == 1 ?
-                        'OFFLINE_MESSAGE' :
-                        'OFFLINE_MESSAGE_PLURAL',
-                    str('OFFLINE_COLUMN_LABEL')));
-            return;
-          }
+        if (props.filter(function(p) {return !p.availableOffline}).length) {
+          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.prototype.isOffline = function() {
-    return !navigator.onLine;
-  };
-
   FileManager.prototype.onOnlineOffline_ = function() {
-    if (this.isOffline()) {
+    if (util.isOffline()) {
       console.log('OFFLINE');
       this.dialogContainer_.setAttribute('offline', true);
     } else {
       console.log('ONLINE');
       this.dialogContainer_.removeAttribute('offline');
     }
   };
 
   FileManager.prototype.isOnGDataOffline = function() {
-    return this.isOnGData() && this.isOffline();
+    return this.isOnGData() && util.isOffline();
   };
 
   FileManager.prototype.isOnReadonlyDirectory = function() {
     return this.directoryModel_.isReadOnly();
   };
 
   /**
    * Event handler called when some volume was mounted or unmouted.
    */
   FileManager.prototype.onMountCompleted_ = function(event) {
@@ skipping 555 matching lines @@
               strf('GDATA_OUT_OF_SPACE_MESSAGE',
                   util.bytesToSi(filesystem.size)));
         });
       }
       // We don't have update events yet, so clear the cached data.
       self.metadataCache_.clear(entry, 'gdata');
       checkbox.checked = props[0].isPinned;
     }
     var pin = checkbox.checked;
     this.metadataCache_.get(entry, 'gdata', function(gdata) {
-      if (self.isOffline() && pin && !gdata.present) {
+      if (util.isOffline() && pin && !gdata.present) {
         // If we are offline, we cannot pin a file that is not already present.
         checkbox.checked = false;  // Revert the default action.
         self.alert.showHtml(
             str('OFFLINE_HEADER'),
             strf('OFFLINE_MESSAGE', str('OFFLINE_COLUMN_LABEL')));
         return;
       }
       chrome.fileBrowserPrivate.pinGDataFile([entry.toURL()], pin, callback);
     });
     event.preventDefault();
@@ skipping 92 matching lines @@
       this.updateSelectAllCheckboxState_(selectAllCheckbox);
   };
 
   FileManager.prototype.updateOkButton_ = function(event) {
     var selectable;
 
     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 1019 matching lines @@
 
       handleSplitterDragEnd: function(e) {
         Splitter.prototype.handleSplitterDragEnd.apply(this, arguments);
         this.ownerDocument.documentElement.classList.remove('col-resize');
       }
     };
 
     customSplitter.decorate(splitterElement);
   };
 })();