[File Manager]Disable "Copy" command if selection contains dimmed GData files

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 2197 matching lines @@
    */
   FileManager.prototype.summarizeSelection_ = function() {
     var selection = this.selection = {
       entries: [],
       urls: [],
       totalCount: 0,
       fileCount: 0,
       directoryCount: 0,
       bytes: 0,
       showBytes: false,
+      allGDataFilesPresent: this.isOnGData(),
       iconType: null,
       indexes: this.currentList_.selectionModel.selectedIndexes
     };
 
     if (!selection.indexes.length) {
       this.updateCommonActionButtons_();
       this.updatePreviewPanelVisibility_();
       cr.dispatchSimpleEvent(this, 'selection-summarized');
       return;
     }
 
     this.previewSummary_.textContent = str('COMPUTING_SELECTION');
     var thumbnails = this.document_.createDocumentFragment();
 
     var fileCount = 0;
     var byteCount = 0;
     var pendingFiles = [];
+    var pendingGDataFiles = [];
     var thumbnailCount = 0;
     var thumbnailLoaded = -1;
     var forcedShowTimeout = null;
     var self = this;
 
     function showThumbnails() {
       if (forcedShowTimeout === null)
         return;
       clearTimeout(forcedShowTimeout);
       forcedShowTimeout = null;
@@ skipping 53 matching lines @@
           // Any file that hasn't been rendered may be missing its cachedSize_
           // property.  For example, visit a large file list, and press ctrl-a
           // to select all.  In this case, we need to asynchronously get the
           // sizes for these files before telling the world the selection has
           // been summarized.  See the 'computeNextFile' logic below.
           pendingFiles.push(entry);
         } else {
           selection.bytes += entry.cachedSize_;
           selection.showBytes |= this.getFileType(entry).type != 'hosted';
         }
+
+        // Only keep checking if allGDataFilesPresent is not already false.
+        if (selection.allGDataFilesPresent) {
+          if (!('gdata_' in entry)) {
+            pendingGDataFiles.push(entry);
+          } else {
+            selection.allGDataFilesPresent =
+                FileManager.isAvaliableOffline_(entry.gdata_);
+          }
+        }
       } else {
         selection.directoryCount += 1;
+        // We cannot afford checking every file under this directory so
+        // we conservatively assume that some files are not present.
+        selection.allGDataFilesPresent = false;
       }
     }
 
     // Now this.selection is complete. Update buttons.
     this.updateCommonActionButtons_();
     this.updatePreviewPanelVisibility_();
     forcedShowTimeout = setTimeout(showThumbnails, 100);
     onThumbnailLoaded();
 
+    if (this.fileTransferController_) {
+      this.fileTransferController_.selectionAvailable = false;
+    }
+
+    function maybeFireSummarized() {
+      if (pendingFiles.length == 0 && pendingGDataFiles.length == 0)
+        self.dispatchEvent(new cr.Event('selection-summarized'));
+    }
+
     function cacheNextFile(fileEntry) {
       if (fileEntry) {
         // We're careful to modify the 'selection', rather than 'self.selection'
         // here, just in case the selection has changed since this summarization
         // began.
         selection.bytes += fileEntry.cachedSize_;
         selection.showBytes |= self.getFileType(fileEntry).type != 'hosted';
       }
 
       if (pendingFiles.length) {
         cacheEntryDateAndSize(pendingFiles.pop(), cacheNextFile);
       } else {
-        self.dispatchEvent(new cr.Event('selection-summarized'));
+        maybeFireSummarized();
       }
     }
 
+    function cacheNextGDataFile(fileEntry) {
+      // If selection.allGDataFilesPresent is already false we stop checking.
+      if (selection.allGDataFilesPresent && fileEntry) {
+         selection.allGDataFilesPresent =
+             FileManager.isAvaliableOffline_(fileEntry.gdata_);
+      }
+      if (selection.allGDataFilesPresent && pendingGDataFiles.length) {
+        cacheGDataProps(pendingGDataFiles.pop(), cacheNextGDataFile);
+      } else {
+        pendingGDataFiles = [];
+        maybeFireSummarized();
+      }
+    }
+
     if (this.dialogType_ == FileManager.DialogType.FULL_PAGE) {
       // Some internal tasks cannot be defined in terms of file patterns,
       // so we pass selection to check for them manually.
       if (selection.directoryCount == 0 && selection.fileCount > 0) {
         // Only files, not directories, are supported for external tasks.
         chrome.fileBrowserPrivate.getFileTasks(
             selection.urls,
             this.onTasksFound_.bind(this, selection));
       } else {
         // There may be internal tasks for directories.
         this.onTasksFound_(selection, []);
       }
     }
 
     cacheNextFile();
+    if (selection.allGDataFilesPresent)
+      cacheNextGDataFile();
   };
 
   /**
    * 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 328 matching lines @@
       console.log('ONLINE');
       this.dialogContainer_.removeAttribute('offline');
     }
     this.directoryModel_.offline = this.isOffline();
   };
 
   FileManager.prototype.isOnGDataOffline = function() {
     return this.isOnGData() && this.isOffline();
   };
 
+  /**
+   * 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.isOnReadonlyDirectory = function() {
     return this.directoryModel_.readonly;
   };
 
   /**
    * Event handler called when some volume was mounted or unmouted.
    */
   FileManager.prototype.onMountCompleted_ = function(event) {
     var self = this;
 
@@ skipping 518 matching lines @@
       // TODO(dgozman): change the string to not contain ", $2".
       if (!selection.showBytes) text = text.substring(0, text.lastIndexOf(','));
     } else if (selection.fileCount == 0) {
       text = strf('MANY_DIRECTORIES_SELECTED', selection.directoryCount);
     } else {
       text = strf('MANY_ENTRIES_SELECTED', selection.totalCount, bytes);
       // TODO(dgozman): change the string to not contain ", $2".
       if (!selection.showBytes) text = text.substring(0, text.lastIndexOf(','));
     }
     this.previewSummary_.textContent = text;
+
+    this.updateOkButton_();
+    if (this.fileTransferController_) {
+      this.fileTransferController_.selectionAvailable =
+          this.isSelectionAvailable();
+    }
   };
 
   /**
    * Handle a click event on a breadcrumb element.
    *
    * @param {Event} event The click event.
    */
   FileManager.prototype.onBreadcrumbClick_ = function(event) {
     this.directoryModel_.changeDirectory(event.srcElement.path);
   };
@@ skipping 125 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 1032 matching lines @@
 
     chrome.fileBrowserPrivate.setGDataPreferences(changeInfo);
 
     if (oldValue) {
       event.target.removeAttribute('checked');
     } else {
       event.target.setAttribute('checked', 'checked');
     }
   };
 })();