[filemanager] Implementing undo delete functionality.

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 192 matching lines @@
                      fileManager.volumeManager_);
     this.metadataCache_ = fileManager.metadataCache_;
 
     this.filesystemChangeHandler_ =
         fileManager.updateMetadataInUI_.bind(fileManager, 'filesystem');
     this.thumbnailChangeHandler_ =
         fileManager.updateMetadataInUI_.bind(fileManager, 'thumbnail');
     this.gdataChangeHandler_ =
         fileManager.updateMetadataInUI_.bind(fileManager, 'gdata');
 
+    var dm = fileManager.directoryModel_;
+    this.internalChangeHandler_ = dm.rescan.bind(dm);
+
     this.filesystemObserverId_ = null;
     this.thumbnailObserverId_ = null;
     this.gdataObserverId_ = null;
+    this.internalObserverId_ = null;
 
     // Holds the directories known to contain files with stale metadata
     // as URL to bool map.
     this.directoriesWithStaleMetadata_ = {};
   };
 
   FileManager.MetadataFileWatcher.prototype.__proto__ = FileWatcher.prototype;
 
   /**
    * Changed metadata observers for the new directory.
    * @override
    * @param {DirectoryEntryi?} entry New watched directory entry.
    * @override
    */
-  FileManager.MetadataFileWatcher.prototype.changeWatchedEntry =
-      function(entry) {
+  FileManager.MetadataFileWatcher.prototype.changeWatchedEntry = function(
+      entry) {
     FileWatcher.prototype.changeWatchedEntry.call(this, entry);
 
     if (this.filesystemObserverId_)
       this.metadataCache_.removeObserver(this.filesystemObserverId_);
     if (this.thumbnailObserverId_)
       this.metadataCache_.removeObserver(this.thumbnailObserverId_);
     if (this.gdataObserverId_)
       this.metadataCache_.removeObserver(this.gdataObserverId_);
     this.filesystemObserverId_ = null;
     this.gdataObserverId_ = null;
+    this.internalObserverId_ = null;
     if (!entry)
       return;
 
     this.filesystemObserverId_ = this.metadataCache_.addObserver(
         entry,
         MetadataCache.CHILDREN,
         'filesystem',
         this.filesystemChangeHandler_);
 
     this.thumbnailObserverId_ = this.metadataCache_.addObserver(
         entry,
         MetadataCache.CHILDREN,
         'thumbnail',
         this.thumbnailChangeHandler_);
 
     if (PathUtil.getRootType(entry.fullPath) === RootType.GDATA) {
       this.gdataObserverId_ = this.metadataCache_.addObserver(
           entry,
           MetadataCache.CHILDREN,
           'gdata',
           this.gdataChangeHandler_);
     }
+
+    this.internalObserverId_ = this.metadataCache_.addObserver(
+        entry,
+        MetadataCache.CHILDREN,
+        'internal',
+        this.internalChangeHandler_);
   };
 
   /**
    * @override
    */
   FileManager.MetadataFileWatcher.prototype.onFileInWatchedDirectoryChanged =
       function() {
     FileWatcher.prototype.onFileInWatchedDirectoryChanged.apply(this);
     delete this.directoriesWithStaleMetadata_[
         this.getWatchedDirectoryEntry().toURL()];
@@ skipping 191 matching lines @@
   };
 
   FileManager.prototype.initDataTransferOperations_ = function() {
     this.copyManager_ = new FileCopyManagerWrapper.getInstance(
         this.filesystem_.root);
     this.copyManager_.addEventListener('copy-progress',
                                        this.onCopyProgress_.bind(this));
     this.copyManager_.addEventListener('copy-operation-complete',
         this.onCopyManagerOperationComplete_.bind(this));
 
-    this.butterBar_ = new ButterBar(this.dialogDom_, this.copyManager_);
+    this.butterBar_ = new ButterBar(this.dialogDom_, this.copyManager_,
+        this.metadataCache_);
 
     var controller = this.fileTransferController_ = new FileTransferController(
         GridItem.bind(null, this, false /* no checkbox */),
         this.copyManager_,
         this.directoryModel_);
     controller.attachDragSource(this.table_.list);
     controller.attachDropTarget(this.table_.list);
     controller.attachDragSource(this.grid_);
     controller.attachDropTarget(this.grid_);
     controller.attachDropTarget(this.rootsList_, true);
@@ skipping 787 matching lines @@
         return;
 
       case 'rename':
         this.initiateRename_();
         return;
 
       case 'delete':
         if (this.isRenamingInProgress())
           document.execCommand('delete');
         else
-          this.deleteEntries(this.selection.entries);
+          this.deleteSelection();
 
         return;
 
       case 'newfolder':
         this.onNewFolderCommand_(event);
         return;
 
       case 'unmount':
         this.unmountVolume_(this.directoryModel_.getCurrentRootPath());
         return;
@@ skipping 1332 matching lines @@
   };
 
   /**
    * Return URL of the current directory or null.
    */
   FileManager.prototype.getCurrentDirectoryURL = function() {
     return this.directoryModel_ &&
         this.directoryModel_.getCurrentDirEntry().toURL();
   };
 
-  FileManager.prototype.deleteEntries = function(entries, force, opt_callback) {
-    if (!force) {
+  FileManager.prototype.deleteSelection = function(entries) {
+/*    if (!force) {

[Vladislav Kaznacheev, 2012/09/04 14:50:38]

Commented code

[dgozman, 2012/09/07 11:05:10]

Done.

       var self = this;
       var msg;
       if (entries.length == 1) {
         msg = strf('CONFIRM_DELETE_ONE', entries[0].name);
       } else {
         msg = strf('CONFIRM_DELETE_SOME', entries.length);
       }
 
       this.confirm.show(msg, this.deleteEntries.bind(
           this, entries, true, opt_callback));
       return;
     }
+    this.directoryModel_.deleteEntries(entries);*/
 
-    this.directoryModel_.deleteEntries(entries, opt_callback);
+    this.butterBar_.initiateDelete(this.selection.entries);
   };
 
   FileManager.prototype.onDeleteButtonClick_ = function(event) {
-    this.deleteEntries(this.selection.entries);
+    this.deleteSelection();
     event.preventDefault();
     event.stopPropagation();
   };
 
   FileManager.prototype.onDeleteButtonKeyPress_ = function(event) {
     switch (util.getKeyModifiers(event) + event.keyCode) {
       case '13':  // Enter
       case '32':  // Space
-        this.deleteEntries(this.selection.entries);
+        this.deleteSelection();
         event.preventDefault();
         event.stopPropagation();
         break;
     }
   };
 
   FileManager.prototype.blinkSelection = function() {
     if (!this.selection || this.selection.totalCount == 0)
       return;
 
@@ skipping 1552 matching lines @@
         this.dialogDom_.querySelector('#default-action-separator');
 
     // TODO(dzvorygin): Here we use this hack, since 'hidden' is standard
     // attribute and we can't use it's setter as usual.
     this.openWithCommand_.__lookupSetter__('hidden').
         call(this.openWithCommand_, !(defaultItem && isMultiple));
     this.defaultActionMenuItem_.hidden = !defaultItem;
     defaultActionSeparator.hidden = !defaultItem;
   };
 })();