Refactor DirectoryContents.

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.
  * @constructor
  */
@@ skipping 36 matching lines @@
   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.
  * @override
  */
 DirectoryContentScanner.prototype.scan = 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;
   }
 
@@ skipping 50 matching lines @@
 /**
  * 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.
  * @override
  */
 DriveSearchContentScanner.prototype.scan = 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_) {
@@ skipping 55 matching lines @@
   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.
  * @override
  */
 LocalSearchContentScanner.prototype.scan = 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));
@@ skipping 70 matching lines @@
  */
 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.
  * @override
  */
 DriveMetadataSearchContentScanner.prototype.scan = function(
     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;
@@ skipping 122 matching lines @@
    * @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.
+ * TODO(hidehiko): Remove EventTarget from this.
+ *
  * @param {FileListContext} context The file list context.
+ * @param {boolean} isSearch True for search directory contents, otherwise
+ *     false.
+ * @param {DirectoryEntry} directoryEntry The entry of the current directory.
+ * @param {DirectoryEntry} lastNonSearchDirectoryEntry The entry of the last
+ *     non-search directroy.
+ * @param {function():ContentScanner} scannerFactory The factory to create
+ *     ContentScanner instance.
  * @constructor
  * @extends {cr.EventTarget}
  */
-function DirectoryContents(context) {
+function DirectoryContents(context, isSearch, directoryEntry,
+                           lastNonSearchDirectoryEntry,
+                           scannerFactory) {
   this.context_ = context;
   this.fileList_ = context.fileList;
+
+  this.isSearch_ = isSearch;
+  this.directoryEntry_ = directoryEntry;
+  this.lastNonSearchDirectoryEntry_ = lastNonSearchDirectoryEntry;
+
+  this.scannerFactory_ = scannerFactory;
+  this.scanner_ = null;
   this.prefetchMetadataQueue_ = new AsyncUtil.Queue();
   this.scanCancelled_ = false;
   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.
  * @return {DirectoryContents} Object copy.
  */
 DirectoryContents.prototype.clone = function() {
-  return new DirectoryContents(this.context_);
+  return new DirectoryContents(
+      this.context_, this.isSearch_, this.directoryEntry_,
+      this.lastNonSearchDirectoryEntry_, this.scannerFactory_);
 };
 
 /**
  * Use a given fileList instead of the fileList from the context.
  * @param {Array|cr.ui.ArrayDataModel} fileList The new file list.
  */
 DirectoryContents.prototype.setFileList = function(fileList) {
   this.fileList_ = fileList;
   this.fileList_.prepareSort = this.prepareSort_.bind(this);
 };
@@ skipping 16 matching lines @@
  * @return {boolean} If the scan is active.
  */
 DirectoryContents.prototype.isScanning = function() {
   return this.scanner_ || this.prefetchMetadataQueue_.isRunning();
 };
 
 /**
  * @return {boolean} True if search results (drive or local).
  */
 DirectoryContents.prototype.isSearch = function() {
-  return false;
+  return this.isSearch_;
 };
 
 /**
  * @return {DirectoryEntry} A DirectoryEntry for current directory. In case of
  *     search -- the top directory from which search is run.
  */
 DirectoryContents.prototype.getDirectoryEntry = function() {
-  throw 'Not implemented.';
+  return this.directoryEntry_;
 };
 
 /**
  * @return {DirectoryEntry} A DirectoryEntry for the last non search contents.
  */
 DirectoryContents.prototype.getLastNonSearchDirectoryEntry = function() {
-  throw 'Not implemented.';
+  return this.lastNonSearchDirectoryEntry_;
 };
 
 /**
  * Start directory scan/search operation. Either 'scan-completed' or
  * 'scan-failed' event will be fired upon completion.
  */
 DirectoryContents.prototype.scan = function() {
-  throw 'Not implemented.';
+  // TODO(hidehiko,mtomasz): this scan method must be called at most once.
+  // Remove such a limitation.
+  this.scanner_ = this.scannerFactory_();
+  this.scanner_.scan(this.onNewEntries_.bind(this),
+                     this.onScanCompleted_.bind(this),
+                     this.onScanError_.bind(this));
 };
 
 /**
  * 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
+ * @private
  */
-DirectoryContents.prototype.onScanCompleted = function() {
+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
+ * @private
  */
-DirectoryContents.prototype.onScanError = function() {
+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 when some chunk of entries are read by scanner.
  * @param {Array.<Entry>} entries The list of the scanned entries.
- * @protected
+ * @private
  */
-DirectoryContents.prototype.onNewEntries = function(entries) {
+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;
@@ skipping 45 matching lines @@
   this.context_.metadataCache.get(entries, 'filesystem', callback);
 };
 
 /**
  * @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.';
-};
-
-
-/**
- * @param {FileListContext} context File list context.
- * @param {DirectoryEntry} entry DirectoryEntry for current directory.
- * @constructor
- * @extends {DirectoryContents}
- */
-function DirectoryContentsBasic(context, entry) {
-  DirectoryContents.call(this, context);
-  this.entry_ = entry;
-}
-
-/**
- * Extends DirectoryContents
- */
-DirectoryContentsBasic.prototype.__proto__ = DirectoryContents.prototype;
-
-/**
- * Create the copy of the object, but without scan started.
- * @return {DirectoryContentsBasic} Object copy.
- */
-DirectoryContentsBasic.prototype.clone = function() {
-  return new DirectoryContentsBasic(this.context_, this.entry_);
-};
-
-/**
- * @return {DirectoryEntry} DirectoryEntry of the current directory.
- */
-DirectoryContentsBasic.prototype.getDirectoryEntry = function() {
-  return this.entry_;
-};
-
-/**
- * @return {DirectoryEntry} DirectoryEntry for the currnet entry.
- */
-DirectoryContentsBasic.prototype.getLastNonSearchDirectoryEntry = function() {
-  return this.entry_;
-};
-
-/**
- * Start directory scan.
- */
-DirectoryContentsBasic.prototype.scan = function() {
-  // TODO(hidehiko,mtomasz): this scan method must be called at most once.
-  // Remove such a limitation.
-  this.scanner_ = new DirectoryContentScanner(this.entry_);
-  this.scanner_.scan(this.onNewEntries.bind(this),
-                     this.onScanCompleted.bind(this),
-                     this.onScanError.bind(this));
-};
-
-/**
- * @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_) {
+  if (this.isSearch_ || !this.directoryEntry_) {
     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);
+  this.directoryEntry_.getDirectory(name, {create: true, exclusive: true},
+                                    onSuccess.bind(this), errorCallback);
 };
 
 /**
+ * Creates a DirectoryContents instance to show entries in a directory.
+ *
  * @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}
+ * @param {DirectoryEntry} directoryEntry The current directory entry.
+ * @return {DirectoryContents} Created DirectoryContents instance.
  */
-function DirectoryContentsDriveSearch(context,
-                                      dirEntry,
-                                      previousDirEntry,
-                                      query) {
-  DirectoryContents.call(this, context);
-  this.directoryEntry_ = dirEntry;
-  this.previousDirectoryEntry_ = previousDirEntry;
-  this.query_ = query;
-}
-
-/**
- * Extends DirectoryContents.
- */
-DirectoryContentsDriveSearch.prototype.__proto__ = DirectoryContents.prototype;
-
-/**
- * Create the copy of the object, but without scan started.
- * @return {DirectoryContentsBasic} Object copy.
- */
-DirectoryContentsDriveSearch.prototype.clone = function() {
-  return new DirectoryContentsDriveSearch(
-      this.context_, this.directoryEntry_,
-      this.previousDirectoryEntry_, this.query_);
+DirectoryContents.createForDirectory = function(context, directoryEntry) {
+  return new DirectoryContents(
+      context,
+      false,  // Non search.
+      directoryEntry,
+      directoryEntry,
+      function() {
+        return new DirectoryContentScanner(directoryEntry);
+      });
 };
 
 /**
- * @return {boolean} True if this is search results (yes).
+ * Creates a DirectoryContents instance to show the result of the search on
+ * Drive File System.
+ *
+ * @param {FileListContext} context File list context.
+ * @param {DirectoryEntry} directoryEntry The current directory entry.
+ * @param {DirectoryEntry} previousDirectoryEntry The DirectoryEntry that was
+ *     current before the search.
+ * @param {string} query Search query.
+ * @return {DirectoryContents} Created DirectoryContents instance.
  */
-DirectoryContentsDriveSearch.prototype.isSearch = function() {
-  return true;
+DirectoryContents.createForDriveSearch = function(
+    context, directoryEntry, previousDirectoryEntry, query) {
+  return new DirectoryContents(
+      context,
+      true,  // Search.
+      directoryEntry,
+      previousDirectoryEntry,
+      function() {
+        return new DriveSearchContentScanner(query);
+      });
 };
 
 /**
- * @return {DirectoryEntry} A DirectoryEntry for the top directory from which
- *     search is run (i.e. drive root).
+ * Creates a DirectoryContents instance to show the result of the search on
+ * Local File System.
+ *
+ * @param {FileListContext} context File list context.
+ * @param {DirectoryEntry} directoryEntry The current directory entry.
+ * @param {string} query Search query.
+ * @return {DirectoryContents} Created DirectoryContents instance.
  */
-DirectoryContentsDriveSearch.prototype.getDirectoryEntry = function() {
-  return this.directoryEntry_;
+DirectoryContents.createForLocalSearch = function(
+    context, directoryEntry, query) {
+  return new DirectoryContents(
+      context,
+      true,  // Search.
+      directoryEntry,
+      directoryEntry,
+      function() {
+        return new LocalSearchContentScanner(directoryEntry, query);
+      });
 };
 
 /**
- * @return {DirectoryEntry} DirectoryEntry for the directory that was current
- *     before the search.
- */
-DirectoryContentsDriveSearch.prototype.getLastNonSearchDirectoryEntry =
-    function() {
-  return this.previousDirectoryEntry_;
-};
-
-/**
- * Start directory scan.
- */
-DirectoryContentsDriveSearch.prototype.scan = function() {
-  this.scanner_ = new DriveSearchContentScanner(this.query_);
-  this.scanner_.scan(this.onNewEntries.bind(this),
-                     this.onScanCompleted.bind(this),
-                     this.onScanError.bind(this));
-};
-
-/**
- * @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;
-}
-
-/**
- * Extends DirectoryContents
- */
-DirectoryContentsLocalSearch.prototype.__proto__ = DirectoryContents.prototype;
-
-/**
- * Create the copy of the object, but without scan started.
- * @return {DirectoryContentsBasic} Object copy.
- */
-DirectoryContentsLocalSearch.prototype.clone = function() {
-  return new DirectoryContentsLocalSearch(
-      this.context_, this.directoryEntry_, this.query_);
-};
-
-/**
- * @return {boolean} True if search results (drive or local).
- */
-DirectoryContentsLocalSearch.prototype.isSearch = function() {
-  return true;
-};
-
-/**
- * @return {DirectoryEntry} A DirectoryEntry for the top directory from which
- *     search is run.
- */
-DirectoryContentsLocalSearch.prototype.getDirectoryEntry = function() {
-  return this.directoryEntry_;
-};
-
-/**
- * @return {DirectoryEntry} DirectoryEntry for current directory (the search is
- *     run from the directory that was current before search).
- */
-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.scanner_ =
-      new LocalSearchContentScanner(this.directoryEntry_, this.query_);
-  this.scanner_.scan(this.onNewEntries.bind(this),
-                     this.onScanCompleted.bind(this),
-                     this.onScanError.bind(this));
-};
-
-/**
- * DirectoryContents to list Drive files using searchDriveMetadata().
+ * Creates a DirectoryContents instance to show the result of metadata search
+ * on Drive File System.
  *
  * @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 {DriveMetadataSearchContentScanner.SearchType} searchType
- *     Type of search. searchDriveMetadata will restricts the entries based on
- *     the given search type.
- * @constructor
- * @extends {DirectoryContents}
+ * @param {DirectoryEntry} fakeDirectoryEntry Fake directory entry representing
+ *     the set of result entries. This serves as a top directory for the
+ *     search.
+ * @param {DirectoryEntry} driveDirectoryEntry Directory for the actual drive.
+ * @param {string} query Search query.
+ * @param {DriveMetadataSearchContentScanner.SearchType} searchType The type of
+ *     the search. The scanner will restricts the entries based on the given
+ *     type.
+ * @return {DirectoryContents} Created DirectoryContents instance.
  */
-function DirectoryContentsDriveSearchMetadata(context,
-                                              driveDirEntry,
-                                              fakeDirEntry,
-                                              query,
-                                              searchType) {
-  DirectoryContents.call(this, context);
-  this.driveDirEntry_ = driveDirEntry;
-  this.fakeDirEntry_ = fakeDirEntry;
-  this.query_ = query;
-  this.searchType_ = searchType;
-}
-
-/**
- * Creates a copy of the object, but without scan started.
- * @return {DirectoryContents} Object copy.
- */
-DirectoryContentsDriveSearchMetadata.prototype.clone = function() {
-  return new DirectoryContentsDriveSearchMetadata(
-      this.context_, this.driveDirEntry_, this.fakeDirEntry_, this.query_,
-      this.searchType_);
+DirectoryContents.createForDriveMetadataSearch = function(
+    context, fakeDirectoryEntry, driveDirectoryEntry, query, searchType) {
+  return new DirectoryContents(
+      context,
+      true,  // Search
+      fakeDirectoryEntry,
+      driveDirectoryEntry,
+      function() {
+        return new DriveMetadataSearchContentScanner(query, searchType);
+      });
 };
-
-/**
- * Extends DirectoryContents.
- */
-DirectoryContentsDriveSearchMetadata.prototype.__proto__ =
-    DirectoryContents.prototype;
-
-/**
- * @return {boolean} True if this is search results (yes).
- */
-DirectoryContentsDriveSearchMetadata.prototype.isSearch = function() {
-  return true;
-};
-
-/**
- * @return {DirectoryEntry} An Entry representing the current contents
- *     (i.e. fake root for "Shared with me").
- */
-DirectoryContentsDriveSearchMetadata.prototype.getDirectoryEntry = function() {
-  return this.fakeDirEntry_;
-};
-
-/**
- * @return {DirectoryEntry} DirectoryEntry for the directory that was current
- *     before the search.
- */
-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.scanner_ =
-      new DriveMetadataSearchContentScanner(this.query_, this.searchType_);
-  this.scanner_.scan(this.onNewEntries.bind(this),
-                     this.onScanCompleted.bind(this),
-                     this.onScanError.bind(this));
-};