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 35 matching lines @@
   ContentScanner.call(this);
   this.entry_ = entry;
 }
 
 /**
  * Extends ContentScanner.
  */
 DirectoryContentScanner.prototype.__proto__ = ContentScanner.prototype;
 
 /**
  * Starts to read the entries in the directory.

[mtomasz, 2013/10/01 07:47:36]

We don't need to copy jsdoc while overriding. @override is enough.

[hidehiko, 2013/10/01 07:50:38]

Great to know. Done!

  * @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) {
@@ skipping 381 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));
-};