[File Manager] Refresh GDrive thumbnails if they became stale

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 419 matching lines @@
         'modificationTime';
     var sortDirection =
         window.localStorage['sort-direction-' + this.dialogType_] || 'desc';
     this.directoryModel_.sortFileList(sortField, sortDirection);
 
     this.refocus();
 
     this.metadataProvider_ =
         new MetadataProvider(this.filesystem_.root.toURL());
 
+    // Holds the directories known to contain files with stale metadata
+    // as URL to bool map.
+    this.directoriesWithStaleMetadata_ = {};
+
     // PyAuto tests monitor this state by polling this variable
     this.__defineGetter__('workerInitialized_', function() {
        return self.getMetadataProvider().isInitialized();
     });
 
     if (this.dialogType_ == FileManager.DialogType.FULL_PAGE)
       this.initDataTransferOperations_();
 
     this.table_.endBatchUpdates();
     this.grid_.endBatchUpdates();
@@ skipping 1217 matching lines @@
       fractionX = 1;
     }
 
     style.width = percent(fractionX);
     style.height = percent(fractionY);
     style.left = percent((1 - fractionX) / 2);
     style.top = percent((1 - fractionY) / 2);
   };
 
   /**
+   * Ask the GData service to re-fetch the metadata for the current directory.
+   */
+  FileManager.prototype.requestMetadataRefresh = function() {
+    if (!this.isOnGData())
+      return;
+    // TODO(kaznacheev) This does not really work with GData search.
+    var url = this.getCurrentDirectoryURL();
+    // Skip if the current directory is now being refreshed.
+    if (this.directoriesWithStaleMetadata_[url])
+      return;
+
+    this.directoriesWithStaleMetadata_[url] = true;
+    chrome.fileBrowserPrivate.requestDirectoryRefresh(url);
+  };
+
+  /**
    * Create a box containing a centered thumbnail image.
    *
    * @param {Entry} entry Entry which thumbnail is generating for.
    * @param {boolean} True if fill, false if fit.
    * @param {function(HTMLElement)} opt_imageLoadCallback Callback called when
    *                                the image has been loaded before inserting
    *                                it into the DOM.
    * @return {HTMLDivElement} Thumbnal box.
    */
   FileManager.prototype.renderThumbnailBox_ = function(entry, fill,
@@ skipping 13 matching lines @@
         self.centerImage_(img.style, img.width, img.height, fill);
         if (opt_imageLoadCallback)
           opt_imageLoadCallback(img, transform);
         box.appendChild(img);
       };
       img.onerror = function() {
         // Use the default icon if we could not fetch the correct one.
         img.src = FileType.getPreviewArt(iconType);
         transform = null;
         util.applyTransform(box, transform);
+
+        var cached = self.thumbnailUrlCache_[entry.fullPath];
+        if (!cached.failed) {
+          cached.failed = true;
+          self.requestMetadataRefresh();
+          // Failing to fetch a thumbnail likely means that the thumbnail URL
+          // is now stale. Request a refresh of the current directory, to get
+          // the new thumbnail URLs. Once the directory is refreshed, we'll get
+          // notified via onFileChanged event.
+          self.requestMetadataRefresh();
+        }
       };
       img.src = url;
       util.applyTransform(box, transform);
     }
 
     // TODO(dgozman): move to new metadata cache.
     var cached = this.thumbnailUrlCache_[entry.fullPath];
-    if (cached)
+    // Don't reuse the cached URL if we are now retrying.
+    if (cached && !cached.failed)
       onThumbnailURL(cached.iconType, cached.url, cached.transform);
-    else
+    else {
+      if (cached && cached.failed) {
+        delete cached.failed;
+        this.metadataProvider_.reset(entry.toURL());  // Clear the cache.
+      }
       this.getThumbnailURL(entry, onThumbnailURL);
+    }
 
     return box;
   };
 
   FileManager.prototype.decorateThumbnail_ = function(li, entry) {
     li.className = 'thumbnail-item';
 
     if (this.showCheckboxes_)
       li.appendChild(this.renderSelectionCheckbox_(entry));
 
@@ skipping 1943 matching lines @@
             if (!result) {
               console.log('Failed to remove file watch');
             }
           });
       this.watchedDirectoryUrl_ = null;
     }
   };
 
   FileManager.prototype.onFileChanged_ = function(event) {
     // We receive a lot of events even in folders we are not interested in.
-    if (encodeURI(event.fileUrl) == this.getSearchOrCurrentDirectoryURL())
+    if (encodeURI(event.fileUrl) == this.getSearchOrCurrentDirectoryURL()) {
+      // This event is not necessarily caused by the metadata refresh
+      // completion. We clear the map knowing that if the metadata is still
+      // stale then a new re-fetch will be requested.
+      delete this.directoriesWithStaleMetadata_[
+          this.getSearchOrCurrentDirectoryURL()];
       this.directoryModel_.rescanLater();
+    }
   };
 
   FileManager.prototype.initiateRename_ = function() {
     var item = this.currentList_.ensureLeadItemExists();
     if (!item)
       return;
     var label = item.querySelector('.filename-label');
     var input = this.renameInput_;
 
     input.value = label.textContent;
@@ skipping 959 matching lines @@
 
     function closeBanner() {
       self.cleanupGDataWelcome_();
       // Stop showing the welcome banner.
       localStorage[WELCOME_HEADER_COUNTER_KEY] = WELCOME_HEADER_COUNTER_LIMIT;
     }
 
     return maybeShowBanner;
   };
 })();