[Gallery] Add reload feature

ui/file_manager/gallery/js/gallery.js

 // Copyright 2014 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.
 
 /**
  * Overrided metadata worker's path.
  * @type {string}
  */
 ContentProvider.WORKER_SCRIPT = '/js/metadata_worker.js';
 
@@ skipping 36 matching lines @@
     curDirEntry: null,
     searchResults: null
   };
   this.container_ = queryRequiredElement(document, '.gallery');
   this.document_ = document;
   this.metadataCache_ = this.context_.metadataCache;
   this.volumeManager_ = volumeManager;
   this.selectedEntry_ = null;
   this.metadataCacheObserverId_ = null;
   this.onExternallyUnmountedBound_ = this.onExternallyUnmounted_.bind(this);
+  this.initialized_ = false;
 
   this.dataModel_ = new GalleryDataModel(
       this.context_.metadataCache);
   var downloadVolumeInfo = this.volumeManager_.getCurrentProfileVolumeInfo(
       VolumeManagerCommon.VolumeType.DOWNLOADS);
   downloadVolumeInfo.resolveDisplayRoot().then(function(entry) {
     this.dataModel_.fallbackSaveDirectory = entry;
   }.bind(this)).catch(function(error) {
     console.error(
         'Failed to obtain the fallback directory: ' + (error.stack || error));
@@ skipping 266 matching lines @@
   }
   loadingList = loadingList.sort(function(a, b) {
     if (a.selected && !b.selected)
       return -1;
     else if (!a.selected && b.selected)
       return 1;
     else
       return a.index - b.index;
   });
 
+  if (loadingList.length === 0) {
+    this.dataModel_.splice(0, this.dataModel_.length);
+    return;
+  }
+
   // Load entries.
   // Use the self variable capture-by-closure because it is faster than bind.
   var self = this;
   var loadChunk = function(firstChunk) {
     // Extract chunk.
     var chunk = loadingList.splice(0, maxChunkSize);
     if (!chunk.length)
       return;
 
     return new Promise(function(fulfill) {
       // Obtains metadata for chunk.
       var entries = chunk.map(function(chunkItem) {
         return chunkItem.entry;
       });
       self.metadataCache_.get(entries, Gallery.METADATA_TYPE, fulfill);
     }).then(function(metadataList) {
       if (chunk.length !== metadataList.length)
         return Promise.reject('Failed to load metadata.');
 
+      // Remove all the previous items if it's the first chunk.
+      // Do it here because prevent a flicker between removing all the items
+      // and adding new ones.
+      if (firstChunk) {
+        self.dataModel_.splice(0, self.dataModel_.length);
+        self.updateThumbnails_();  // Remove the caches.
+      }
+
       // Add items to the model.
       var items = [];
       chunk.forEach(function(chunkItem, index) {
         var locationInfo = self.volumeManager_.getLocationInfo(chunkItem.entry);
         if (!locationInfo)  // Skip the item, since gone.
           return;
         var clonedMetadata = MetadataCache.cloneMetadata(metadataList[index]);
         items.push(new Gallery.Item(
             chunkItem.entry,
             locationInfo,
@@ skipping 11 matching lines @@
         var index = self.dataModel_.indexOf(items[i]);
         if (index < 0)
           continue;
         self.selectionModel_.setIndexSelected(index, true);
         selectionUpdated = true;
       }
       if (selectionUpdated)
         self.onSelection_();
 
       // Init modes after the first chunk is loaded.
-      if (firstChunk) {
+      if (firstChunk && !self.initialized_) {
         // Determine the initial mode.
         var shouldShowMosaic = selectedEntries.length > 1 ||
             (self.context_.pageState &&
              self.context_.pageState.gallery === 'mosaic');
         self.setCurrentMode_(
             shouldShowMosaic ? self.mosaicMode_ : self.slideMode_);
 
         // Init mosaic mode.
         var mosaic = self.mosaicMode_.getMosaic();
         mosaic.init();
 
         // Do the initialization for each mode.
         if (shouldShowMosaic) {
           mosaic.show();
           self.inactivityWatcher_.check();  // Show the toolbar.
           cr.dispatchSimpleEvent(self, 'loaded');
         } else {
           self.slideMode_.enter(
               null,
               function() {
                 // Flash the toolbar briefly to show it is there.
                 self.inactivityWatcher_.kick(Gallery.FIRST_FADE_TIMEOUT);
               },
               function() {
                 cr.dispatchSimpleEvent(self, 'loaded');
               });
         }
+        self.initialized_ = true;
       }
 
       // Continue to load chunks.
       return loadChunk(/* firstChunk */ false);
     });
   };
   loadChunk(/* firstChunk */ true).catch(function(error) {
     console.error(error.stack || error);
   });
 };
@@ skipping 470 matching lines @@
   this.mosaicMode_.debugMe();
 };
 
 /**
  * Singleton gallery.
  * @type {Gallery}
  */
 var gallery = null;
 
 /**
+ * (Re-)loads entries.
+ */
+function reload() {
+  initializePromise.then(function() {
+    util.URLsToEntries(window.appState.urls, function(entries) {
+      gallery.load(entries);
+    });
+  });
+}
+
+/**
  * Promise to initialize the load time data.
  * @type {!Promise}
  */
 var loadTimeDataPromise = new Promise(function(fulfill, reject) {
   chrome.fileManagerPrivate.getStrings(function(strings) {
     window.loadTimeData.data = strings;
     i18nTemplate.process(document, loadTimeData);
     fulfill(true);
   });
 });
 
 /**
  * Promise to initialize volume manager.
  * @type {!Promise}
  */
 var volumeManagerPromise = new Promise(function(fulfill, reject) {
   var volumeManager = new VolumeManagerWrapper(
       VolumeManagerWrapper.DriveEnabledStatus.DRIVE_ENABLED);
   volumeManager.ensureInitialized(fulfill.bind(null, volumeManager));
 });
 
 /**
  * Promise to initialize both the volume manager and the load time data.
  * @type {!Promise}
  */
 var initializePromise =
     Promise.all([loadTimeDataPromise, volumeManagerPromise]).
     then(function(args) {
       var volumeManager = args[1];
-      var gallery = new Gallery(volumeManager);
-      return gallery;
+      gallery = new Gallery(volumeManager);
     });
 
 // Loads entries.
-initializePromise.then(
-    /**
-     * Loads entries.
-     * @param {!Gallery} gallery The gallery instance.
-     */
-    function(gallery) {
-      util.URLsToEntries(window.appState.urls, function(entries) {
-        gallery.load(entries);
-      });
-    });
+initializePromise.then(reload);
 
 /**
  * Enteres the debug mode.
  */
 window.debugMe = function() {
-  initializePromise.then(function(gallery) {
+  initializePromise.then(function() {
     gallery.debugMe();
   });
 };