Files.app: Clean DirectoryModel.

chrome/browser/resources/file_manager/foreground/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 243 matching lines @@
 
     var reader = entry.createReader();
     reader.readEntries(onSuccess, onError);
   }.bind(this);
 
   processEntry(this.entry_);
 };
 
 /**
  * Scanner of the entries for the metadata search on Drive File System.
- * @param {string} query The query of the search.
  * @param {DriveMetadataSearchContentScanner.SearchType} searchType The option
  *     of the search.
  * @constructor
  * @extends {ContentScanner}
  */
-function DriveMetadataSearchContentScanner(query, searchType) {
+function DriveMetadataSearchContentScanner(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.
  * @enum {string}
  */
 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.
  * @override
  */
 DriveMetadataSearchContentScanner.prototype.scan = function(
     entriesCallback, successCallback, errorCallback) {
   chrome.fileBrowserPrivate.searchDriveMetadata(
-      {query: this.query_, types: this.searchType_, maxResults: 500},
+      {query: '', types: this.searchType_, maxResults: 500},

[mtomasz, 2014/02/04 02:20:12]

nit: Could you please file a bug to remove this argument from private api?

[hirono, 2014/02/04 05:53:11]

Done. crbug.com/340557.

       function(results) {
         if (this.cancelled_) {
           errorCallback(util.createDOMError(util.FileError.ABORT_ERR));
           return;
         }
 
         if (!results) {
           console.error('Drive search encountered an error.');
           errorCallback(util.createDOMError(
               util.FileError.INVALID_MODIFICATION_ERR));
@@ skipping 99 matching lines @@
  * 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 directory.
  * @param {function():ContentScanner} scannerFactory The factory to create
  *     ContentScanner instance.
  * @constructor
  * @extends {cr.EventTarget}
  */
 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;
 }
 
 /**
  * DirectoryContents extends cr.EventTarget.
  */
@@ skipping 52 matching lines @@
 
 /**
  * @return {DirectoryEntry} A DirectoryEntry for current directory. In case of
  *     search -- the top directory from which search is run.
  */
 DirectoryContents.prototype.getDirectoryEntry = function() {
   return this.directoryEntry_;
 };
 
 /**
- * @return {DirectoryEntry} A DirectoryEntry for the last non search contents.
- */
-DirectoryContents.prototype.getLastNonSearchDirectoryEntry = function() {
-  return this.lastNonSearchDirectoryEntry_;
-};
-
-/**
  * Start directory scan/search operation. Either 'scan-completed' or
  * 'scan-failed' event will be fired upon completion.
  */
 DirectoryContents.prototype.scan = function() {
   // TODO(hidehiko,mtomasz): this scan method must be called at most once.
   // Remove such a limitation.
   this.scanner_ = this.scannerFactory_();

[mtomasz, 2014/02/04 02:20:12]

I'm getting a JS error after launching Files app here. Please check.

[hirono, 2014/02/04 05:53:11]

Thanks for handling it.
This is caused because the call of the constructor of DirectoryContents in the
clone method is wrong.
Fixed.

   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_)
@@ skipping 100 matching lines @@
  *
  * @param {FileListContext} context File list context.
  * @param {DirectoryEntry} directoryEntry The current directory entry.
  * @return {DirectoryContents} Created DirectoryContents instance.
  */
 DirectoryContents.createForDirectory = function(context, directoryEntry) {
   return new DirectoryContents(
       context,
       false,  // Non search.
       directoryEntry,
-      directoryEntry,
       function() {
         return new DirectoryContentScanner(directoryEntry);
       });
 };
 
 /**
  * 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.
  */
 DirectoryContents.createForDriveSearch = function(
-    context, directoryEntry, previousDirectoryEntry, query) {
+    context, directoryEntry, query) {
   return new DirectoryContents(
       context,
       true,  // Search.
       directoryEntry,
-      previousDirectoryEntry,
       function() {
         return new DriveSearchContentScanner(query);
       });
 };
 
 /**
  * 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.
  */
 DirectoryContents.createForLocalSearch = function(
     context, directoryEntry, query) {
   return new DirectoryContents(
       context,
       true,  // Search.
       directoryEntry,
-      directoryEntry,
       function() {
         return new LocalSearchContentScanner(directoryEntry, query);
       });
 };
 
 /**
  * Creates a DirectoryContents instance to show the result of metadata search
  * on Drive File System.
  *
  * @param {FileListContext} context File list context.
  * @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.
  */
 DirectoryContents.createForDriveMetadataSearch = function(
-    context, fakeDirectoryEntry, driveDirectoryEntry, query, searchType) {
+    context, fakeDirectoryEntry, searchType) {
   return new DirectoryContents(
       context,
       true,  // Search
       fakeDirectoryEntry,
-      driveDirectoryEntry,
       function() {
-        return new DriveMetadataSearchContentScanner(query, searchType);
+        return new DriveMetadataSearchContentScanner(searchType);
       });
 };