In FileManager send 'on-completed' event only when a scan is completed. Send 'on-cancelled' event w…

chrome/browser/resources/file_manager/js/directory_contents.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.
 
 /**
  * @constructor
  * @param {MetadataCache} metadataCache Metadata cache service.
  * @param {cr.ui.ArrayDataModel} fileList The file list.
  * @param {boolean} showHidden If files starting with '.' are shown.
  */
@@ skipping 72 matching lines @@
  * @constructor
  * @param {FileListContext} context The file list context.
  */
 function DirectoryContents(context) {
   this.context_ = context;
   this.fileList_ = context.fileList;
   this.scanCompletedCallback_ = null;
   this.scanFailedCallback_ = null;
   this.scanCancelled_ = false;
   this.filter_ = context.filter.bind(context);
-
+  this.allChunksFetched_ = false;
+  this.pendingMetadataRequests_ = 0;
   this.fileList_.prepareSort = this.prepareSort_.bind(this);
 }
 
 /**
  * DirectoryModel extends cr.EventTarget.
  */
 DirectoryContents.prototype.__proto__ = cr.EventTarget.prototype;
 
 /**
  * Create the copy of the object, but without scan started.
@@ skipping 23 matching lines @@
     spliceArgs.unshift(0, fileList.length);
     fileList.splice.apply(fileList, spliceArgs);
     this.fileList_ = fileList;
   }
 };
 
 /**
  * @return {string} The path.
  */
 DirectoryContents.prototype.getPath = function() {
-  console.log((new Error()).stack);
   throw 'Not implemented.';
 };
 
 /**
+ * @return {boolean} If the scan is active.
+ */
+DirectoryContents.prototype.isScanning = function() {
+  return !this.scanCancelled_ &&
+         (!this.allChunksFetched_ || this.pendingMetadataRequests_ > 0);
+};
+
+/**
  * @return {boolean} True if search results (gdata or local).
  */
 DirectoryContents.prototype.isSearch = function() {
   return false;
 };
 
 /**
  * @return {DirectoryEntry} A DirectoryEntry for current directory. In case of
  *     search -- the top directory from which search is run
  */
@@ skipping 23 matching lines @@
  */
 DirectoryContents.prototype.readNextChunk = function() {
   throw 'Not implemented.';
 };
 
 /**
  * Cancel the running scan.
  */
 DirectoryContents.prototype.cancelScan = function() {
   this.scanCancelled_ = true;
+  cr.dispatchSimpleEvent(this, 'scan-cancelled');
 };
 
 
 /**
  * Called in case scan has failed. Should send the event.
  * @protected
  */
 DirectoryContents.prototype.onError = function() {
   cr.dispatchSimpleEvent(this, 'scan-failed');
 };
 
 /**
  * Called in case scan has completed succesfully. Should send the event.
  * @protected
  */
