Extract ContentScanner from DirectoryContent.

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.
 
 'use strict';
 
 /**
+ * Scanner of the entries.

[mtomasz, 2013/10/01 02:13:44]

@constructor is missing

[hidehiko, 2013/10/01 04:12:23]

Done.

+ */
+function ContentScanner() {
+  this.cancelled_ = false;
+}
+
+/**
+ * Starts to scan the entries. For example, starts to read the entries in a
+ * directory, or starts to search with some query on a file system.

[mtomasz, 2013/10/01 02:13:44]

nit: Please add a new line after the description in log jsdocs for better
readability.

[hidehiko, 2013/10/01 04:12:23]

Done.

+ * Derived classes must override this method.
+ * @param {function(Array.<Entry>)} entriesCallback Called when some chunk of
+ *     entries are read. This can be called a couple of times until the
+ *     completion.
+ * @param {function()} successCallback Called when the scan is completed
+ *     successfully.
+ * @param {function(FileError)} errorCallback Called an error occurs.
+ */
+ContentScanner.prototype.startScan = function(
+    entriesCallback, successCallback, errorCallback) {
+};
+
+/**
+ * Request cancelling of the running scan. When the cancelling is done,
+ * an error will be reported from errorCallback passed to startScan().
+ */
+ContentScanner.prototype.cancel = function() {
+  this.cancelled_ = true;
+};
+
+/**
+ * Scanner of the entries in a directory.
+ * @param {DirectoryEntry} entry The directory to be read.
+ * @extends {ContentScanner}

[mtomasz, 2013/10/01 02:13:44]

@constructor is missing

[hidehiko, 2013/10/01 04:12:23]

Done.

+ */
+function DirectoryContentScanner(entry) {
+  ContentScanner.call(this);
+  this.entry_ = entry;
+}
+
+/**
+ * Extends ContentScanner.
+ */
+DirectoryContentScanner.prototype.__proto__ = ContentScanner.prototype;
+
+/**
+ * Starts to read the entries in the directory.
+ * @param {function(Array.<Entry>)} entriesCallback Called when some chunk of
+ *     entries are read. This can be called a couple of times until the
+ *     completion.
+ * @param {function()} successCallback Called when the scan is completed
+ *     successfully.
+ * @param {function(FileError)} errorCallback Called an error occurs.

[mtomasz, 2013/10/01 02:13:44]

@override is missing

[hidehiko, 2013/10/01 04:12:23]

Done.

+ */
+DirectoryContentScanner.prototype.startScan = function(
+    entriesCallback, successCallback, errorCallback) {
+  if (!this.entry_ || this.entry_ === DirectoryModel.fakeDriveEntry_) {
+    // If entry is not specified or a fake, we cannot read it.
+    errorCallback(util.createFileError(FileError.INVALID_MODIFICATION_ERR));
+    return;
+  }
+
+  metrics.startInterval('DirectoryScan');
+  var reader = this.entry_.createReader();
+  var readEntries = function() {
+    reader.readEntries(
+        function(entries) {
+          if (this.cancelled_) {
+            errorCallback(util.createFileError(FileError.ABORT_ERR));
+            return;
+          }
+
+          if (entries.length === 0) {
+            // All entries are read.
+            metrics.recordInterval('DirectoryScan');
+            successCallback();
+            return;
+          }
+
+          entriesCallback(entries);
+          readEntries();
+        }.bind(this),
+        errorCallback);
+  }.bind(this);
+  readEntries();
+};
+
+/**
+ * Scanner of the entries for the search results on Drive File System.
+ * @param {string} query The query string.
+ * @extends {ContentScanner}

[mtomasz, 2013/10/01 02:13:44]

ditto (@constructor)

[hidehiko, 2013/10/01 04:12:23]

Done.

+ */
+function DriveSearchContentScanner(query) {
+  ContentScanner.call(this);
+  this.query_ = query;
+}
+
+/**
+ * Extends ContentScanner.
+ */
+DriveSearchContentScanner.prototype.__proto__ = ContentScanner.prototype;
+
+/**
+ * Delay to be used for drive search scan, in order to reduce the number of
+ * server requests while user is typeing the query.

[mtomasz, 2013/10/01 02:13:44]

nit: typeing -> typing
nit: in milliseconds (we always specify units)

[hidehiko, 2013/10/01 04:12:23]

Done.

+ * @type {number}
+ * @private
+ * @const
+ */
+DriveSearchContentScanner.SCAN_DELAY_ = 200;
+
+/**
+ * Maximum number of results which is shown on the search.
+ * @type {number}
+ * @private
+ * @const
+ */
+DriveSearchContentScanner.MAX_RESULTS_ = 100;
+
+/**
+ * Starts to search on Drive File System.
+ * @param {function(Array.<Entry>)} entriesCallback Called when some chunk of
+ *     entries are read. This can be called a couple of times until the
+ *     completion.
+ * @param {function()} successCallback Called when the scan is completed
+ *     successfully.
+ * @param {function(FileError)} errorCallback Called an error occurs.

[mtomasz, 2013/10/01 02:13:44]

nit: ditto (@override)

[hidehiko, 2013/10/01 04:12:23]

Done.

+ */
+DriveSearchContentScanner.prototype.startScan = function(
+    entriesCallback, successCallback, errorCallback) {
+  var numReadEntries = 0;
+  var readEntries = function(nextFeed) {
+    chrome.fileBrowserPrivate.searchDrive(
+        {query: this.query_, nextFeed: nextFeed},
+        function(entries, nextFeed) {
+          if (this.cancelled_) {
+            errorCallback(util.createFileError(FileError.ABORT_ERR));
+            return;
+          }
+
+          // TODO(tbarzic): Improve error handling.
+          if (!entries) {
+            console.error('Drive search encountered an error.');
+            errorCallback(util.createFileError(
+                FileError.INVALID_MODIFICATION_ERR));
+            return;
+          }
+
+          var numRemainingEntries =
+              DriveSearchContentScanner.MAX_RESULTS_ - numReadEntries;
+          if (entries.length >= numRemainingEntries) {
+            // The limit is hit, so quit the scan here.
+            entries = entries.slice(0, numRemainingEntries);
+            nextFeed = '';
+          }
+
+          numReadEntries += entries.length;
+          if (entries.length > 0)
+            entriesCallback(entries);
+
+          if (nextFeed === '')
+            successCallback();
+          else
+            readEntries(nextFeed);
+        }.bind(this));
+  }.bind(this);
+
+  // Let's give another search a chance to cancel us before we begin.
+  setTimeout(
+      function() {
+        // Check cancelled state before read the entries.
+        if (this.cancelled_) {
+          errorCallback(util.createFileError(FileError.ABORT_ERR));
+          return;
+        }
+        readEntries('');
+      }.bind(this),
+      DriveSearchContentScanner.SCAN_DELAY_);
+};
+
+/**
+ * Scanner of the entries of the file name search on the directory tree, whose
+ * root is entry.
+ * @param {DirectoryEntry} entry The root of the search target directory tree.
+ * @param {string} query The query of the search.

[mtomasz, 2013/10/01 02:13:44]

ditto

[hidehiko, 2013/10/01 04:12:23]

Done.

+ */
+function LocalSearchContentScanner(entry, query) {
+  ContentScanner.call(this);
+  this.entry_ = entry;
+  this.query_ = query.toLowerCase();
+}
+
+/**
+ * Extedns ContentScanner.
+ */
+LocalSearchContentScanner.prototype.__proto__ = ContentScanner.prototype;
+
+/**
+ * Starts the file name search.
+ * @param {function(Array.<Entry>)} entriesCallback Called when some chunk of
+ *     entries are read. This can be called a couple of times until the
+ *     completion.
+ * @param {function()} successCallback Called when the scan is completed
+ *     successfully.
+ * @param {function(FileError)} errorCallback Called an error occurs.

[mtomasz, 2013/10/01 02:13:44]

ditto here and in other places

[hidehiko, 2013/10/01 04:12:23]

Done.

+ */
+LocalSearchContentScanner.prototype.startScan = function(
+    entriesCallback, successCallback, errorCallback) {
+  var numRunningTasks = 0;
+  var error = null;
+  var maybeRunCallback = function() {
+    if (numRunningTasks === 0) {
+      if (this.cancelled_)
+        errorCallback(util.createFileError(FileError.ABORT_ERR));
+      else if (error)
+        errorCallback(error);
+      else
+        successCallback();
+    }
+  }.bind(this);
+
+  var processEntry = function(entry) {
+    numRunningTasks++;
+    var onError = function(fileError) {
+      if (!error)
+        error = fileError;
+      numRunningTasks--;
+      maybeRunCallback();
+    };
+
+    var onSuccess = function(entries) {
+      if (this.cancelled_ || error || entries.length === 0) {
+        numRunningTasks--;
+        maybeRunCallback();
+        return;
+      }
+
+      // Filters by the query, and if found, run entriesCallback.
+      var foundEntries = entries.filter(function(entry) {
+        return entry.name.toLowerCase().indexOf(this.query_) >= 0;
+      }.bind(this));
+      if (foundEntries.length > 0)
+        entriesCallback(foundEntries);
+
+      // Start to process sub directories.
+      for (var i = 0; i < entries.length; i++) {
+        if (entries[i].isDirectory)
+          processEntry(entries[i]);
+      }
+
+      // Read remaining entries.
+      reader.readEntries(onSuccess, onError);
+    }.bind(this);
+
+    var reader = entry.createReader();
+    reader.readEntries(onSuccess, onError);
+  }.bind(this);
+
+  processEntry(this.entry_);
+};
+
+/**
+ * Scanner of the entries for the metadata seaerch on Drive File System.
+ * @param {string} query The query of the search.
+ * @param {DriveMetadataSearchContentScanner.SearchType} searchType The option
+ *     of the search.
+ * @extends {ContentScanner}
+ */
+function DriveMetadataSearchContentScanner(query, searchType) {
+  ContentScanner.call(this);
+  this.query_ = query;
+  this.searchType_ = searchType;
+}
+
+/**
+ * Extends ContentScanner.
+ */
+DriveMetadataSearchContentScanner.prototype.__proto__ =
+    ContentScanner.prototype;
+
+/**
+ * The search types on the Drive File System.

[mtomasz, 2013/10/01 02:13:44]

@enum {string} missing

[hidehiko, 2013/10/01 04:12:23]

Done.

+ */
+DriveMetadataSearchContentScanner.SearchType = Object.freeze({
+  SEARCH_ALL: 'ALL',
+  SEARCH_SHARED_WITH_ME: 'SHARED_WITH_ME',
+  SEARCH_RECENT_FILES: 'EXCLUDE_DIRECTORIES',
+  SEARCH_OFFLINE: 'OFFLINE'
+});
+
+/**
+ * Starts to metadata-search on Drive File System.
+ * @param {function(Array.<Entry>)} entriesCallback Called when some chunk of
+ *     entries are read. This can be called a couple of times until the
+ *     completion.
+ * @param {function()} successCallback Called when the scan is completed
+ *     successfully.
+ * @param {function(FileError)} errorCallback Called an error occurs.
+ */
+DriveMetadataSearchContentScanner.prototype.startScan = function(

[mtomasz, 2013/10/01 02:13:44]

optional: how about just scan() instead of startScan()?

[hidehiko, 2013/10/01 04:12:23]

Done.

+    entriesCallback, successCallback, errorCallback) {
+  chrome.fileBrowserPrivate.searchDriveMetadata(
+      {query: this.query_, types: this.searchType_, maxResults: 500},
+      function(results) {
+        if (this.cancelled_) {
+          errorCallback(util.createFileError(FileError.ABORT_ERR));
+          return;
+        }
+
+        if (!results) {
+          console.error('Drive search encountered an error.');
+          errorCallback(util.createFileError(
+              FileError.INVALID_MODIFICATION_ERR));
+          return;
+        }
+
+        var entries = results.map(function(result) { return result.entry; });
+        if (entries.length > 0)
+          entriesCallback(entries);
+        successCallback();
+      }.bind(this));
+};
+
+/**
  * This class manages filters and determines a file should be shown or not.
  * When filters are changed, a 'changed' event is fired.
  *
  * @param {MetadataCache} metadataCache Metadata cache service.
  * @param {boolean} showHidden If files starting with '.' are shown.
  * @constructor
  * @extends {cr.EventTarget}
  */
 function FileFilter(metadataCache, showHidden) {
   /**
    * @type {MetadataCache}
    * @private
    */
   this.metadataCache_ = metadataCache;
+
   /**
    * @type Object.<string, Function>
    * @private
    */
   this.filters_ = {};
   this.setFilterHidden(!showHidden);
 
   // Do not show entries marked as 'deleted'.
   this.addFilter('deleted', function(entry) {
     var internal = this.metadataCache_.getCached(entry, 'internal');
@@ skipping 63 matching lines @@
  *
  * @param {FileFilter} fileFilter The file-filter context.
  * @param {MetadataCache} metadataCache Metadata cache service.
  * @constructor
  */
 function FileListContext(fileFilter, metadataCache) {
   /**
    * @type {cr.ui.ArrayDataModel}
    */
   this.fileList = new cr.ui.ArrayDataModel([]);
+
   /**
    * @type {MetadataCache}
    */
   this.metadataCache = metadataCache;
 
   /**
    * @type {FileFilter}
    */
   this.fileFilter = fileFilter;
 }
 
 /**
  * This class is responsible for scanning directory (or search results),
  * and filling the fileList. Different descendants handle various types of
  * directory contents shown: basic directory, drive search results, local search
  * results.
  * @param {FileListContext} context The file list context.
  * @constructor
  * @extends {cr.EventTarget}
  */
 function DirectoryContents(context) {
   this.context_ = context;
   this.fileList_ = context.fileList;
-  this.scanCompletedCallback_ = null;
-  this.scanFailedCallback_ = null;
+  this.prefetchMetadataQueue_ = new AsyncUtil.Queue();
   this.scanCancelled_ = false;
-  this.allChunksFetched_ = false;
-  this.pendingMetadataRequests_ = 0;
   this.fileList_.prepareSort = this.prepareSort_.bind(this);
 }
 
 /**
  * DirectoryContents 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 {boolean} If the scan is active.
  */
 DirectoryContents.prototype.isScanning = function() {
-  return !this.scanCancelled_ &&
-         (!this.allChunksFetched_ || this.pendingMetadataRequests_ > 0);
+  return this.scanner_ || this.prefetchMetadataQueue_.isRunning();
 };
 
 /**
  * @return {boolean} True if search results (drive or local).
  */
 DirectoryContents.prototype.isSearch = function() {
   return false;
 };
 
 /**
@@ skipping 13 matching lines @@
 
 /**
  * Start directory scan/search operation. Either 'scan-completed' or
  * 'scan-failed' event will be fired upon completion.
  */
 DirectoryContents.prototype.scan = function() {
   throw 'Not implemented.';
 };
 
 /**
- * Read next chunk of results from DirectoryReader.
- * @protected
- */
-DirectoryContents.prototype.readNextChunk = function() {
-  throw 'Not implemented.';
-};
-
-/**
- * Cancel the running scan.
+ * Cancels the running scan.
  */
 DirectoryContents.prototype.cancelScan = function() {
   if (this.scanCancelled_)
     return;
   this.scanCancelled_ = true;
+  if (this.scanner_)
+    this.scanner_.cancel();
+
+  this.prefetchMetadataQueue_.cancel();
   cr.dispatchSimpleEvent(this, 'scan-cancelled');
 };
 
+/**
+ * Called when the scanning by scanner_ is done.
+ * @protected
+ */
+DirectoryContents.prototype.onScanCompleted = function() {
+  this.scanner_ = null;
+  if (this.scanCancelled_)
+    return;
+
+  this.prefetchMetadataQueue_.run(function(callback) {
+    cr.dispatchSimpleEvent(this, 'scan-completed');
+    if (!this.isSearch() &&
+        this.getDirectoryEntry().fullPath === RootDirectory.DOWNLOADS)
+      metrics.recordMediumCount('DownloadsCount', this.fileList_.length);
+    callback();
+  }.bind(this));
+};
 
 /**
  * Called in case scan has failed. Should send the event.
  * @protected
  */
-DirectoryContents.prototype.onError = function() {
-  cr.dispatchSimpleEvent(this, 'scan-failed');
+DirectoryContents.prototype.onScanError = function() {
+  this.scanner_ = null;
+  if (this.scanCancelled_)
+    return;
+
+  this.prefetchMetadataQueue_.run(function(callback) {
+    cr.dispatchSimpleEvent(this, 'scan-failed');
+    callback();
+  }.bind(this));
 };
 
 /**
- * Called in case scan has completed succesfully. Should send the event.
+ * Called when some chunk of entries are read by scanner.
+ * @param {Array.<Entry>} entries The list of the scanned entries.
  * @protected
  */
-DirectoryContents.prototype.lastChunkReceived = function() {
-  this.allChunksFetched_ = true;
-  if (!this.scanCancelled_ && this.pendingMetadataRequests_ === 0)
-    cr.dispatchSimpleEvent(this, 'scan-completed');
+DirectoryContents.prototype.onNewEntries = function(entries) {
+  if (this.scanCancelled_)
+    return;
+
+  var entriesFiltered = [].filter.call(
+      entries, this.context_.fileFilter.filter.bind(this.context_.fileFilter));
+
+  // Because the prefetchMetadata can be slow, throttling by splitting entries
+  // into smaller chunks to reduce UI latency.
+  // TODO(hidehiko,mtomasz): This should be handled in MetadataCache.
+  var MAX_CHUNK_SIZE = 50;
+  for (var i = 0; i < entriesFiltered.length; i += MAX_CHUNK_SIZE) {
+    var chunk = entriesFiltered.slice(i, i + MAX_CHUNK_SIZE);
+    this.prefetchMetadataQueue_.run(function(chunk, callback) {
+      this.prefetchMetadata(chunk, function() {
+        if (this.scanCancelled_) {
+          // Do nothing if the scanning is cancelled.
+          callback();
+          return;
+        }
+
+        this.fileList_.push.apply(this.fileList_, chunk);
+        cr.dispatchSimpleEvent(this, 'scan-updated');
+        callback();
+      }.bind(this));
+    }.bind(this, chunk));
+  }
 };
 
 /**
  * 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.
  * @param {string} field Sort field.
  * @param {function(Object)} callback Called when done.
  * @private
@@ skipping 13 matching lines @@
 /**
  * @param {Array.<Entry>} entries Files.
  * @param {function(Object)} callback Callback on done.
  */
 DirectoryContents.prototype.reloadMetadata = function(entries, callback) {
   this.context_.metadataCache.clear(entries, '*');
   this.context_.metadataCache.get(entries, 'filesystem', callback);
 };
 
 /**
- * @protected
- * @param {Array.<Entry>} entries File list.
- */
-DirectoryContents.prototype.onNewEntries = function(entries) {
-  if (this.scanCancelled_)
-    return;
-
-  var entriesFiltered = [].filter.call(
-      entries, this.context_.fileFilter.filter.bind(this.context_.fileFilter));
-
-  var onPrefetched = function() {
-    this.pendingMetadataRequests_--;
-    if (this.scanCancelled_)
-      return;
-    this.fileList_.push.apply(this.fileList_, entriesFiltered);
-
-    if (this.pendingMetadataRequests_ === 0 && this.allChunksFetched_)
-      cr.dispatchSimpleEvent(this, 'scan-completed');
-    else
-      cr.dispatchSimpleEvent(this, 'scan-updated');
-
-    if (!this.allChunksFetched_)
-      this.readNextChunk();
-  };
-
-  this.pendingMetadataRequests_++;
-  this.prefetchMetadata(entriesFiltered, onPrefetched.bind(this));
-};
-
-/**
  * @param {string} name Directory name.
  * @param {function(DirectoryEntry)} successCallback Called on success.
  * @param {function(FileError)} errorCallback On error.
  */
 DirectoryContents.prototype.createDirectory = function(
     name, successCallback, errorCallback) {
   throw 'Not implemented.';
 };
 
 
@@ skipping 32 matching lines @@
  * @return {DirectoryEntry} DirectoryEntry for the currnet entry.
  */
 DirectoryContentsBasic.prototype.getLastNonSearchDirectoryEntry = function() {
   return this.entry_;
 };
 
 /**
  * Start directory scan.
  */
 DirectoryContentsBasic.prototype.scan = function() {
-  if (!this.entry_ || this.entry_ === DirectoryModel.fakeDriveEntry_) {
-    this.lastChunkReceived();
-    return;
-  }
-
-  metrics.startInterval('DirectoryScan');
-  this.reader_ = this.entry_.createReader();
-  this.readNextChunk();
+  this.scanner_ = new DirectoryContentScanner(this.entry_);

[mtomasz, 2013/10/01 02:36:39]

Do we need to create a new instance of scanner every time? If so, then how about
old instances? Shall we cancel them before creating a new one?

[hidehiko, 2013/10/01 04:12:23]

Good point.
In the existing code, scan must be called at most once. To rescan, it is
necessary
to clone() the instance, to call cancel() for the older instance, and to call
scan() for the new instance. It is done in DirectoryModel.

It should be clean up, but this CL is already huge, so I'd like to split it from
this CL. WDYT?

[mtomasz, 2013/10/01 04:39:55]

Can you please add either (1) a TODO line or (2): if (this.scanner_) throw new
Error('Scanner already exists.')? Thanks!

[hidehiko, 2013/10/01 05:28:17]

Done.

+  this.scanner_.startScan(this.onNewEntries.bind(this),
+                          this.onScanCompleted.bind(this),
+                          this.onScanError.bind(this));
 };
 
 /**
- * Read next chunk of results from DirectoryReader.
- * @protected
- */
-DirectoryContentsBasic.prototype.readNextChunk = function() {
-  this.reader_.readEntries(this.onChunkComplete_.bind(this),
-                           this.onError.bind(this));
-};
-
-/**
- * @param {Array.<Entry>} entries File list.
- * @private
- */
-DirectoryContentsBasic.prototype.onChunkComplete_ = function(entries) {
-  if (this.scanCancelled_)
-    return;
-
-  if (entries.length == 0) {
-    this.lastChunkReceived();
-    this.recordMetrics_();
-    return;
-  }
-
-  this.onNewEntries(entries);
-};
-
-/**
- * @private
- */
-DirectoryContentsBasic.prototype.recordMetrics_ = function() {
-  metrics.recordInterval('DirectoryScan');
-  if (this.entry_.fullPath === RootDirectory.DOWNLOADS)
-    metrics.recordMediumCount('DownloadsCount', this.fileList_.length);
-};
-
-/**
  * @param {string} name Directory name.
  * @param {function(Entry)} successCallback Called on success.
  * @param {function(FileError)} errorCallback On error.
  */
 DirectoryContentsBasic.prototype.createDirectory = function(
     name, successCallback, errorCallback) {
+  // TODO(hidehiko): createDirectory should not be the part of
+  // DirectoryContent.
   if (!this.entry_) {
     errorCallback(util.createFileError(FileError.INVALID_MODIFICATION_ERR));
     return;
   }
 
   var onSuccess = function(newEntry) {
     this.reloadMetadata([newEntry], function() {
       successCallback(newEntry);
     });
   };
 
   this.entry_.getDirectory(name, {create: true, exclusive: true},
                            onSuccess.bind(this), errorCallback);
 };
 
 /**
- * Delay to be used for drive search scan.
- * The goal is to reduce the number of server requests when user is typing the
- * query.
- *
- * @type {number}
- * @const
- */
-DirectoryContentsDriveSearch.SCAN_DELAY = 200;
-
-/**
- * Maximum number of results which is shown on the search.
- *
- * @type {number}
- * @const
- */
-DirectoryContentsDriveSearch.MAX_RESULTS = 100;
-
-/**
  * @param {FileListContext} context File list context.
  * @param {DirectoryEntry} dirEntry Current directory.
  * @param {DirectoryEntry} previousDirEntry DirectoryEntry that was current
  *     before the search.
  * @param {string} query Search query.
  * @constructor
  * @extends {DirectoryContents}
  */
 function DirectoryContentsDriveSearch(context,
                                       dirEntry,
                                       previousDirEntry,
                                       query) {
   DirectoryContents.call(this, context);
   this.directoryEntry_ = dirEntry;
   this.previousDirectoryEntry_ = previousDirEntry;
   this.query_ = query;
-  this.nextFeed_ = '';
-  this.done_ = false;
-  this.fetchedResultsNum_ = 0;
 }
 
 /**
  * Extends DirectoryContents.
  */
 DirectoryContentsDriveSearch.prototype.__proto__ = DirectoryContents.prototype;
 
 /**
  * Create the copy of the object, but without scan started.
  * @return {DirectoryContentsBasic} Object copy.
@@ skipping 25 matching lines @@
  */
 DirectoryContentsDriveSearch.prototype.getLastNonSearchDirectoryEntry =
     function() {
   return this.previousDirectoryEntry_;
 };
 
 /**
  * Start directory scan.
  */
 DirectoryContentsDriveSearch.prototype.scan = function() {
-  // Let's give another search a chance to cancel us before we begin.
-  setTimeout(this.readNextChunk.bind(this),
-             DirectoryContentsDriveSearch.SCAN_DELAY);
+  this.scanner_ = new DriveSearchContentScanner(this.query_);

[mtomasz, 2013/10/01 02:36:39]

Same here.

[hidehiko, 2013/10/01 04:12:23]

Ack.

+  this.scanner_.startScan(this.onNewEntries.bind(this),
+                          this.onScanCompleted.bind(this),
+                          this.onScanError.bind(this));
 };
 
 /**
- * All the results are read in one chunk, so when we try to read second chunk,
- * it means we're done.
- */
-DirectoryContentsDriveSearch.prototype.readNextChunk = function() {
-  if (this.scanCancelled_)
-    return;
-
-  if (this.done_) {
-    this.lastChunkReceived();
-    return;
-  }
-
-  var searchCallback = (function(entries, nextFeed) {
-    // TODO(tbarzic): Improve error handling.
-    if (!entries) {
-      console.error('Drive search encountered an error.');
-      this.lastChunkReceived();
-      return;
-    }
-    this.nextFeed_ = nextFeed;
-    var remaining =
-        DirectoryContentsDriveSearch.MAX_RESULTS - this.fetchedResultsNum_;
-    if (entries.length >= remaining) {
-      entries = entries.slice(0, remaining);
-      this.nextFeed_ = '';
-    }
-    this.fetchedResultsNum_ += entries.length;
-
-    this.done_ = (this.nextFeed_ == '');
-
-    this.onNewEntries(entries);
-  }).bind(this);
-
-  var searchParams = {
-    'query': this.query_,
-    'nextFeed': this.nextFeed_
-  };
-  chrome.fileBrowserPrivate.searchDrive(searchParams, searchCallback);
-};
-
-
-/**
  * @param {FileListContext} context File list context.
  * @param {DirectoryEntry} dirEntry Current directory.
  * @param {string} query Search query.
  * @constructor
  * @extends {DirectoryContents}
  */
 function DirectoryContentsLocalSearch(context, dirEntry, query) {
   DirectoryContents.call(this, context);
   this.directoryEntry_ = dirEntry;
-  this.query_ = query.toLowerCase();
+  this.query_ = query;
 }
 
 /**
  * Extends DirectoryContents
  */
 DirectoryContentsLocalSearch.prototype.__proto__ = DirectoryContents.prototype;
 
 /**
  * Create the copy of the object, but without scan started.
  * @return {DirectoryContentsBasic} Object copy.
@@ skipping 25 matching lines @@
 DirectoryContentsLocalSearch.prototype.getLastNonSearchDirectoryEntry =
     function() {
   return this.directoryEntry_;
 };
 
 /**
  * Start directory scan/search operation. Either 'scan-completed' or
  * 'scan-failed' event will be fired upon completion.
  */
 DirectoryContentsLocalSearch.prototype.scan = function() {
-  this.pendingScans_ = 0;
-  this.scanDirectory_(this.directoryEntry_);
+  this.scanner_ =
+      new LocalSearchContentScanner(this.directoryEntry_, this.query_);
+  this.scanner_.startScan(this.onNewEntries.bind(this),
+                          this.onScanCompleted.bind(this),
+                          this.onScanError.bind(this));
 };
 
 /**
- * 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 onChunkComplete = function(entries) {
-    if (this.scanCancelled_)
-      return;
-
-    if (entries.length === 0) {
-      if (found.length > 0)
-        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(this.query_) != -1) {
-        found.push(entries[i]);
-      }
-
-      if (entries[i].isDirectory)
-        this.scanDirectory_(entries[i]);
-    }
-
-    getNextChunk();
-  }.bind(this);
-
-  var getNextChunk = function() {
-    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() {
-};
-
-/**
- * List of search types for DirectoryContentsDriveSearch.
- * TODO(haruki): SHARED_WITH_ME support for searchDriveMetadata is not yet
- * implemented. Update this when it's done.
- * SEARCH_ALL uses no filtering.
- * SEARCH_SHARED_WITH_ME searches for the shared-with-me entries.
- * SEARCH_RECENT_FILES searches for recently accessed file entries.
- * @enum {number}
- */
-DirectoryContentsDriveSearchMetadata.SearchType = {
-  SEARCH_ALL: 0,
-  SEARCH_SHARED_WITH_ME: 1,
-  SEARCH_RECENT_FILES: 2,
-  SEARCH_OFFLINE: 3
-};
-
-/**
  * DirectoryContents to list Drive files using searchDriveMetadata().
  *
  * @param {FileListContext} context File list context.
  * @param {DirectoryEntry} driveDirEntry Directory for actual Drive.
  * @param {DirectoryEntry} fakeDirEntry Fake directory representing the set of
  *     result files. This serves as a top directory for this search.
  * @param {string} query Search query to filter the files.
- * @param {DirectoryContentsDriveSearchMetadata.SearchType} searchType
+ * @param {DriveMetadataSearchContentScanner.SearchType} searchType
  *     Type of search. searchDriveMetadata will restricts the entries based on
  *     the given search type.
  * @constructor
  * @extends {DirectoryContents}
  */
 function DirectoryContentsDriveSearchMetadata(context,
                                               driveDirEntry,
                                               fakeDirEntry,
                                               query,
                                               searchType) {
@@ skipping 42 matching lines @@
 DirectoryContentsDriveSearchMetadata.prototype.getLastNonSearchDirectoryEntry =
     function() {
   return this.driveDirEntry_;
 };
 
 /**
  * Start directory scan/search operation. Either 'scan-completed' or
  * 'scan-failed' event will be fired upon completion.
  */
 DirectoryContentsDriveSearchMetadata.prototype.scan = function() {
-  this.readNextChunk();
+  this.scanner_ =
+      new DriveMetadataSearchContentScanner(this.query_, this.searchType_);
+  this.scanner_.startScan(this.onNewEntries.bind(this),
+                          this.onScanCompleted.bind(this),
+                          this.onScanError.bind(this));
 };
-
-/**
- * All the results are read in one chunk, so when we try to read second chunk,
- * it means we're done.
- */
-DirectoryContentsDriveSearchMetadata.prototype.readNextChunk = function() {
-  if (this.scanCancelled_)
-    return;
-
-  if (this.done_) {
-    this.lastChunkReceived();
-    return;
-  }
-
-  var searchCallback = (function(results, nextFeed) {
-    if (!results) {
-      console.error('Drive search encountered an error.');
-      this.lastChunkReceived();
-      return;
-    }
-    this.done_ = true;
-
-    var entries = results.map(function(r) { return r.entry; });
-    this.onNewEntries(entries);
-    this.lastChunkReceived();
-  }).bind(this);
-
-  var type;
-  switch (this.searchType_) {
-    case DirectoryContentsDriveSearchMetadata.SearchType.SEARCH_ALL:
-      type = 'ALL';
-      break;
-    case DirectoryContentsDriveSearchMetadata.SearchType.SEARCH_SHARED_WITH_ME:
-      type = 'SHARED_WITH_ME';
-      break;
-    case DirectoryContentsDriveSearchMetadata.SearchType.SEARCH_RECENT_FILES:
-      type = 'EXCLUDE_DIRECTORIES';
-      break;
-    case DirectoryContentsDriveSearchMetadata.SearchType.SEARCH_OFFLINE:
-      type = 'OFFLINE';
-      break;
-    default:
-      throw Error('Unknown search type: ' + this.searchType_);
-  }
-  var searchParams = {
-    'query': this.query_,
-    'types': type,
-    'maxResults': 500
-  };
-  chrome.fileBrowserPrivate.searchDriveMetadata(searchParams, searchCallback);
-};