Support multiple serialization sources in DeserializerSystemImpl.

tests/compiler/dart2js/serialization/library_test.dart

 // Copyright (c) 2016, 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_library_test;
 
+import 'dart:async';
 import 'dart:io';
 import '../memory_compiler.dart';
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common/names.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/diagnostics/invariant.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/serialization/json_serializer.dart';
 import 'package:compiler/src/serialization/serialization.dart';
@@ skipping 23 matching lines @@
       if (entryPoint != null) {
         print("Multiple entrypoints are not supported.");
       }
       entryPoint = Uri.parse(arg);
     }
   }
   if (entryPoint == null) {
     entryPoint = Uris.dart_core;
   }
   asyncTest(() async {
-    CompilationResult result = await runCompiler(
+    Compiler compiler = await compilerFor(
         entryPoint: entryPoint, options: [Flags.analyzeAll]);
-    Compiler compiler = result.compiler;
-    testSerialization(compiler.libraryLoader.libraries,
-                      outPath: outPath,
-                      prettyPrint: prettyPrint,
-                      shardCount: shardCount);
+    compiler.serialization.supportSerialization = true;
+    await compiler.run(entryPoint);
+    List<String> data =
+        createData(compiler,
+                   outPath: outPath,
+                   prettyPrint: prettyPrint,
+                   shardCount: shardCount);
+    testEquivalence(data, compiler.libraryLoader.libraries);
+    await testAnalysis(data, entryPoint);
   });
 }
 
-void testSerialization(Iterable<LibraryElement> libraries1,
-                       {String outPath,
-                        bool prettyPrint,
-                        int shardCount: 3}) {
+List<String> createData(
+    Compiler compiler,
+    {String outPath,
+     bool prettyPrint,
+     int shardCount: 3}) {
+  Iterable<LibraryElement> libraries1 = compiler.libraryLoader.libraries;
   if (shardCount < 1 || shardCount > libraries1.length) {
     shardCount = libraries1.length;
   }
   List<List<LibraryElement>> librarySplits = <List<LibraryElement>>[];
   int offset = 0;
   int shardSize = (libraries1.length / shardCount).ceil();
   for (int shard = 0; shard < shardCount; shard++) {
     List<LibraryElement> libraries = <LibraryElement>[];
     for (int index = 0; index < shardSize; index++) {
       if (offset + index < libraries1.length) {
         libraries.add(libraries1.elementAt(offset + index));
       }
     }
     librarySplits.add(libraries);
     offset += shardSize;
   }
   print(librarySplits.join('\n'));
   List<String> texts = <String>[];
   for (int shard = 0; shard < shardCount; shard++) {
     List<LibraryElement> libraries = librarySplits[shard];
-    Serializer serializer = new Serializer(
-        shouldInclude: (e) => libraries.contains(e.library));
-    for (LibraryElement library in libraries) {
-      serializer.serialize(library);
-    }
+    Serializer serializer =
+        compiler.serialization.createSerializer(libraries);
     String text = serializer.toText(const JsonSerializationEncoder());
     String outText = text;
     if (prettyPrint) {
       outText = serializer.prettyPrint();
     }
     if (outPath != null) {
       String name = outPath;
       String ext = '';
       int dotPos = outPath.lastIndexOf('.');
       if (dotPos != -1) {
         name = outPath.substring(0, dotPos);
         ext = outPath.substring(dotPos);
       }
       new File('$name$shard$ext').writeAsStringSync(outText);
     } else if (prettyPrint) {
       print(outText);
     }
     texts.add(text);
   }
+  return texts;
+}
+
+void testEquivalence(List<String> data, Iterable<LibraryElement> libraries1) {
   DeserializationContext deserializationContext =
       new DeserializationContext();
-  for (int shard = 0; shard < shardCount; shard++) {
-    new Deserializer.fromText(
-        deserializationContext, texts[shard], const JsonSerializationDecoder());
+  for (String shardData in data) {
+    Deserializer deserializer = new Deserializer.fromText(
+        deserializationContext, shardData, const JsonSerializationDecoder());
+    deserializationContext.deserializers.add(deserializer);
   }
-  List<LibraryElement> libraries2 = <LibraryElement>[];
   for (LibraryElement library1 in libraries1) {
     LibraryElement library2 =
         deserializationContext.lookupLibrary(library1.canonicalUri);
     if (library2 == null) {
       throw new ArgumentError('No library ${library1.canonicalUri} found.');
     }
     checkLibraryContent('library1', 'library2', 'library', library1, library2);
-    libraries2.add(library2);
   }
+}
+
+Future testAnalysis(List<String> data, Uri entryPoint) async {
+  Compiler compiler = compilerFor(entryPoint: entryPoint,
+      options: [Flags.analyzeAll]);
+  for (String shardData in data) {
+    compiler.serialization.deserializeFromText(shardData);
+  }
+  await compiler.run(entryPoint);
 }