Use UnlimitedCacheFlushManager for DEFAULT_CACHING_POLICY.

pkg/analyzer/lib/src/context/cache.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.context.cache;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisEngine, CacheState, InternalAnalysisContext, RetentionPriority;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
+import 'package:analyzer/src/task/model.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
  * Return `true` if the given [target] is a priority one.
  */
 typedef bool IsPriorityAnalysisTarget(AnalysisTarget target);
 
 /**
  * An LRU cache of results produced by analysis.
  */
@@ skipping 584 matching lines @@
   /**
    * If [currentSize] is already less than [maxSize], returns an empty list.
    * Otherwise returns [TargetedResult]s to flush from the cache to make
    * [currentSize] less or equal to [maxSize].
    *
    * Results for priority files are never flushed, so this method might leave
    * [currentSize] greater than [maxSize].
    */
   List<TargetedResult> flushToSize() {
     // If still under the cap, done.
-    if (maxSize == -1 || currentSize <= maxSize) {
+    if (currentSize <= maxSize) {
       return TargetedResult.EMPTY_LIST;
     }
     // Flush results until we are under the cap.
     List<TargetedResult> resultsToFlush = <TargetedResult>[];
     for (TargetedResult result in recentlyUsed) {
       if (isPriorityAnalysisTarget(result.target)) {
         continue;
       }
       resultsToFlush.add(result);
       int size = resultSizeMap.remove(result);
@@ skipping 20 matching lines @@
    */
   List<TargetedResult> madeIdle() {
     maxSize = maxIdleSize;
     return flushToSize();
   }
 
   /**
    * Records that the given [result] was just read from the cache.
    */
   void resultAccessed(TargetedResult result) {
-    if (maxSize <= 0) {
-      return;
-    }
     if (recentlyUsed.remove(result)) {
       recentlyUsed.add(result);
     }
   }
 
   /**
    * Records that the given [newResult] and [newValue] were stored to the cache.
    * Returns [TargetedResult]s that should be flushed from the cache.
    */
   List<TargetedResult> resultStored(TargetedResult newResult, T newValue) {
-    if (maxSize <= 0) {
-      return TargetedResult.EMPTY_LIST;
-    }
     if (!recentlyUsed.remove(newResult)) {
       int size = policy.measure(newValue);
       resultSizeMap[newResult] = size;
       currentSize += size;
     }
     recentlyUsed.add(newResult);
     return flushToSize();
   }
 
   /**
@@ skipping 151 matching lines @@
     } else {
       return entry._getResultData(result.result);
     }
   }
 
   /**
    * Return the [CacheFlushManager] for the given [descriptor], not `null`.
    */
   CacheFlushManager _getFlushManager(ResultDescriptor descriptor) {
     ResultCachingPolicy policy = descriptor.cachingPolicy;
-    return _flushManagerMap.putIfAbsent(
-        policy, () => new CacheFlushManager(policy, _isPriorityAnalysisTarget));
+    if (identical(policy, DEFAULT_CACHING_POLICY)) {
+      return UnlimitedCacheFlushManager.INSTANCE;
+    }
+    CacheFlushManager manager = _flushManagerMap[policy];
+    if (manager == null) {
+      manager = new CacheFlushManager(policy, _isPriorityAnalysisTarget);
+      _flushManagerMap[policy] = manager;
+    }
+    return manager;
   }
 
   bool _isPriorityAnalysisTarget(AnalysisTarget target) {
     return context.priorityTargets.contains(target);
   }
 
   /**
    * If the given [target] is a [Source], removes it from [_sources].
    */
   void _removeIfSource(AnalysisTarget target) {
@@ skipping 119 matching lines @@
 class UniversalCachePartition extends CachePartition {
   /**
    * Initialize a newly created cache partition, belonging to the given
    * [context].
    */
   UniversalCachePartition(InternalAnalysisContext context) : super(context);
 
   @override
   bool isResponsibleFor(AnalysisTarget target) => true;
 }
+
+/**
+ * [CacheFlushManager] that does nothing, results are never flushed.
+ */
+class UnlimitedCacheFlushManager extends CacheFlushManager {
+  static final CacheFlushManager INSTANCE = new UnlimitedCacheFlushManager();
+
+  UnlimitedCacheFlushManager() : super(DEFAULT_CACHING_POLICY, (_) => false);
+
+  @override
+  void resultAccessed(TargetedResult result) {}
+
+  @override
+  List<TargetedResult> resultStored(TargetedResult newResult, newValue) {
+    return TargetedResult.EMPTY_LIST;
+  }
+
+  @override
+  void targetRemoved(AnalysisTarget target) {}
+}