[Files.app] Change sort timing during metadata fetch

chrome/browser/resources/file_manager/foreground/js/metadata/metadata_cache.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';
 
 /**
  * MetadataCache is a map from url to an object containing properties.
  * Properties are divided by types, and all properties of one type are accessed
  * at once.
@@ skipping 59 matching lines @@
    *   callback - the callback.
    * TODO(dgozman): pass entries to observer if present.
    * @private
    */
   this.observers_ = [];
   this.observerId_ = 0;
 
   this.batchCount_ = 0;
   this.totalCount_ = 0;
 
+  this.currentCacheSize_ = 0;
+
   /**
    * Time of first get query of the current batch. Items updated later than this
    * will not be evicted.
    * @private
    */
   this.lastBatchStart_ = new Date();
 }
 
 /**
  * Observer type: it will be notified if the url changed is exactly the same
  * as the url passed.
  */
 MetadataCache.EXACT = 0;
 
 /**
  * Observer type: it will be notified if the url changed is an immediate child
  * of the url passed.
  */
 MetadataCache.CHILDREN = 1;
 
 /**
  * Observer type: it will be notified if the url changed is any descendant
  * of the url passed.
  */
 MetadataCache.DESCENDANTS = 2;
 
 /**
- * Minimum number of items in cache to start eviction.
+ * Margin of the cache size. This amount of caches may be kept in addition.
  */
-MetadataCache.EVICTION_NUMBER = 1000;
+MetadataCache.EVICTION_THRESHOLD_MARGIN = 500;
 
 /**
  * @return {MetadataCache!} The cache with all providers.
  */
 MetadataCache.createFull = function() {
   var cache = new MetadataCache();
   cache.providers_.push(new FilesystemProvider());
   cache.providers_.push(new DriveProvider());
   cache.providers_.push(new ContentProvider());
   return cache;
@@ skipping 32 matching lines @@
  * @return {boolean} Whether all providers are ready.
  */
 MetadataCache.prototype.isInitialized = function() {
   for (var index = 0; index < this.providers_.length; index++) {
     if (!this.providers_[index].isInitialized()) return false;
   }
   return true;
 };
 
 /**
+ * Sets the size of cache. The acutual cache size may be larger than the given

[mtomasz, 2014/01/08 08:11:02]

nit: actual

[yoshiki, 2014/01/08 09:04:45]

Done.

+ * value.
+ * @param {number} size The cache size to be set.
+ */
+MetadataCache.prototype.setCacheSize = function(size) {
+  this.currentCacheSize_ = size;
+
+  if (this.totalCount_ > this.currentEvictionThreshold_())
+    this.evict_();
+};
+
+/**
+ * Returns the current threshold to evict caches. When the number of caches
+ * exceeds this, the cache should be evicted.
+ * @return {number} Threshold to evict caches.
+ * @private
+ */
+MetadataCache.prototype.currentEvictionThreshold_ = function() {
+  return this.currentCacheSize_ * 2 + MetadataCache.EVICTION_THRESHOLD_MARGIN;
+};
+
+/**
  * Fetches the metadata, puts it in the cache, and passes to callback.
  * If required metadata is already in the cache, does not fetch it again.
  * @param {string|Entry|Array.<string|Entry>} items The list of entries or
  *     file urls. May be just a single item.
  * @param {string} type The metadata type.
  * @param {function(Object)} callback The metadata is passed to callback.
  */
 MetadataCache.prototype.get = function(items, type, callback) {
   if (!(items instanceof Array)) {
     this.getOne(items, type, callback);
@@ skipping 277 matching lines @@
   if (this.batchCount_ == 1)
     this.lastBatchStart_ = new Date();
 };
 
 /**
  * End batch updates. Notifies observers if all nested updates are finished.
  */
 MetadataCache.prototype.endBatchUpdates = function() {
   this.batchCount_--;
   if (this.batchCount_ != 0) return;
-  if (this.totalCount_ > MetadataCache.EVICTION_NUMBER)
+  if (this.totalCount_ > this.currentEvictionThreshold_())
     this.evict_();
   for (var index = 0; index < this.observers_.length; index++) {
     var observer = this.observers_[index];
     var urls = [];
     var properties = [];
     for (var url in observer.pending) {
       if (observer.pending.hasOwnProperty(url) && url in this.cache_) {
         urls.push(url);
         properties.push(this.cache_[url].properties[observer.type] || null);
       }
@@ skipping 27 matching lines @@
 
 /**
  * Removes the oldest items from the cache.
  * This method never removes the items from last batch.
  * @private
  */
 MetadataCache.prototype.evict_ = function() {
   var toRemove = [];
 
   // We leave only a half of items, so we will not call evict_ soon again.
-  var desiredCount = Math.round(MetadataCache.EVICTION_NUMBER / 2);
+  var desiredCount = this.currentEvictionThreshold();
   var removeCount = this.totalCount_ - desiredCount;
   for (var url in this.cache_) {
     if (this.cache_.hasOwnProperty(url) &&
         this.cache_[url].time < this.lastBatchStart_) {
       toRemove.push(url);
     }
   }
 
   toRemove.sort(function(a, b) {
     var aTime = this.cache_[a].time;
@@ skipping 524 matching lines @@
 
 /**
  * Handles the 'log' message from the worker.
  * @param {Array.<*>} arglist Log arguments.
  * @private
  */
 ContentProvider.prototype.onLog_ = function(arglist) {
   if (MetadataCache.log)  // Avoid log spam by default.
     console.log.apply(console, ['metadata:'].concat(arglist));
 };