dart2js: Support https.

tests/compiler/dart2js/http_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.
 //
 // Test:
 //   *) Compiling a script fetched over HTTP.
 //   *) Importing a library fetched over HTTP.
 //   *) Automatically resolving package_root when script is fetched over HTTP.
 
 library http_launch_test;
 
 import 'dart:async';
 import 'dart:io';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:path/path.dart' as path;
 
 Uri pathOfData = Platform.script.resolve('http_launch_data/');
-int port;
 Directory tempDir;
 String outFilePath;
 
 _sendNotFound(HttpResponse response) {
   response.statusCode = HttpStatus.NOT_FOUND;
   response.close();
 }
 
 Future handleRequest(HttpRequest request) {
   final String path = request.uri.path.substring(1);
@@ skipping 40 matching lines @@
 }
 
 Future testNonHttp() {
   String inFilePath = pathOfData.resolve('http_launch_main.dart').toFilePath();
   List<String> args = [inFilePath, "--out=" + outFilePath];
   return launchDart2Js(args)
       .then(check)
       .then((_) { cleanup(); });
 }
 
-Future testHttp() {
-  String inFilePath = 'http://127.0.0.1:$port/http_launch_main.dart';
+Future testHttpMain(String serverUrl) {
+  String inFilePath = '$serverUrl/http_launch_main.dart';
   List<String> args = [inFilePath, "--out=" + outFilePath];
   return launchDart2Js(args)
       .then(check)
       .then((_) { cleanup(); });
 }
 
-Future testHttpLib() {
+Future testHttpLib(String serverUrl) {
   File file = new File(path.join(tempDir.path, "in.dart"));
   file.writeAsStringSync("""
-  import 'http://127.0.0.1:$port/lib1.dart';
+  import '$serverUrl/lib1.dart';
   main() { print(foo()); }
   """);
   String inFilePath = file.path;
   List<String> args = [inFilePath, "--out=" + outFilePath];
   return launchDart2Js(args)
       .then(check)
       .whenComplete(file.deleteSync)
       .then((_) { cleanup(); });
 }
 
-Future testHttpPackage() {
+Future testHttpPackage(String serverUrl) {
   String inFilePath =
       pathOfData.resolve('http_launch_main_package.dart').toFilePath();
-  String packageRoot = 'http://127.0.0.1:$port/packages/';
+  String packageRoot = '$serverUrl/packages/';
   List<String> args = [inFilePath,
                        "--out=" + outFilePath,
                        "--package-root=" + packageRoot];
   return launchDart2Js(args)
       .then(check)
       .then((_) { cleanup(); });
 }
 
-Future testBadHttp() {
+Future testBadHttp(String serverUrl) {
   File file = new File(path.join(tempDir.path, "in_bad.dart"));
   file.writeAsStringSync("""
-  import 'http://127.0.0.1:$port/not_existing.dart';
+  import '$serverUrl/not_existing.dart';
   main() { print(foo()); }
   """);
   String inFilePath = file.path;
   List<String> args = [inFilePath, "--out=" + outFilePath];
   return launchDart2Js(args)
       .then((pr) => checkNotFound(pr, "not_existing.dart"))
       .whenComplete(file.deleteSync)
       .then((_) { cleanup(); });
 }
 
-Future testBadHttp2() {
-  String inFilePath = 'http://127.0.0.1:$port/not_found.dart';
+Future testBadHttp2(String serverUrl) {
+  String inFilePath = '$serverUrl/not_found.dart';
   List<String> args = [inFilePath, "--out=" + outFilePath];
   return launchDart2Js(args)
       .then((processResult) => checkNotFound(processResult, "not_found.dart"))
       .then((_) { cleanup(); });
 }
 
-serverRunning(HttpServer server) {
-  port = server.port;
+serverRunning(HttpServer server, String scheme) {
   tempDir = Directory.systemTemp.createTempSync('directory_test');
   outFilePath = path.join(tempDir.path, "out.js");
+  int port = server.port;
+  String serverUrl = "$scheme://127.0.0.1:$port";
 
   asyncStart();
   server.listen(handleRequest);
-  new Future.value()
+  return new Future.value()
        .then((_) => cleanup())  // Make sure we start fresh.
        .then((_) => testNonHttp())
-       .then((_) => testHttp())
-       .then((_) => testHttpLib())
-       .then((_) => testHttpPackage())
-       .then((_) => testBadHttp())
-       .then((_) => testBadHttp2())
+       .then((_) => testHttpMain(serverUrl))
+       .then((_) => testHttpLib(serverUrl))
+       .then((_) => testHttpPackage(serverUrl))
+       .then((_) => testBadHttp(serverUrl))
+       .then((_) => testBadHttp2(serverUrl))
        .whenComplete(() => tempDir.delete(recursive: true))
        .whenComplete(server.close)
        .then((_) => asyncEnd());
 }
 
+Future testHttp() {
+  return HttpServer.bind(InternetAddress.LOOPBACK_IP_V4, 0)
+      .then((HttpServer server) => serverRunning(server, "http"));
+}
+
+void initializeSSL() {
+  Uri pathOfPkcert = pathOfData.resolve('pkcert');
+  String testPkcertDatabase = pathOfPkcert.toFilePath();
+  SecureSocket.initialize(database: testPkcertDatabase,
+                          password: 'dartdart');
+}
+
+Future testHttps() {
+  initializeSSL();
+  return HttpServer.bindSecure(InternetAddress.LOOPBACK_IP_V4,
+                               0,
+                               certificateName: 'localhost_cert')
+      .then((HttpServer server) => serverRunning(server, "https"));
+}
+
 main() {
-  HttpServer.bind(InternetAddress.LOOPBACK_IP_V4, 0).then(serverRunning);
+  asyncStart();
+  testHttp()
+    .then((_) => testHttps)
+    .whenComplete(asyncEnd);
 }