Fix hot reload test

pkg/front_end/test/src/incremental/hot_reload_e2e_test.dart

 // Copyright (c) 2017, 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.
 
 /// Integration test that runs the incremental compiler, runs the compiled
 /// program, incrementally rebuild portions of the app, and triggers a hot
 /// reload on the running program.
 library front_end.incremental.hot_reload_e2e_test;
 
 import 'dart:async';
@@ skipping 35 matching lines @@
   tearDown(() async {
     outDir.deleteSync(recursive: true);
     lines = null;
   });
 
   /// Start the VM with the first version of the program compiled by the
   /// incremental compiler.
   startProgram(int reloadCount) async {
     var vmArgs = [
       '--enable-vm-service=0', // Note: use 0 to avoid port collisions.
-      '--platform=${platformFile.toFilePath()}',
+      '--kernel-binaries=${sdkRoot.toFilePath()}',
       outputUri.toFilePath()
     ];
     vmArgs.add('$reloadCount');
     var vm = await Process.start(Platform.executable, vmArgs);
     var splitter = new LineSplitter();
 
     /// The program prints at most 2 + reloadCount lines:
     ///  - a line displaying the observatory port
     ///  - a line before waiting for a reload
     ///  - a line after each hot-reload
@@ skipping 24 matching lines @@
     var port = int.parse(match.group(1));
     var reloader = new VmReloader(port);
     var reloadResult = await reloader.reload(outputUri);
     expect(reloadResult['success'], isTrue);
     await reloader.disconnect();
   }
 
   test('initial program is valid', () async {
     await startProgram(0);
     await programIsDone;
-    expect(await lines.skip(1).first, "part1 part2");
+    expect(await lines[1], "part1 part2");
   });
 
   test('reload after leaf library modification', () async {
     await startProgram(1);
     expect(await lines[1], "part1 part2");
 
     writeFile(fs, 'b.dart', sourceB.replaceAll("part1", "part3"));
     await rebuild(compiler, outputUri);
     await hotReload();
     await programIsDone;
@@ skipping 37 matching lines @@
     writeFile(fs, 'a.dart', sourceA.replaceAll("part2", "part8"));
     await rebuild(compiler, outputUri);
     await hotReload();
     await programIsDone;
     expect(await lines[3], "part7 part8");
   });
 }
 
 var dartVm = Uri.base.resolve(Platform.resolvedExecutable);
 var sdkRoot = dartVm.resolve("patched_sdk/");
-var platformFile = sdkRoot.resolve('platform.dill');
 
 Future<IncrementalKernelGenerator> createIncrementalCompiler(
     String entry, FileSystem fs) {
   var entryUri = Uri.base.resolve(entry);
   var options = new CompilerOptions()
     ..sdkRoot = sdkRoot
     ..sdkSummary = sdkRoot.resolve('outline.dill')
     ..packagesFileUri = Uri.parse('file:///.packages')
     ..strongMode = false
     ..dartLibraries = loadDartLibraries()
@@ skipping 37 matching lines @@
 }
 
 /// This program calls a function periodically and tracks when the function
 /// returns a different value than before (which only happens after a
 /// hot-reload). The program exits after certain number of reloads, specified as
 /// an argument to main.
 const sourceA = r'''
 import 'dart:async';
 import 'b.dart';
 
-void main(List<String> args) {
+void main(List<String> args) async {
+  // Note: this short delay is used to ensure the VM can initialize observatory
+  // first and we can obtain the port number as the first line in the output.
+  // If this becomes a source of flakiness, we can make the isolate pause on
+  // start and start the program via observatory instead.

[ahe, 2017/07/10 13:59:35]

Let's to that proactively.

[Siggi Cherem (dart-lang), 2017/07/10 19:31:11]

Done.

+  await new Future.delayed(new Duration(milliseconds: 100));
   var last = f();
   print(last);
 
   // The argument indicates how many "visible" hot-reloads to run
   int reloadCount = 0;
   if (args.length > 0) {
     reloadCount = int.parse(args[0]);
   }
   if (reloadCount == 0) return;
 
   new Timer.periodic(new Duration(milliseconds: 100), (timer) {
     var result = f();
     if (last != result) {
       print(result);
       last = result;
       if (--reloadCount == 0) timer.cancel();
     }
   });
 }
 
 f() => "$line part2";
 ''';
 
 const sourceB = r'''
 get line => "part1";
 ''';
 
 RegExp observatoryPortRegExp =
     new RegExp("Observatory listening on http://127.0.0.1:\([0-9]*\)/");