Remove unavailable shortcut silently instead of showing a confirmation dialog

chrome/browser/resources/file_manager/js/navigation_list.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.
 
 'use strict';
 
 /**
  * Entry of NavigationListModel. This construtor should be called only from
  * the helper methods (NavigationModelItem.createWithPath/createWithEntry).
  *
  * @param {FileSystem} filesystem Fielsystem.
  * @param {?string} path Path.
  * @param {DirectoryEntry} entry Entry. Can be a fake.
  * @extends {cr.EventTarget}
  * @constructor
  */
 function NavigationModelItem(filesystem, path, entry) {
   this.filesystem_ = filesystem;
   this.path_ = path;
   this.entry_ = entry;
+  this.fileError_ = null;
 
   this.resolvingQueue_ = new AsyncUtil.Queue();
+
+  Object.seal(this);
 }
 
 NavigationModelItem.prototype = {
-  __proto__: cr.EventTarget.prototype,
-  get path() { return this.path_; }
+  get path() { return this.path_; },
+  get fileError() { return this.fileError_; }
 };
 
 /**
  * Returns the cached entry of the item. This may returns NULL if the target is
  * not available on the filesystem, is not resolved or is under resolving the
  * entry.
  *
  * @return {Entry} Cached entry.
  */
 NavigationModelItem.prototype.getCachedEntry = function() {
   return this.entry_;
 };
 
 /**
  * @param {FileSystem} filesystem FileSystem.
  * @param {string} path Path.
+ * @param {function(NavigationModelItem)} callback Called when the resolving is
+ *     success/failed with the created NavigationModelItem.
  * @return {NavigationModelItem} Created NavigationModelItem.
  */
