Remove Gallery.Item when the corresponding entries are removed in file system.

ui/file_manager/gallery/js/slide_mode.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.
 
 /**
  * Slide mode displays a single image and has a set of controls to navigate
  * between the images and to edit an image.
  *
  * @param {!HTMLElement} container Main container element.
  * @param {!HTMLElement} content Content container element.
@@ skipping 140 matching lines @@
    */
   this.sequenceLength_ = 0;
 
   /**
    * @type {Array.<number>}
    * @private
    */
   this.savedSelection_ = null;
 
   /**
-   * @type {number}
+   * @type {Gallery.Item}
    * @private
    */
-  this.displayedIndex_ = -1;
+  this.displayedItem_ = null;
 
   /**
    * @type {?number}
    * @private
    */
   this.slideHint_ = null;
 
   /**
    * @type {boolean}
    * @private
@@ skipping 354 matching lines @@
 
     if (loadCallback) loadCallback();
   }.bind(this);
 
   // The latest |leave| call might have left the image animating. Remove it.
   this.unloadImage_();
 
   new Promise(function(fulfill) {
     // If the items are empty, just show the error message.
     if (this.getItemCount_() === 0) {
-      this.displayedIndex_ = -1;
+      this.displayedItem_ = null;
       //TODO(hirono) Show this message in the grid mode too.
       this.errorBanner_.show('GALLERY_NO_IMAGES');
       fulfill();
       return;
     }
 
     // Remember the selection if it is empty or multiple. It will be restored
     // in |leave| if the user did not changing the selection manually.
     var currentSelection = this.selectionModel_.selectedIndexes;
     if (currentSelection.length === 1)
       this.savedSelection_ = null;
     else
       this.savedSelection_ = currentSelection;
 
     // Ensure valid single selection.
     // Note that the SlideMode object is not listening to selection change yet.
     this.select(Math.max(0, this.getSelectedIndex()));
-    this.displayedIndex_ = this.getSelectedIndex();
 
     // Show the selected item ASAP, then complete the initialization
     // (loading the ribbon thumbnails can take some time).
     var selectedItem = this.getSelectedItem();
+    this.displayedItem_ = selectedItem;
 
     // Load the image of the item.
     this.loadItem_(
         selectedItem,
         zoomFromRect ?
             this.imageView_.createZoomEffect(zoomFromRect) :
             new ImageView.Effect.None(),
         displayCallback,
         function(loadType, delay) {
           fulfill(delay);
@@ skipping 133 matching lines @@
  * @private
  */
 SlideMode.prototype.onSelection_ = function() {
   if (this.selectionModel_.selectedIndexes.length === 0)
     return;  // Ignore temporary empty selection.
 
   // Forget the saved selection if the user changed the selection manually.
   if (!this.isSlideshowOn_())
     this.savedSelection_ = null;
 
-  if (this.getSelectedIndex() === this.displayedIndex_)
+  if (this.getSelectedItem() === this.displayedItem_)
     return;  // Do not reselect.
 
   this.commitItem_(this.loadSelectedItem_.bind(this));
 };
 
 /**
  * Handles changes in tools visibility, and if the header is dimmed, then
  * requests disabling the draggable app region.
  *
  * @private
@@ skipping 18 matching lines @@
 
 /**
  * Load the selected item.
  *
  * @private
  */
 SlideMode.prototype.loadSelectedItem_ = function() {
   var slideHint = this.slideHint_;
   this.slideHint_ = null;
 
-  var index = this.getSelectedIndex();
-  if (index === this.displayedIndex_)
+  if (this.getSelectedItem() === this.displayedItem_)
     return;  // Do not reselect.
 
-  var step = slideHint || (index - this.displayedIndex_);
+  var index = this.getSelectedIndex();
+  var displayedIndex = this.dataModel_.indexOf(this.displayedItem_);
+  var step =
+      slideHint || (displayedIndex > 0 ? index - displayedIndex : 1);
 
   if (Math.abs(step) != 1) {
     // Long leap, the sequence is broken, we have no good prefetch candidate.
     this.sequenceDirection_ = 0;
     this.sequenceLength_ = 0;
   } else if (this.sequenceDirection_ === step) {
     // Keeping going in sequence.
     this.sequenceLength_++;
   } else {
     // Reversed the direction. Reset the counter.
     this.sequenceDirection_ = step;
     this.sequenceLength_ = 1;
   }
 
-  this.displayedIndex_ = index;
+  this.displayedItem_ = this.getSelectedItem();
   var selectedItem = assertInstanceof(this.getSelectedItem(), Gallery.Item);
 
   if (this.sequenceLength_ <= 1) {
     // We have just broke the sequence. Touch the current image so that it stays
     // in the cache longer.
     this.imageView_.prefetch(selectedItem);
   }
 
   function shouldPrefetch(loadType, step, sequenceLength) {
     // Never prefetch when selecting out of sequence.
@@ skipping 50 matching lines @@
   ImageUtil.setAttribute(this.arrowBox_, 'active', this.getItemCount_() > 1);
 
   // Splice invalidates saved indices, drop the saved selection.
   this.savedSelection_ = null;
 
   if (event.removed.length != 1)
     return;
 
   // Delay the selection to let the ribbon splice handler work first.
   setTimeout(function() {
+    var displayedItemNotRemvoed = event.removed.every(function(item) {
+      return item !== this.displayedItem_;
+    }.bind(this));
+    if (displayedItemNotRemvoed)
+      return;
+    var nextIndex;
     if (event.index < this.dataModel_.length) {
       // There is the next item, select it.
       // The next item is now at the same index as the removed one, so we need
       // to correct displayIndex_ so that loadSelectedItem_ does not think
       // we are re-selecting the same item (and does right-to-left slide-in
       // animation).
-      this.displayedIndex_ = event.index - 1;
-      this.select(event.index);
+      nextIndex = event.index;
     } else if (this.dataModel_.length) {
       // Removed item is the rightmost, but there are more items.
-      this.select(event.index - 1);  // Select the new last index.
+      nextIndex = event.index - 1;  // Select the new last index.
     } else {
       // No items left. Unload the image, disable edit and print button, and
       // show the banner.
       this.commitItem_(function() {
         this.unloadImage_();
         this.printButton_.disabled = true;
         this.editButton_.disabled = true;
         this.errorBanner_.show('GALLERY_NO_IMAGES');
       }.bind(this));
+      return;
     }
+    // To force to dispatch a selection change event, clear selection before.
+    this.selectionModel_.clear();
+    this.select(nextIndex);
   }.bind(this), 0);
 };
 
 /**
  * @param {number} direction -1 for left, 1 for right.
  * @return {number} Next index in the given direction, with wrapping.
  * @private
  */
 SlideMode.prototype.getNextSelectedIndex_ = function(direction) {
   function advance(index, limit) {
@@ skipping 979 matching lines @@
   var event = assertInstanceof(event, MouseEvent);
   var viewport = this.slideMode_.getViewport();
   if (!this.enabled_ || !viewport.isZoomed())
     return;
   this.stopOperation();
   viewport.setOffset(
       viewport.getOffsetX() + event.wheelDeltaX,
       viewport.getOffsetY() + event.wheelDeltaY);
   this.slideMode_.applyViewportChange();
 };