[Files.app] Change sort timing during metadata fetch

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 442 matching lines @@
   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_, 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);
+  if (fileList instanceof cr.ui.ArrayDataModel)
+    this.fileList_ = fileList;
+  else
+    this.fileList_ = new cr.ui.ArrayDataModel(fileList);
+  this.context_.metadataCache.setCacheSize(this.fileList_.length);
 };
 
 /**
  * Use the filelist from the context and replace its contents with the entries
  * from the current fileList.
  */
 DirectoryContents.prototype.replaceContextFileList = function() {
   if (this.context_.fileList !== this.fileList_) {
-    var spliceArgs = [].slice.call(this.fileList_);
+    var spliceArgs = this.fileList_.slice();
     var fileList = this.context_.fileList;
     spliceArgs.unshift(0, fileList.length);
     fileList.splice.apply(fileList, spliceArgs);
     this.fileList_ = fileList;
+    this.context_.metadataCache.setCacheSize(this.fileList_.length);
   }
 };
 
 /**
  * @return {boolean} If the scan is active.
  */
 DirectoryContents.prototype.isScanning = function() {
   return this.scanner_ || this.prefetchMetadataQueue_.isRunning();
 };
 
@@ skipping 87 matching lines @@
   if (this.scanCancelled_)
     return;
 
   var entriesFiltered = [].filter.call(
       entries, this.context_.fileFilter.filter.bind(this.context_.fileFilter));
 
   // Update the filelist without waiting the metadata.
   this.fileList_.push.apply(this.fileList_, entriesFiltered);
   cr.dispatchSimpleEvent(this, 'scan-updated');
 
+  this.context_.metadataCache.setCacheSize(this.fileList_.length);
+
   // 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;
         }
 
+        // TODO(yoshiki): Here we should fire the update event of changed
+        // items. Currently we have a method this.fileList_.updateIndex() to
+        // fire an event, but this method takes only 1 argument and invokes sort
+        // one by one. It is obviously time wasting. Instead, we call sort
+        // directory.
+        // In future, we should implement a good method like updateIndexes and
+        // use it here.
+        var status = this.fileList_.sortStatus;
+        this.fileList_.sort(status.field, status.direction);
+
         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
- */
-DirectoryContents.prototype.prepareSort_ = function(field, callback) {
-  this.prefetchMetadata(this.fileList_.slice(), callback);
-};
-
-/**
  * @param {Array.<Entry>} entries Files.
  * @param {function(Object)} callback Callback on done.
  */
 DirectoryContents.prototype.prefetchMetadata = function(entries, callback) {
   this.context_.metadataCache.get(entries, 'filesystem', callback);
 };
 
 /**
  * @param {Array.<Entry>} entries Files.
  * @param {function(Object)} callback Callback on done.
@@ skipping 108 matching lines @@
     context, fakeDirectoryEntry, driveDirectoryEntry, query, searchType) {
   return new DirectoryContents(
       context,
       true,  // Search
       fakeDirectoryEntry,
       driveDirectoryEntry,
       function() {
         return new DriveMetadataSearchContentScanner(query, searchType);
       });
 };