-DirectoryContents.prototype.onCompleted = function() {
-  cr.dispatchSimpleEvent(this, 'scan-completed');
+DirectoryContents.prototype.lastChunkReceived = function() {
+  this.allChunksFetched_ = true;
+  if (!this.scanCancelled_ && this.pendingMetadataRequests_ === 0)
+    cr.dispatchSimpleEvent(this, 'scan-completed');
 };
 
 /**
  * Cache necessary data before a sort happens.
  *
  * This is called by the table code before a sort happens, so that we can
  * go fetch data for the sort field that we may not have yet.
  * @private
  * @param {string} field Sort field.
  * @param {function} callback Called when done.
@@ skipping 14 matching lines @@
  * @protected
  * @param {Array.<Entry>} entries File list.
  */
 DirectoryContents.prototype.onNewEntries = function(entries) {
   if (this.scanCancelled_)
     return;
 
   var entriesFiltered = [].filter.call(entries, this.filter_);
 
   var onPrefetched = function() {
+    this.pendingMetadataRequests_--;
     if (this.scanCancelled_)
       return;
     this.fileList_.push.apply(this.fileList_, entriesFiltered);
-    this.readNextChunk();
+
+    if (this.pendingMetadataRequests === 0 && this.allChunksFetched_) {
+      cr.dispatchSimpleEvent(this, 'scan-completed');

[dgozman, 2012/08/13 12:58:08]

Forgot |!this.scanCacelled_|.

Maybe, create a method to check all 3 conditions and fire scan-completed?

[Oleg Eterevsky, 2012/08/13 13:32:22]

scanCancelled_ checked 3 lines above. I don't want to create a separate function
because the conditions still have to be checked here, to decide whether to call
readNextChunk().

+    } else {
+      this.readNextChunk();

[dgozman, 2012/08/13 13:36:48]

I believe, this is called if there is pending metadata request, but all chunks
are already fetched.

[Oleg Eterevsky, 2012/08/13 13:39:40]

You're right. Fixed.

+    }
   };
 
+  this.pendingMetadataRequests_++;
   this.prefetchMetadata(entriesFiltered, onPrefetched.bind(this));
 };
 
 /**
  * @param {string} name Directory name.
  * @param {function} successCallback Called on success.
  * @param {function} errorCallback On error.
  */
 DirectoryContents.prototype.createDirectory = function(
     name, successCallback, errorCallback) {
@@ skipping 62 matching lines @@
 
 /**
  * @private
  * @param {Array.<Entry>} entries File list.
  */
 DirectoryContentsBasic.prototype.onChunkComplete_ = function(entries) {
   if (this.scanCancelled_)
     return;
 
   if (entries.length == 0) {
-    this.onCompleted();
+    this.lastChunkReceived();
     this.recordMetrics_();
     return;
   }
 
   this.onNewEntries(entries);
 };
 
 /**
  * @private
  */
@@ skipping 94 matching lines @@
 
 /**
  * All the results are read in one chunk, so when we try to read second chunk,
  * it means we're done.
  */
 DirectoryContentsGDataSearch.prototype.readNextChunk = function() {
   if (this.scanCancelled_)
     return;
 
   if (this.done_) {
-    this.onCompleted();
+    this.lastChunkReceived();

[dgozman, 2012/08/13 12:58:08]

May this call fire event for the second time?

[Oleg Eterevsky, 2012/08/13 13:32:22]

It shouldn't. readNextChunk() is called from onPrefetched() only if
allChunksFetched_ is not set yet.

     return;
   }
 
   var searchCallback = (function(entries, nextFeed) {
     // TODO(tbarzic): Improve error handling.
     if (!entries) {
       console.log('Drive search encountered an error');
-      this.onCompleted();
+      this.lastChunkReceived();
       return;
     }
     this.nextFeed_ = nextFeed;
     this.fetchedResultsNum_ += entries.length;
     if (this.fetchedResultsNum_ >= DirectoryContentsGDataSearch.MAX_RESULTS)
       this.nextFeed_ = '';
 
     this.done_ = (this.nextFeed_ == '');
     this.onNewEntries(entries);
   }).bind(this);
@@ skipping 73 matching lines @@
 /**
  * Scan a directory.
  * @param {DirectoryEntry} entry A directory to scan.
  * @private
  */
 DirectoryContentsLocalSearch.prototype.scanDirectory_ = function(entry) {
   this.pendingScans_++;
   var reader = entry.createReader();
   var found = [];
 
-  var self = this;
-
   var onChunkComplete = function(entries) {
-    if (self.scanCancelled_)
+    if (this.scanCancelled_)
       return;
 
     if (entries.length === 0) {
       if (found.length > 0)
-        self.onNewEntries(found);
-      self.pendingScans_--;
-
-      if (self.pendingScans_ === 0)
-        self.onCompleted();
-
+        this.onNewEntries(found);
+      this.pendingScans_--;
+      if (this.pendingScans_ === 0)
+        this.lastChunkReceived();
       return;
     }
 
     for (var i = 0; i < entries.length; i++) {
-      if (entries[i].name.toLowerCase().indexOf(self.query_) != -1) {
+      if (entries[i].name.toLowerCase().indexOf(this.query_) != -1) {
         found.push(entries[i]);
       }
 
       if (entries[i].isDirectory)
-        self.scanDirectory_(entries[i]);
+        this.scanDirectory_(entries[i]);
     }
 
     getNextChunk();
-  };
+  }.bind(this);
 
   var getNextChunk = function() {
-    reader.readEntries(onChunkComplete, self.onError.bind(self));
-  };
+    reader.readEntries(onChunkComplete, this.onError.bind(this));
+  }.bind(this);
 
   getNextChunk();
 };
 
 /**
  * We get results for each directory in one go in scanDirectory_.
  */
 DirectoryContentsLocalSearch.prototype.readNextChunk = function() {
 };