Fix Javascript errors occuring when a file is deleted during calculating it's size.

chrome/browser/resources/file_manager/js/file_selection.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';
 
 /**
  * The current selection object.
  *
  * @param {FileManager} fileManager FileManager instance.
  * @param {Array.<number>} indexes Selected indexes.
  * @constructor
  */
 function FileSelection(fileManager, indexes) {
   this.fileManager_ = fileManager;
+  this.sequenceIndex_ = 0;

[satorux1, 2013/04/19 07:52:18]

sequenceIndex_ may sound too general as this is only used for computeBytes().
Maybe:

computeBytesSequence_

[mtomasz, 2013/04/19 09:13:16]

Done.

   this.indexes = indexes;
   this.entries = [];
   this.urls = [];
   this.totalCount = 0;
   this.fileCount = 0;
   this.directoryCount = 0;
   this.bytes = 0;
   this.showBytes = false;
   this.allDriveFilesPresent = false,
   this.iconType = null;
-  this.cancelled_ = false;
   this.bytesKnown = false;
 
   // Synchronously compute what we can.
   for (var i = 0; i < this.indexes.length; i++) {
     var entry = fileManager.getFileList().item(this.indexes[i]);
     if (!entry)
       continue;
 
     this.entries.push(entry);
     this.urls.push(entry.toURL());
@@ skipping 39 matching lines @@
     });
 
     this.tasks.init(this.urls, this.mimeTypes);
     callback();
   }.bind(this));
 };
 
 /**
  * Computes the total size of selected files.
  *
- * @param {function} callback The callback.
+ * @param {function} callback Completion callback. Not called when cancelled,
+ *     or a new call has been invoked in the meantime.
  */
 FileSelection.prototype.computeBytes = function(callback) {
   if (this.entries.length == 0) {
     this.bytesKnown = true;
     this.bytes = 0;
     return;
   }
 
-  var countdown = this.entries.length;
+  var sequenceIndex = ++this.sequenceIndex_;
   var pendingMetadataCount = 0;
 
   var maybeDone = function() {
-    if (countdown == 0 && pendingMetadataCount == 0 && !this.cancelled_) {
+    if (pendingMetadataCount == 0) {
       this.bytesKnown = true;
       callback();
     }
   }.bind(this);
 
   var onProps = function(filesystem) {

[satorux1, 2013/04/19 07:52:18]

The parameter looks like a misnomer. We are getting properties of a file, right?

Maybe |filesystem| -> properties

[mtomasz, 2013/04/19 09:13:16]

This fetches the 'filesystem' metadata. Done.

-    this.bytes += filesystem.size;
+    // Ignore if the call got cancelled, or there is another new one fired.
+    if (sequenceIndex != this.sequenceIndex_)
+      return;
+
+    // It may happen that the metadata is not available because a file has been
+    // deleted in the meantime.
+    if (filesystem)
+      this.bytes += filesystem.size;
     pendingMetadataCount--;
     maybeDone();
   }.bind(this);
 
   for (var index = 0; index < this.entries.length; index++) {
-    if (this.cancelled_)
-      break;
-
     var entry = this.entries[index];
     if (entry.isFile) {
       this.showBytes |= !FileType.isHosted(entry);
       pendingMetadataCount++;
       this.fileManager_.metadataCache_.get(entry, 'filesystem', onProps);
     } else if (entry.isDirectory) {
       // Don't compute the directory size as it's expensive.
       // crbug.com/179073.
       this.showBytes = false;
-      countdown = 0;
       break;
     }
-    countdown--;
   }
   maybeDone();
 };
 
 /**
  * Cancels any async computation.
  *
  * @private
  */
 FileSelection.prototype.cancelComputing_ = function() {
-  this.cancelled_ = true;
+  this.sequenceIndex_++;

[satorux1, 2013/04/19 07:52:18]

Maybe add some comment?

This will invalidate the sequence number used in the inflight computeBytes()
operation, hence cancel the operation.

[mtomasz, 2013/04/19 09:13:16]

Done.

 };
 
 /**
  * This object encapsulates everything related to current selection.
  *
  * @param {FileManager} fileManager File manager instance.
  * @constructor
  */
 function FileSelectionHandler(fileManager) {
   this.fileManager_ = fileManager;
@@ skipping 543 matching lines @@
   style.left = (boxWidth - imageWidth) / 2 + 'px';
   style.top = (boxHeight - imageHeight) / 2 + 'px';
   style.position = 'relative';
 
   util.applyTransform(largeImage, transform);
 
   largeImageBox.appendChild(largeImage);
   largeImageBox.style.zIndex = 1000;
   return true;
 };