Add AnalysisCache.onResultInvalidated, use in DartWorkManager.

pkg/analyzer/test/src/context/cache_test.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 test.src.task.driver_test;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show
         AnalysisContext,
@@ skipping 473 matching lines @@
 
   test_setState_invalid() {
     AnalysisTarget target = new TestSource();
     ResultDescriptor result = new ResultDescriptor('test', 1);
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     // set VALID
     entry.setValue(result, 10, TargetedResult.EMPTY_LIST);
     expect(entry.getState(result), CacheState.VALID);
     expect(entry.getValue(result), 10);
+    // listen, expect "result" invalidation event
+    int numberOfEvents = 0;
+    cache.onResultInvalidated.listen((event) {
+      numberOfEvents++;
+      expect(event.entry, same(entry));
+      expect(event.descriptor, same(result));
+    });
     // set INVALID
     entry.setState(result, CacheState.INVALID);
     expect(entry.getState(result), CacheState.INVALID);
     expect(entry.getValue(result), 1);
+    expect(numberOfEvents, 1);
   }
 
   test_setState_invalid_dependencyCycle() {
     AnalysisTarget target1 = new TestSource('/a.dart');
     AnalysisTarget target2 = new TestSource('/b.dart');
     CacheEntry entry1 = new CacheEntry(target1);
     CacheEntry entry2 = new CacheEntry(target2);
     cache.put(entry1);
     cache.put(entry2);
     ResultDescriptor result = new ResultDescriptor('result', -1);
     // Set each result as VALID with a dependency on on the other.
     entry1.setValue(result, 100, [new TargetedResult(target2, result)]);
     entry2.setValue(result, 200, [new TargetedResult(target1, result)]);
     expect(entry1.getState(result), CacheState.VALID);
     expect(entry2.getState(result), CacheState.VALID);
+    // Listen, expect entry1.result and entry2.result invalidation events.
+    int numberOfEvents = 0;
+    bool wasEntry1 = false;
+    bool wasEntry2 = false;
+    cache.onResultInvalidated.listen((event) {
+      numberOfEvents++;
+      if (event.entry == entry1) wasEntry1 = true;
+      if (event.entry == entry2) wasEntry2 = true;
+      expect(event.descriptor, same(result));
+    });
     // Invalidate entry1.result; this should cause entry2 to be also
     // cleared without going into an infinite regress.
     entry1.setState(result, CacheState.INVALID);
     expect(cache.get(target1), isNull);
     expect(cache.get(target2), isNull);
+    expect(numberOfEvents, 2);
+    expect(wasEntry1, isTrue);
+    expect(wasEntry2, isTrue);
   }
 
   test_setState_invalid_invalidateDependent() {
     AnalysisTarget target = new TestSource();
     CacheEntry entry = new CacheEntry(target);
     cache.put(entry);
     ResultDescriptor result1 = new ResultDescriptor('result1', -1);
     ResultDescriptor result2 = new ResultDescriptor('result2', -2);
     ResultDescriptor result3 = new ResultDescriptor('result3', -3);
     ResultDescriptor result4 = new ResultDescriptor('result4', -4);
@@ skipping 443 matching lines @@
 
 class _InternalAnalysisContextMock extends TypedMock
     implements InternalAnalysisContext {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 class _TestAnalysisTarget implements AnalysisTarget {
   @override
   Source get source => null;
 }