Replace the configuration map with a typed object.

tools/testing/dart/configuration.dart

Index: tools/testing/dart/configuration.dart
diff --git a/tools/testing/dart/configuration.dart b/tools/testing/dart/configuration.dart
new file mode 100644
index 0000000000000000000000000000000000000000..6c9e2db5246057623fe760efef1ae4e41be4efbf
--- /dev/null
+++ b/tools/testing/dart/configuration.dart
@@ -0,0 +1,882 @@
+// 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.
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
+import 'compiler_configuration.dart';
+import 'http_server.dart';
+import 'path.dart';
+import 'runtime_configuration.dart';
+import 'test_suite.dart';
+
+/// All of the contextual information to determine how a test suite should be
+/// run.
+///
+/// Includes the compiler used to compile the code, the runtime the result is
+/// executed on, etc.
+class Configuration {
+  Configuration(
+      {this.architecture,
+      this.compiler,
+      this.mode,
+      this.progress,
+      this.runtime,
+      this.system,
+      this.selectors,
+      this.appendLogs,
+      this.batch,
+      this.batchDart2JS,
+      this.copyCoreDumps,
+      this.hotReload,
+      this.hotReloadRollback,
+      this.isChecked,
+      this.isStrong,
+      this.isHostChecked,
+      this.isCsp,
+      this.isMinified,
+      this.isVerbose,
+      this.listTests,
+      this.printTiming,
+      this.printReport,
+      this.reportInJson,
+      this.resetBrowser,
+      this.skipCompilation,
+      this.useBlobs,
+      this.useSdk,
+      this.useCpsIR,
+      this.useFastStartup,
+      this.useDart2JSWithKernel,
+      this.writeDebugLog,
+      this.writeTestOutcomeLog,
+      this.drtPath,
+      this.dartiumPath,
+      this.chromePath,
+      this.safariPath,
+      this.firefoxPath,
+      this.dartPath,
+      this.dartPrecompiledPath,
+      this.flutterPath,
+      this.recordingPath,
+      this.replayPath,
+      this.taskCount,
+      int timeout,
+      this.shardCount,
+      this.shard,
+      this.stepName,
+      this.testServerPort,
+      this.testServerCrossOriginPort,
+      this.testDriverErrorPort,
+      this.localIP,
+      this.dart2jsOptions,
+      this.vmOptions,
+      String packages,
+      this.packageRoot,
+      this.suiteDirectory,
+      this.builderTag,
+      this.reproducingArguments})
+      : _packages = packages,
+        _timeout = timeout;
+
+  final Architecture architecture;
+  final Compiler compiler;
+  final Mode mode;
+  final Progress progress;
+  final Runtime runtime;
+  final System system;
+
+  final Map<String, RegExp> selectors;
+
+  // Boolean flags.
+
+  final bool appendLogs;
+  final bool batch;
+  final bool batchDart2JS;
+  final bool copyCoreDumps;
+  final bool hotReload;
+  final bool hotReloadRollback;
+  final bool isChecked;
+  final bool isStrong;
+  final bool isHostChecked;
+  final bool isCsp;
+  final bool isMinified;
+  final bool isVerbose;
+  final bool listTests;
+  final bool printTiming;
+  final bool printReport;
+  final bool reportInJson;
+  final bool resetBrowser;
+  final bool skipCompilation;
+  final bool useBlobs;
+  final bool useSdk;
+  final bool useCpsIR;
+  final bool useFastStartup;
+  final bool useDart2JSWithKernel;
+  final bool writeDebugLog;
+  final bool writeTestOutcomeLog;
+
+  // Various file paths.
+
+  final String drtPath;
+  final String dartiumPath;
+  final String chromePath;
+  final String safariPath;
+  final String firefoxPath;
+  final String dartPath;
+  final String dartPrecompiledPath;
+  final String flutterPath;
+  final String recordingPath;
+  final String replayPath;
+
+  final int taskCount;
+  final int shardCount;
+  final int shard;
+  final String stepName;
+
+  final int testServerPort;
+  final int testServerCrossOriginPort;
+  final int testDriverErrorPort;
+  final String localIP;
+
+  /// Extra dart2js options passed to the testing script.
+  final List<String> dart2jsOptions;
+
+  /// Extra VM options passed to the testing script.
+  final List<String> vmOptions;
+
+  String _packages;
+  String get packages {
+    // If the .packages file path wasn't given, find it.
+    if (packageRoot == null && _packages == null) {
+      _packages = TestUtils.dartDirUri.resolve('.packages').toFilePath();
+    }
+
+    return _packages;
+  }
+
+  final String packageRoot;
+  final String suiteDirectory;
+  final String builderTag;
+  final List<String> reproducingArguments;
+
+  TestingServers _servers;
+  TestingServers get servers {
+    if (_servers == null) {
+      throw new StateError("Servers have not been started yet.");
+    }
+    return _servers;
+  }
+
+  /// The base directory named for this configuration, like:
+  ///
+  ///     none_vm_release_x64
+  String _configurationDirectory;
+  String get configurationDirectory {
+    // Lazy initialize and cache since it requires hitting the file system.
+    if (_configurationDirectory == null) {
+      _configurationDirectory = _calculateDirectory();
+    }
+
+    return _configurationDirectory;
+  }
+
+  /// The build directory path for this configuration, like:
+  ///
+  ///     build/none_vm_release_x64
+  String get buildDirectory => system.outputDirectory + configurationDirectory;
+
+  int _timeout;
+  int get timeout {
+    if (_timeout == null) {
+      var isReload = hotReload || hotReloadRollback;
+
+      var compilerMulitiplier = compilerConfiguration.timeoutMultiplier;
+      var runtimeMultiplier = runtimeConfiguration.timeoutMultiplier(
+          mode: mode,
+          isChecked: isChecked,
+          isReload: isReload,
+          arch: architecture);
+
+      _timeout = 60 * compilerMulitiplier * runtimeMultiplier;
+    }
+
+    return _timeout;
+  }
+
+  List<String> get standardOptions {
+    if (compiler != Compiler.dart2js) {
+      return const ["--ignore-unrecognized-flags"];
+    }
+
+    var args = ['--generate-code-with-compile-time-errors', '--test-mode'];
+    if (isChecked) args.add('--enable-checked-mode');
+
+    // args.add("--verbose");

[Bill Hesse, 2017/05/29 13:08:28]

Remove commented code.

[Bob Nystrom, 2017/05/30 23:29:31]

Done.

+    if (!runtime.isBrowser) {
+      args.add("--allow-mock-compilation");
+      args.add("--categories=all");
+    }
+
+    if (isMinified) args.add("--minify");
+    if (isCsp) args.add("--csp");
+    if (useCpsIR) args.add("--use-cps-ir");
+    if (useFastStartup) args.add("--fast-startup");
+    if (useDart2JSWithKernel) args.add("--use-kernel");
+    return args;
+  }
+
+  String _windowsSdkPath;
+  String get windowsSdkPath {
+    if (!Platform.isWindows) {
+      throw new StateError(
+          "Should not use windowsSdkPath when not running on Windows.");
+    }
+
+    if (_windowsSdkPath == null) {
+      // When running tests on Windows, use cdb from depot_tools to dump
+      // stack traces of tests timing out.
+      try {
+        var path = new Path("build/win_toolchain.json").toNativePath();
+        var text = new File(path).readAsStringSync();
+        _windowsSdkPath = JSON.decode(text)['win_sdk'] as String;
+      } on dynamic {
+        // Ignore errors here. If win_sdk is not found, stack trace dumping
+        // for timeouts won't work.
+      }
+    }
+
+    return _windowsSdkPath;
+  }
+
+  /// Gets the local file path to the browser executable for this configuration.

[Bill Hesse, 2017/05/29 13:08:28]

I think this would go better in runtime_configuration

[Bob Nystrom, 2017/05/30 23:29:31]

This relies on chromePath, dartiumPath, et al., which are all defined on
Configuration. I could move this into RuntimeConfiguration (or Runtime for that
matter), but then those would all have to be passed in, so I don't think it's
worth doing. If it didn't use those, definitely I would move it down.

+  String get browserLocation {
+    // If the user has explicitly configured a browser path, use it.
+    String location;
+    switch (runtime) {
+      case Runtime.chrome:
+        location = chromePath;
+        break;
+      case Runtime.dartium:
+        location = dartiumPath;
+        break;
+      case Runtime.drt:
+        location = drtPath;
+        break;
+      case Runtime.firefox:
+        location = firefoxPath;
+        break;
+      case Runtime.flutter:
+        location = flutterPath;
+        break;
+      case Runtime.safari:
+        location = safariPath;
+        break;
+    }
+
+    if (location != null) return location;
+
+    const locations = const {
+      Runtime.firefox: const {
+        System.windows: 'C:\\Program Files (x86)\\Mozilla Firefox\\firefox.exe',
+        System.linux: 'firefox',
+        System.macos: '/Applications/Firefox.app/Contents/MacOS/firefox'
+      },
+      Runtime.chrome: const {
+        System.windows:
+            'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+        System.macos:
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+        System.linux: 'google-chrome'
+      },
+      Runtime.dartium: const {
+        System.windows: 'client\\tests\\dartium\\chrome.exe',
+        System.macos:
+            'client/tests/dartium/Chromium.app/Contents/MacOS/Chromium',
+        System.linux: 'client/tests/dartium/chrome'
+      },
+      Runtime.safari: const {
+        System.macos: '/Applications/Safari.app/Contents/MacOS/Safari'
+      },
+      Runtime.safariMobileSim: const {
+        System.macos: '/Applications/Xcode.app/Contents/Developer/Platforms/'
+            'iPhoneSimulator.platform/Developer/Applications/'
+            'iPhone Simulator.app/Contents/MacOS/iPhone Simulator'
+      },
+      Runtime.ie9: const {
+        System.windows: 'C:\\Program Files\\Internet Explorer\\iexplore.exe'
+      },
+      Runtime.ie10: const {
+        System.windows: 'C:\\Program Files\\Internet Explorer\\iexplore.exe'
+      },
+      Runtime.ie11: const {
+        System.windows: 'C:\\Program Files\\Internet Explorer\\iexplore.exe'
+      }
+    };
+
+    location = locations[runtime][System.find(Platform.operatingSystem)];
+
+    if (location == null) {
+      throw "${runtime.name} is not supported on ${Platform.operatingSystem}";
+    }
+
+    return location;
+  }
+
+  RuntimeConfiguration _runtimeConfiguration;

[Bill Hesse, 2017/05/29 13:08:28]

Same here - couldn't the function go in runtime_configuration, and only the
getter and cache be in the configuration?

[Bob Nystrom, 2017/05/30 23:29:31]

My goal was to get rid of all of the "configuration." calls in the body,
especially in CompilerConfiguration. It seemed a little shorter to move the
logic right into Configuration. But I agree, it's weird. Moved it back.

+  RuntimeConfiguration get runtimeConfiguration {
+    if (_runtimeConfiguration == null) {
+      switch (runtime) {
+        case Runtime.contentShellOnAndroid:
+        case Runtime.dartiumOnAndroid:
+        case Runtime.chrome:
+        case Runtime.chromeOnAndroid:
+        case Runtime.dartium:
+        case Runtime.firefox:
+        case Runtime.ie11:
+        case Runtime.ie10:
+        case Runtime.ie9:
+        case Runtime.opera:
+        case Runtime.safari:
+        case Runtime.safariMobileSim:
+          // TODO(ahe): Replace this with one or more browser runtimes.
+          _runtimeConfiguration = new DummyRuntimeConfiguration();
+          break;
+
+        case Runtime.jsshell:
+          _runtimeConfiguration = new JsshellRuntimeConfiguration();
+          break;
+
+        case Runtime.d8:
+          _runtimeConfiguration = new D8RuntimeConfiguration();
+          break;
+
+        case Runtime.none:
+          _runtimeConfiguration = new NoneRuntimeConfiguration();
+          break;
+
+        case Runtime.vm:
+          _runtimeConfiguration = new StandaloneDartRuntimeConfiguration();
+          break;
+
+        case Runtime.flutter:
+          _runtimeConfiguration = new StandaloneFlutterEngineConfiguration();
+          break;
+
+        case Runtime.dartPrecompiled:
+          if (system == System.android) {
+            _runtimeConfiguration =
+                new DartPrecompiledAdbRuntimeConfiguration(useBlobs: useBlobs);
+          } else {
+            _runtimeConfiguration =
+                new DartPrecompiledRuntimeConfiguration(useBlobs: useBlobs);
+          }
+          break;
+
+        case Runtime.drt:
+          _runtimeConfiguration = new DrtRuntimeConfiguration();
+          break;
+
+        case Runtime.selfCheck:
+          _runtimeConfiguration = new SelfCheckRuntimeConfiguration();
+          break;
+
+        default:
+          assert(false);
+      }
+    }
+
+    return _runtimeConfiguration;
+  }
+
+  CompilerConfiguration _compilerConfiguration;
+  CompilerConfiguration get compilerConfiguration {
+    if (_compilerConfiguration == null) {
+      switch (compiler) {
+        case Compiler.dart2analyzer:
+          _compilerConfiguration = new AnalyzerCompilerConfiguration(
+              isDebug: mode.isDebug,
+              isChecked: isChecked,
+              isStrong: isStrong,
+              isHostChecked: isHostChecked,
+              useSdk: useSdk);
+          break;
+
+        case Compiler.dart2js:
+          _compilerConfiguration = new Dart2jsCompilerConfiguration(
+              isDebug: mode.isDebug,
+              isChecked: isChecked,
+              isHostChecked: isHostChecked,
+              useCps: useCpsIR,
+              useSdk: useSdk,
+              isCsp: isCsp,
+              useFastStartup: useFastStartup,
+              useKernel: useDart2JSWithKernel,
+              extraDart2jsOptions: dart2jsOptions);
+          break;
+
+        case Compiler.appJit:
+          _compilerConfiguration = new AppJitCompilerConfiguration(
+              isDebug: mode.isDebug, isChecked: isChecked);
+          break;
+
+        case Compiler.precompiler:
+          _compilerConfiguration = new PrecompilerCompilerConfiguration(
+              isDebug: mode.isDebug,
+              isChecked: isChecked,
+              arch: architecture,
+              useBlobs: useBlobs,
+              isAndroid: system == System.android);
+          break;
+
+        case Compiler.dartk:
+          _compilerConfiguration = new NoneCompilerConfiguration(
+              isDebug: mode.isDebug,
+              isChecked: isChecked,
+              isHostChecked: isHostChecked,
+              useSdk: useSdk,
+              hotReload: hotReload,
+              hotReloadRollback: hotReloadRollback,
+              useDFE: true);
+          break;
+
+        case Compiler.dartkp:
+          _compilerConfiguration = new PrecompilerCompilerConfiguration(
+              isDebug: mode.isDebug,
+              isChecked: isChecked,
+              arch: architecture,
+              useBlobs: useBlobs,
+              isAndroid: system == System.android,
+              useDFE: true);
+          break;
+
+        case Compiler.none:
+          _compilerConfiguration = new NoneCompilerConfiguration(
+              isDebug: mode.isDebug,
+              isChecked: isChecked,
+              isHostChecked: isHostChecked,
+              useSdk: useSdk,
+              hotReload: hotReload,
+              hotReloadRollback: hotReloadRollback);
+          break;
+
+        default:
+          assert(false);
+      }
+    }
+
+    return _compilerConfiguration;
+  }
+
+  /// Determines if this configuration has a compatible compiler and runtime
+  /// and other valid fields.
+  ///
+  /// Prints a warning if the configuration isn't valid. Returns whether or not
+  /// it is.
+  bool validate() {
+    var isValid = true;
+    var validRuntimes = compiler.supportedRuntimes;
+
+    if (!validRuntimes.contains(runtime)) {
+      print("Warning: combination of compiler '${compiler.name}' and "
+          "runtime '${runtime.name}' is invalid. Skipping this combination.");
+      isValid = false;
+    }
+
+    if (runtime.isIE && Platform.operatingSystem != 'windows') {
+      print("Warning: cannot run Internet Explorer on non-Windows operating"
+          " system.");
+      isValid = false;
+    }
+
+    if (shard < 1 || shard > shardCount) {
+      print("Error: shard index is $shard out of $shardCount shards");
+      isValid = false;
+    }
+
+    if (runtime == Runtime.flutter && flutterPath == null) {
+      print("-rflutter requires the flutter engine executable to "
+          "be specified using --flutter");
+      isValid = false;
+    }
+
+    if (runtime == Runtime.flutter && architecture != Architecture.x64) {
+      isValid = false;
+      print("-rflutter is applicable only for --arch=x64");
+    }
+
+    return isValid;
+  }
+
+  /// Starts global HTTP servers that serve the entire dart repo.
+  ///
+  /// The HTTP server is available on `window.location.port`, and a second
+  /// server for cross-domain tests can be found by calling
+  /// `getCrossOriginPortNumber()`.
+  Future startServers() {
+    _servers = new TestingServers(
+        buildDirectory, isCsp, runtime, null, packageRoot, packages);
+    var future = servers.startServers(localIP,
+        port: testServerPort, crossOriginPort: testServerCrossOriginPort);
+
+    if (isVerbose) {
+      future = future.then((_) {
+        print('Started HttpServers: ${servers.httpServerCommandLine()}');
+      });
+    }
+
+    return future;
+  }
+
+  void stopServers() {
+    if (_servers != null) _servers.stopServers();
+  }
+
+  /// Returns the correct configuration directory (the last component of the
+  /// output directory path) for regular dart checkouts.
+  ///
+  /// Dartium checkouts use the `--build-directory` option to pass in the
+  /// correct build directory explicitly. We allow our code to have been cross
+  /// compiled, i.e., that there is an X in front of the arch. We don't allow
+  /// both a cross compiled and a normal version to be present (except if you
+  /// specifically pass in the build_directory).
+  String _calculateDirectory() {
+    // Capitalize the mode name.
+    var modeName =
+        mode.name.substring(0, 1).toUpperCase() + mode.name.substring(1);
+
+    var os = '';
+    if (system == System.android) os = "Android";
+
+    var arch = architecture.name.toUpperCase();
+    var normal = '$modeName$os$arch';
+    var cross = '$modeName${os}X$arch';
+    var outDir = system.outputDirectory;
+    var normalDir = new Directory(new Path('$outDir$normal').toNativePath());
+    var crossDir = new Directory(new Path('$outDir$cross').toNativePath());
+
+    if (normalDir.existsSync() && crossDir.existsSync()) {
+      throw "You can't have both $normalDir and $crossDir. We don't know which"
+          " binary to use.";
+    }
+
+    if (crossDir.existsSync()) return cross;
+
+    return normal;
+  }
+}
+
+class Architecture {
+  static const ia32 = const Architecture._('ia32');
+  static const x64 = const Architecture._('x64');
+  static const arm = const Architecture._('arm');
+  static const armv6 = const Architecture._('armv6');
+  static const armv5te = const Architecture._('armv5te');
+  static const arm64 = const Architecture._('arm64');
+  static const simarm = const Architecture._('simarm');
+  static const simarmv6 = const Architecture._('simarmv6');
+  static const simarmv5te = const Architecture._('simarmv5te');
+  static const simarm64 = const Architecture._('simarm64');
+  static const mips = const Architecture._('mips');
+  static const simmips = const Architecture._('simmips');
+  static const simdbc = const Architecture._('simdbc');
+  static const simdbc64 = const Architecture._('simdbc64');
+
+  static final List<String> names = _all.keys.toList();
+
+  static final _all = new Map<String, Architecture>.fromIterable([
+    ia32,
+    x64,
+    arm,
+    armv6,
+    armv5te,
+    arm64,
+    simarm,
+    simarmv6,
+    simarmv5te,
+    simarm64,
+    mips,
+    simmips,
+    simdbc,
+    simdbc64
+  ], key: (Architecture architecture) => architecture.name);
+
+  static Architecture find(String name) {
+    var architecture = _all[name];
+    if (architecture != null) return architecture;
+
+    throw new ArgumentError('Unknown architecture "$name".');
+  }
+
+  final String name;
+
+  const Architecture._(this.name);
+
+  String toString() => "Architecture($name)";
+}
+
+class Compiler {
+  static const none = const Compiler._('none');
+  static const precompiler = const Compiler._('precompiler');
+  static const dart2js = const Compiler._('dart2js');
+  static const dart2analyzer = const Compiler._('dart2analyzer');
+  static const appJit = const Compiler._('app_jit');
+  static const dartk = const Compiler._('dartk');
+  static const dartkp = const Compiler._('dartkp');
+
+  static final List<String> names = _all.keys.toList();
+
+  static final _all = new Map<String, Compiler>.fromIterable(
+      [none, precompiler, dart2js, dart2analyzer, appJit, dartk, dartkp],
+      key: (Compiler compiler) => compiler.name);
+
+  static Compiler find(String name) {
+    var compiler = _all[name];
+    if (compiler != null) return compiler;
+
+    throw new ArgumentError('Unknown compiler "$name".');
+  }
+
+  final String name;
+
+  const Compiler._(this.name);
+
+  /// Gets the runtimes this compiler can target.
+  List<Runtime> get supportedRuntimes {
+    switch (this) {

[Bill Hesse, 2017/05/29 13:08:28]

Could these be on the compiler configurations, or aren't they created at the
point we need these?

Could they move to compiler_configuration in any case?

[Bob Nystrom, 2017/05/30 23:29:31]

They could, yes. But they don't rely on any of the state in
CompilerConfiguration, so I thought it made more sense to have them here. My
rough rule of thumb is to put code near the data it requires and put methods on
the most stateless classes there are that still have the data the method needs.

+      case Compiler.dart2js:
+        // Note: by adding 'none' as a configuration, if the user
+        // runs test.py -c dart2js -r drt,none the dart2js_none and
+        // dart2js_drt will be duplicating work. If later we don't need 'none'
+        // with dart2js, we should remove it from here.
+        return const [
+          Runtime.d8,
+          Runtime.jsshell,
+          Runtime.drt,
+          Runtime.none,
+          Runtime.dartium,
+          Runtime.firefox,
+          Runtime.chrome,
+          Runtime.safari,
+          Runtime.ie9,
+          Runtime.ie10,
+          Runtime.ie11,
+          Runtime.opera,
+          Runtime.chromeOnAndroid,
+          Runtime.safariMobileSim
+        ];
+
+      case Compiler.dart2analyzer:
+        return const [Runtime.none];
+      case Compiler.appJit:
+      case Compiler.dartk:
+        return const [Runtime.vm, Runtime.selfCheck, Runtime.none];
+      case Compiler.precompiler:
+      case Compiler.dartkp:
+        return const [Runtime.dartPrecompiled];
+      case Compiler.none:
+        return const [
+          Runtime.vm,
+          Runtime.flutter,
+          Runtime.drt,
+          Runtime.dartium,
+          Runtime.contentShellOnAndroid,
+          Runtime.dartiumOnAndroid
+        ];
+    }
+
+    throw "unreachable";
+  }
+
+  String toString() => "Compiler($name)";
+}
+
+class Mode {
+  static const debug = const Mode._('debug');
+  static const product = const Mode._('product');
+  static const release = const Mode._('release');
+
+  static final List<String> names = _all.keys.toList();
+
+  static final _all = new Map<String, Mode>.fromIterable(
+      [debug, product, release],
+      key: (Mode mode) => mode.name);
+
+  static Mode find(String name) {
+    var mode = _all[name];
+    if (mode != null) return mode;
+
+    throw new ArgumentError('Unknown mode "$name".');
+  }
+
+  final String name;
+
+  const Mode._(this.name);
+
+  bool get isDebug => this == debug;
+
+  String toString() => "Mode($name)";
+}
+
+class Progress {
+  static const compact = const Progress._('compact');
+  static const color = const Progress._('color');
+  static const line = const Progress._('line');
+  static const verbose = const Progress._('verbose');
+  static const silent = const Progress._('silent');
+  static const status = const Progress._('status');
+  static const buildbot = const Progress._('buildbot');
+  static const diff = const Progress._('diff');
+
+  static final List<String> names = _all.keys.toList();
+
+  static final _all = new Map<String, Progress>.fromIterable(
+      [compact, color, line, verbose, silent, status, buildbot, diff],
+      key: (Progress progress) => progress.name);
+
+  static Progress find(String name) {
+    var progress = _all[name];
+    if (progress != null) return progress;
+
+    throw new ArgumentError('Unknown progress type "$name".');
+  }
+
+  final String name;
+
+  const Progress._(this.name);
+
+  String toString() => "Progress($name)";
+}
+
+class Runtime {
+  static const vm = const Runtime._('vm');
+  static const flutter = const Runtime._('flutter');
+  static const dartPrecompiled = const Runtime._('dart_precompiled');
+  static const d8 = const Runtime._('d8');
+  static const jsshell = const Runtime._('jsshell');
+  static const drt = const Runtime._('drt');
+  static const dartium = const Runtime._('dartium');
+  static const firefox = const Runtime._('firefox');
+  static const chrome = const Runtime._('chrome');
+  static const safari = const Runtime._('safari');
+  static const ie9 = const Runtime._('ie9');
+  static const ie10 = const Runtime._('ie10');
+  static const ie11 = const Runtime._('ie11');
+  static const opera = const Runtime._('opera');
+  static const chromeOnAndroid = const Runtime._('chromeOnAndroid');
+  static const safariMobileSim = const Runtime._('safarimobilesim');
+  static const contentShellOnAndroid = const Runtime._('ContentShellOnAndroid');
+  static const dartiumOnAndroid = const Runtime._('DartiumOnAndroid');
+  static const selfCheck = const Runtime._('self_check');
+  static const none = const Runtime._('none');
+
+  static final List<String> names = _all.keys.toList()..add("ff");
+
+  static final _all = new Map<String, Runtime>.fromIterable([
+    vm,
+    flutter,
+    dartPrecompiled,
+    d8,
+    jsshell,
+    drt,
+    dartium,
+    firefox,
+    chrome,
+    safari,
+    ie9,
+    ie10,
+    ie11,
+    opera,
+    chromeOnAndroid,
+    safariMobileSim,
+    contentShellOnAndroid,
+    dartiumOnAndroid,
+    selfCheck,
+    none
+  ], key: (Runtime runtime) => runtime.name);
+
+  static Runtime find(String name) {
+    // Allow "ff" as a synonym for Firefox.
+    if (name == "ff") return firefox;
+
+    var runtime = _all[name];
+    if (runtime != null) return runtime;
+
+    throw new ArgumentError('Unknown runtime "$name".');
+  }
+
+  final String name;
+
+  const Runtime._(this.name);
+
+  bool get isBrowser => const [
+        drt,
+        dartium,
+        ie9,
+        ie10,
+        ie11,
+        safari,
+        opera,
+        chrome,
+        firefox,
+        chromeOnAndroid,
+        safariMobileSim,
+        contentShellOnAndroid,
+        dartiumOnAndroid,
+      ].contains(this);
+
+  bool get isIE => name.startsWith("ie");
+  bool get isSafari => name.startsWith("safari");
+
+  /// Whether this runtime is a command-line JavaScript environment.
+  bool get isJSCommandLine => const [d8, jsshell].contains(this);
+
+  /// If the runtime doesn't support `Window.open`, we use iframes instead.
+  bool get requiresIFrame => !const [ie11, ie10].contains(this);
+
+  String toString() => "Runtime($name)";
+}
+
+class System {
+  static const android = const System._('android');
+  static const fuchsia = const System._('fuchsia');
+  static const linux = const System._('linux');
+  static const macos = const System._('macos');
+  static const windows = const System._('windows');
+
+  static final List<String> names = _all.keys.toList();
+
+  static final _all = new Map<String, System>.fromIterable(
+      [android, fuchsia, linux, macos, windows],
+      key: (System system) => system.name);
+
+  static System find(String name) {
+    var system = _all[name];
+    if (system != null) return system;
+
+    throw new ArgumentError('Unknown operating system "$name".');
+  }
+
+  final String name;
+
+  const System._(this.name);
+
+  /// The root directory name for build outputs on this system.
+  String get outputDirectory {
+    switch (this) {
+      case android:
+      case fuchsia:
+      case linux:
+      case windows:
+        return 'out/';
+
+      case macos:
+        return 'xcodebuild/';
+    }
+
+    throw "unreachable";
+  }
+
+  String toString() => "System($name)";
+}