Update defer loading algorithm:

tests/compiler/dart2js/serialization/model_test_helper.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 dart2js.serialization_model_test;
 
 import 'dart:async';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/closure.dart';
@@ skipping 107 matching lines @@
       compilerDeserialized.enqueuer.resolution.processedEntities,
       "Processed element mismatch",
       areElementsEquivalent, onSameElement: (a, b) {
     checkElements(compilerNormal, compilerDeserialized, a, b, verbose: verbose);
   }, verbose: verbose);
   Expect.equals(
       compilerNormal.deferredLoadTask.isProgramSplit,
       compilerDeserialized.deferredLoadTask.isProgramSplit,
       "isProgramSplit mismatch");
 
-  Map<ConstantValue, OutputUnit> constants1 =
-      compilerNormal.deferredLoadTask.outputUnitForConstantsForTesting;
-  Map<ConstantValue, OutputUnit> constants2 =
-      compilerDeserialized.deferredLoadTask.outputUnitForConstantsForTesting;
+  Iterable<ConstantValue> constants1 =
+      compilerNormal.deferredLoadTask.constantsForTesting;
+  Iterable<ConstantValue> constants2 =
+      compilerDeserialized.deferredLoadTask.constantsForTesting;
   checkSets(
-      constants1.keys,
-      constants2.keys,
+      constants1,
+      constants2,
       'deferredLoadTask._outputUnitForConstants.keys',
       areConstantValuesEquivalent,
       failOnUnfound: false,
       failOnExtra: false,
       onSameElement: (ConstantValue value1, ConstantValue value2) {
-    OutputUnit outputUnit1 = constants1[value1];
-    OutputUnit outputUnit2 = constants2[value2];
     checkOutputUnits(
-        outputUnit1,
-        outputUnit2,
+        compilerNormal,
+        compilerDeserialized,
+        compilerNormal.deferredLoadTask.outputUnitForConstant(value1),
+        compilerDeserialized.deferredLoadTask.outputUnitForConstant(value2),
         'for ${value1.toStructuredText()} '
         'vs ${value2.toStructuredText()}');
   }, onUnfoundElement: (ConstantValue value1) {
-    OutputUnit outputUnit1 = constants1[value1];
+    OutputUnit outputUnit1 =
+        compilerNormal.deferredLoadTask.outputUnitForConstant(value1);
     Expect.isTrue(outputUnit1.isMainOutput,
         "Missing deferred constant: ${value1.toStructuredText()}");
   }, onExtraElement: (ConstantValue value2) {
-    OutputUnit outputUnit2 = constants2[value2];
+    OutputUnit outputUnit2 =
+        compilerDeserialized.deferredLoadTask.outputUnitForConstant(value2);
     Expect.isTrue(outputUnit2.isMainOutput,
         "Extra deferred constant: ${value2.toStructuredText()}");
   }, elementToString: (a) {
-    return '${a.toStructuredText()} -> ${constants1[a]}/${constants2[a]}';
+    OutputUnit o1 = compilerNormal.deferredLoadTask.outputUnitForConstant(a);
+    OutputUnit o2 =
+        compilerDeserialized.deferredLoadTask.outputUnitForConstant(a);
+    return '${a.toStructuredText()} -> ${o1}/${o2}';
   });
 }
 
 void checkElements(
     Compiler compiler1, Compiler compiler2, Element element1, Element element2,
     {bool verbose: false}) {
   if (element1.isAbstract) return;
   if (element1.isFunction ||
       element1.isConstructor ||
       (element1.isField && element1.isInstanceMember)) {
@@ skipping 110 matching lines @@
   }
   return '(${node.runtimeType}) $text';
 }
 
 void checkElementOutputUnits(Compiler compiler1, Compiler compiler2,
     Element element1, Element element2) {
   OutputUnit outputUnit1 =
       compiler1.deferredLoadTask.getOutputUnitForElementForTesting(element1);
   OutputUnit outputUnit2 =
       compiler2.deferredLoadTask.getOutputUnitForElementForTesting(element2);
-  checkOutputUnits(outputUnit1, outputUnit2, 'for $element1 vs $element2');
+  checkOutputUnits(compiler1, compiler2, outputUnit1, outputUnit2,
+      'for $element1 vs $element2');
 }
 
-void checkOutputUnits(
+void checkOutputUnits(Compiler compiler1, Compiler compiler2,
     OutputUnit outputUnit1, OutputUnit outputUnit2, String message) {
   if (outputUnit1 == null && outputUnit2 == null) return;
   check(outputUnit1, outputUnit2, 'OutputUnit.isMainOutput $message',
       outputUnit1.isMainOutput, outputUnit2.isMainOutput);
   checkSetEquivalence(
       outputUnit1,
       outputUnit2,
       'OutputUnit.imports $message',
-      outputUnit1.imports,
-      outputUnit2.imports,
+      compiler1.deferredLoadTask.getImportNames(outputUnit1),
+      compiler2.deferredLoadTask.getImportNames(outputUnit2),
       (a, b) => areElementsEquivalent(a.declaration, b.declaration));
 }