-NavigationModelItem.createWithPath = function(filesystem, path) {
+NavigationModelItem.createWithPath = function(filesystem, path, callback) {
   var modelItem = new NavigationModelItem(
       filesystem,
       path,
       null);
-  modelItem.resolveDirectoryEntry_();
+  modelItem.resolveDirectoryEntry_(function() {
+    callback(modelItem);
+  });
   return modelItem;
 };
 
 /**
  * @param {DirectoryEntry} entry Entry. Can be a fake.
  * @return {NavigationModelItem} Created NavigationModelItem.
  */
 NavigationModelItem.createWithEntry = function(entry) {
   if (entry) {
     return new NavigationModelItem(
@@ skipping 16 matching lines @@
 NavigationModelItem.prototype.getEntryAsync = function(callback) {
   // If resolveDirectoryEntry_() is running, waits until it finishes.
   this.resolvingQueue_.run(function(continueCallback) {
     callback(this.entry_);
     continueCallback();
   }.bind(this));
 };
 
 /**
  * Resolves an directory entry.
+ * @param {function()} callback Called when the resolving is success/failed.
  * @private
  */
-NavigationModelItem.prototype.resolveDirectoryEntry_ = function() {
+NavigationModelItem.prototype.resolveDirectoryEntry_ = function(callback) {
   this.resolvingQueue_.run(function(continueCallback) {
     this.filesystem_.root.getDirectory(
         this.path_,
         {create: false},
         function(directoryEntry) {
           this.entry_ = directoryEntry;
+          callback();
           continueCallback();
         }.bind(this),
         function(error) {
           this.entry_ = null;
+          this.fileError_ = error;
           console.error('Error on resolving path: ' + this.path_);
+          callback();
           continueCallback();
         }.bind(this));
   }.bind(this));
 };
 
 /**
  * Returns if this item is a shortcut or a volume root.
  * @return {boolean} True if a shortcut, false if a volume root.
  */
 NavigationModelItem.prototype.isShortcut = function() {
@@ skipping 12 matching lines @@
   this.volumesListModel_ = volumesList;
   this.shortcutListModel_ = shortcutList;
 
   // On default, shortcut list is disabled. It may be enabled on initializetion.
   this.showShortcuts_ = false;
 
   var entryToModelItem = function(entry) {
     return NavigationModelItem.createWithEntry(entry);
   };
   var pathToModelItem = function(path) {
-    return NavigationModelItem.createWithPath(filesystem, path);
-  };
+    return NavigationModelItem.createWithPath(filesystem, path,
+        function(modelItem) {
+          if (!modelItem.getCachedEntry() &&
+              modelItem.fileError &&
+              modelItem.fileError.code === FileError.NOT_FOUND_ERR) {
+            this.onItemNotFoundError(modelItem);
+          }
+        }.bind(this));
+  }.bind(this);
 
   /**
    * Type of updated list.
    * @enum {number}
    * @const
    */
   var ListType = {
     VOLUME_LIST: 1,
     SHORTCUT_LIST: 2
   };
@@ skipping 175 matching lines @@
  */
 NavigationListModel.prototype.indexOf = function(modelItem, opt_fromIndex) {
   for (var i = opt_fromIndex || 0; i < this.length; i++) {
     if (modelItem === this.item(i))
       return i;
   }
   return -1;
 };
 
 /**
+ * Called when one od the items is not found on the filesystem.
+ * @param {NavigationModelItem} modelItem The entry which is not found.
+ */
+NavigationListModel.prototype.onItemNotFoundError = function(modelItem) {
+  var index = this.indexOf(modelItem);
+  if (index === -1) {
+    // Invalid modelItem.
+  } else if (index < this.volumesList_.length) {
+    // The item is in the volume list.
+    // Not implemented.
+    // TODO(yoshiki): Implement it when necessary.
+  } else {
+    // The item is in the folder shortcut list.
+    if (this.isDriveMounted())
+      this.shortcutListModel_.remove(modelItem.path);
+  }
+};
+
+/**
+ * Returns if the drive is mounted or not.
+ * @return {boolean} True if the drive is mounted, false otherwise.
+ */
+NavigationListModel.prototype.isDriveMounted = function() {
+  for (var i = 0; i < this.volumesList_.length; i++) {
+    if (PathUtil.isDriveBasedPath(this.item(i).path))
+      return true;
+  }
+  return false;
+};
+
+/**
  * A navigation list item.
  * @constructor
  * @extends {HTMLLIElement}
  */
 var NavigationListItem = cr.ui.define('li');
 
 NavigationListItem.prototype = {
   __proto__: HTMLLIElement.prototype,
-  get modelItem() { return this.modelItem_; },
+  get modelItem() { return this.modelItem_; }
 };
 
 /**
  * Decorate the item.
  */
 NavigationListItem.prototype.decorate = function() {
   // decorate() may be called twice: from the constructor and from
   // List.createItem(). This check prevents double-decorating.
   if (this.className)
     return;
@@ skipping 229 matching lines @@
 
   // TODO(yoshiki): Animation is temporary disabled for volumes. Add animation
   // back. crbug.com/276132.
   item.setFadeinAnimation(modelItem.isShortcut() &&
                           !this.measuringTemporaryItemNow_);
 
   var handleClick = function() {
     if (item.selected &&
         modelItem.path !== this.directoryModel_.getCurrentDirPath()) {
       metrics.recordUserAction('FolderShortcut.Navigate');
-      this.changeDirectory_(modelItem.path);
+      this.changeDirectory_(modelItem);
     }
   }.bind(this);
   item.addEventListener('click', handleClick);
 
   var handleEject = function() {
     var unmountCommand = cr.doc.querySelector('command#unmount');
     // Let's make sure 'canExecute' state of the command is properly set for
     // the root before executing it.
     unmountCommand.canExecuteChange(item);
     unmountCommand.execute(item);
   };
   item.addEventListener('eject', handleEject);
 
   if (this.contextMenu_)
     item.maybeSetContextMenu(this.contextMenu_);
 
   return item;
 };
 
 /**
  * Changes the current directory to the given path.
  * If the given path is not found, a 'shortcut-target-not-found' event is
  * fired.
  *
- * @param {string} path Path of the directory to be chagned to.
+ * @param {NavigationModelItem} modelItem Directory to be chagned to.
  * @private
  */
-NavigationList.prototype.changeDirectory_ = function(path) {
-  var onErrorCallback = function() {
-    // TODO(yoshiki): Remove this if the teporary patch is merged to the M30.
-    // crbug.com/270436
+NavigationList.prototype.changeDirectory_ = function(modelItem) {
+  var onErrorCallback = function(error) {
+    if (error.code === FileError.NOT_FOUND_ERR)
+      this.dataModel.onItemNotFoundError(modelItem);
   }.bind(this);
 
-  this.directoryModel_.changeDirectory(path, onErrorCallback);
+  this.directoryModel_.changeDirectory(modelItem.path, onErrorCallback);
 };
 
 /**
  * Sets a context menu. Context menu is enabled only on archive and removable
  * volumes as of now.
  *
  * @param {cr.ui.Menu} menu Context menu.
  */
 NavigationList.prototype.setContextMenu = function(menu) {
   this.contextMenu_ = menu;
 
   for (var i = 0; i < this.dataModel.length; i++) {
     this.getListItemByIndex(i).maybeSetContextMenu(this.contextMenu_);
   }
 };
 
 /**
  * Selects the n-th item from the list.
  *
  * @param {number} index Item index.
  * @return {boolean} True for success, otherwise false.
  */
 NavigationList.prototype.selectByIndex = function(index) {
   if (index < 0 || index > this.dataModel.length - 1)
     return false;
 
-  var newPath = this.dataModel.item(index).path;
+  var newModelItem = this.dataModel.item(index);
+  var newPath = newModelItem.path;
   if (!newPath)
     return false;
 
   // Prevents double-moving to the current directory.
   // eg. When user clicks the item, changing directory has already been done in
   //     click handler.
   if (this.directoryModel_.getCurrentDirEntry().fullPath == newPath)
     return false;
 
   metrics.recordUserAction('FolderShortcut.Navigate');
-  this.changeDirectory_(newPath);
+  this.changeDirectory_(newModelItem);
   return true;
 };
 
 /**
  * Handler before root item change.
  * @param {Event} event The event.
  * @private
  */
 NavigationList.prototype.onBeforeSelectionChange_ = function(event) {
   if (event.changes.length == 1 && !event.changes[0].selected)
@@ skipping 69 matching lines @@
     var itemPath = this.dataModel.item(i).path;
     if (PathUtil.getRootPath(itemPath) == newRootPath) {
       // Not to invoke the handler of this instance, sets the guard.
       this.dontHandleSelectionEvent_ = true;
       this.selectionModel.selectedIndex = i;
       this.dontHandleSelectionEvent_ = false;
       return;
     }
   }
 };