Avoid redundant calls to "pub list" when multiple dependencies change.

pkg/analysis_server/test/context_manager_test.dart

 // Copyright (c) 2014, 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.context.directory.manager;
 
 import 'dart:collection';
 
 import 'package:analysis_server/src/context_manager.dart';
+import 'package:analysis_server/src/source/optimizing_pub_package_map_provider.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
-import 'package:analyzer/source/package_map_provider.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:path/path.dart';
 import 'package:unittest/unittest.dart';
 
 import 'mocks.dart';
 import 'reflective_tests.dart';
 
@@ skipping 827 matching lines @@
     // Change the package map dependency so that the packageMapProvider is
     // re-run, and arrange for it to return null from computePackageMap().
     packageMapProvider.packageMap = null;
     resourceProvider.modifyFile(dependencyPath, 'new contents');
     return pumpEventQueue().then((_) {
       // The package map should have been changed to null.
       _checkPackageMap(projPath, isNull);
     });
   }
 
+  test_watch_modifyPackageMapDependency_redundantly() async {
+    // Create two dependency files
+    String dependencyPath1 = posix.join(projPath, 'dep1');
+    String dependencyPath2 = posix.join(projPath, 'dep2');
+    resourceProvider.newFile(dependencyPath1, 'contents');
+    resourceProvider.newFile(dependencyPath2, 'contents');
+    packageMapProvider.dependencies.add(dependencyPath1);
+    packageMapProvider.dependencies.add(dependencyPath2);
+    // Create a dart file
+    String dartFilePath = posix.join(projPath, 'main.dart');
+    resourceProvider.newFile(dartFilePath, 'contents');
+    // Verify that the created context has the expected empty package map.
+    manager.setRoots(<String>[projPath], <String>[], <String, String>{});
+    _checkPackageMap(projPath, isEmpty);
+    expect(packageMapProvider.computeCount, 1);
+    // Set up a different package map
+    String packagePath = '/package/foo';
+    resourceProvider.newFolder(packagePath);
+    packageMapProvider.packageMap = {'foo': projPath};
+    // Change both dependencies.
+    resourceProvider.modifyFile(dependencyPath1, 'new contents');
+    resourceProvider.modifyFile(dependencyPath2, 'new contents');
+    // Arrange for the next call to computePackageMap to return the correct
+    // timestamps for the dependencies.
+    packageMapProvider.modificationTimes = <String, int>{};
+    for (String path in [dependencyPath1, dependencyPath2]) {
+      File resource = resourceProvider.getResource(path);
+      packageMapProvider.modificationTimes[path] = resource.modificationStamp;
+    }
+    // This should cause the new package map to be picked up, by executing
+    // computePackageMap just one additional time.
+    await pumpEventQueue();
+    _checkPackageMap(projPath, equals(packageMapProvider.packageMap));
+    expect(packageMapProvider.computeCount, 2);
+  }
+
   /**
    * Verify that package URI's for source files in [path] will be resolved
    * using a package map matching [expectation].
    */
   void _checkPackageMap(String path, expectation) {
     UriResolver resolver = manager.currentContextPackageUriResolvers[path];
     Map<String, List<Folder>> packageMap =
         resolver is PackageMapUriResolver ? resolver.packageMap : null;
     expect(packageMap, expectation);
   }
@@ skipping 39 matching lines @@
   final Map<String, Set<Source>> currentContextSources = <String, Set<Source>>{
   };
 
   /**
    * Map from context to package URI resolver.
    */
   final Map<String, UriResolver> currentContextPackageUriResolvers =
       <String, UriResolver>{};
 
   TestContextManager(MemoryResourceProvider resourceProvider,
-      PackageMapProvider packageMapProvider)
+      OptimizingPubPackageMapProvider packageMapProvider)
       : super(resourceProvider, packageMapProvider,
           InstrumentationService.NULL_SERVICE);
 
   /**
    * Iterable of the paths to contexts that currently exist.
    */
   Iterable<String> get currentContextPaths => currentContextTimestamps.keys;
 
   @override
   AnalysisContext addContext(Folder folder, UriResolver packageUriResolver) {
@@ skipping 50 matching lines @@
     currentContextSources.remove(path);
     currentContextPackageUriResolvers.remove(path);
   }
 
   @override
   void updateContextPackageUriResolver(
       Folder contextFolder, UriResolver packageUriResolver) {
     currentContextPackageUriResolvers[contextFolder.path] = packageUriResolver;
   }
 }