Remove Dartium support from test.dart.

tools/testing/dart/test_suite.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Classes and methods for enumerating and preparing tests.
  *
  * This library includes:
  *
  * - Creating tests by listing all the Dart files in certain directories,
  *   and creating [TestCase]s for those files that meet the relevant criteria.
  * - Preparing tests, including copying files and frameworks to temporary
  *   directories, and computing the command line and arguments to be run.
  */
 import 'dart:async';
 import 'dart:io';
 
 import 'browser_test.dart';
 import 'command.dart';
 import 'compiler_configuration.dart';
 import 'configuration.dart';
-import 'drt_updater.dart';
 import 'expectation.dart';
 import 'expectation_set.dart';
 import 'html_test.dart' as html_test;
 import 'http_server.dart';
 import 'multitest.dart';
 import 'path.dart';
+import 'runtime_updater.dart';
 import 'summary_report.dart';
 import 'test_configurations.dart';
 import 'test_runner.dart';
 import 'utils.dart';
 
 RegExp multiHtmlTestGroupRegExp = new RegExp(r"\s*[^/]\s*group\('[^,']*");
 RegExp multiHtmlTestRegExp = new RegExp(r"useHtmlIndividualConfiguration()");
 // Require at least one non-space character before '//[/#]'
 RegExp multiTestRegExp = new RegExp(r"\S *"
     r"//[#/] \w+:(.*)");
@@ skipping 600 matching lines @@
     return filename.endsWith("Test.dart");
   }
 
   bool isHtmlTestFile(String filename) => filename.endsWith('_htmltest.html');
 
   List<String> additionalOptions(Path filePath) => [];
 
   Future forEachTest(
       Function onTest, Map<String, List<TestInformation>> testCache,
       [VoidFunction onDone]) async {
-    await updateDartium();
+    if (configuration.runtime == Runtime.drt && !configuration.listTests) {
+      await updateContentShell(configuration.drtPath);
+    }
+
     doTest = onTest;
     testExpectations = readExpectations();
 
     // Check if we have already found and generated the tests for this suite.
     if (!testCache.containsKey(suiteName)) {
       cachedTests = testCache[suiteName] = <TestInformation>[];
       await enqueueTests();
     } else {
       for (var info in testCache[suiteName]) {
         enqueueTestCaseFromTestInformation(info);
       }
     }
     testExpectations = null;
     cachedTests = null;
     doTest = null;
     if (onDone != null) onDone();
   }
 
   /**
-   * If Content shell/Dartium is required, and not yet updated, waits for
-   * the update then completes. Otherwise completes immediately.
-   */
-  Future updateDartium() {
-    var completer = new Completer();
-    var updater = runtimeUpdater(configuration.runtime, configuration.drtPath,
-        configuration.dartiumPath);
-    if (updater == null || updater.updated) {
-      return new Future.value(null);
-    }
-
-    assert(updater.isActive);
-    updater.onUpdated.add(() => completer.complete(null));
-
-    return completer.future;
-  }
-
-  /**
    * Reads the status files and completes with the parsed expectations.
    */
   ExpectationSet readExpectations() {
     var statusFiles = statusFilePaths.where((String statusFilePath) {
       var file = new File(dartDir.append(statusFilePath).toNativePath());
       return file.existsSync();
     }).map((statusFilePath) {
       return dartDir.append(statusFilePath).toNativePath();
     }).toList();
 
@@ skipping 276 matching lines @@
       parameters['group'] = subtestName;
     }
     return new Uri(
         scheme: 'http',
         host: configuration.localIP,
         port: serverPort,
         path: pathComponent,
         queryParameters: parameters);
   }
 
-  void _createWrapperFile(
-      String dartWrapperFilename, Path localDartLibraryFilename) {
-    File file = new File(dartWrapperFilename);
-    RandomAccessFile dartWrapper = file.openSync(mode: FileMode.WRITE);
-
-    var libraryPathComponent = _createUrlPathFromFile(localDartLibraryFilename);
-    var generatedSource = dartTestWrapper(libraryPathComponent);
-    dartWrapper.writeStringSync(generatedSource);
-    dartWrapper.closeSync();
-  }
-
   /**
    * The [StandardTestSuite] has support for tests that
    * compile a test from Dart to JavaScript, and then run the resulting
    * JavaScript.  This function creates a working directory to hold the
    * JavaScript version of the test, and copies the appropriate framework
    * files to that directory.  It creates a [BrowserTestCase], which has
    * two sequential steps to be run by the [ProcessQueue] when the test is
    * executed: a compilation step and an execution step, both with the
    * appropriate executable and arguments. The [expectations] object can be
    * either a Set<String> if the test is a regular test, or a Map<String
@@ skipping 19 matching lines @@
   }
 
   void _enqueueBrowserTestWithOptions(
       Path packageRoot,
       Path packages,
       TestInformation info,
       String testName,
       Map<String, Set<Expectation>> expectations,
       List<String> vmOptions,
       String tempDir) {
-    // TODO(Issue 14651): If we're on dartium, we need to pass [packageRoot]
-    // on to the browser (it may be test specific).
-    var filePath = info.filePath;
-    var fileName = filePath.toNativePath();
-
+    var fileName = info.filePath.toNativePath();
     var optionsFromFile = info.optionsFromFile;
     var compilationTempDir = createCompilationOutputDirectory(info.filePath);
-    var dartWrapperFilename = '$tempDir/test.dart';
-    var compiledDartWrapperFilename = '$compilationTempDir/test.js';
-    var dir = filePath.directoryPath;
-    var nameNoExt = filePath.filenameWithoutExtension;
-    var customHtmlPath = dir.append('$nameNoExt.html').toNativePath();
-    var customHtml = new File(customHtmlPath);
+    var jsWrapperFileName = '$compilationTempDir/test.js';
+    var nameNoExt = info.filePath.filenameWithoutExtension;
 
     // Use existing HTML document if available.
-    String htmlPath;
     String content;
+    var customHtml = new File(
+        info.filePath.directoryPath.append('$nameNoExt.html').toNativePath());
     if (customHtml.existsSync()) {
-      htmlPath = '$tempDir/test.html';
-      dartWrapperFilename = filePath.toNativePath();
-
-      var htmlContents = customHtml.readAsStringSync();
-      if (configuration.compiler == Compiler.none) {
-        var dartUrl = _createUrlPathFromFile(filePath);
-        var dartScript =
-            '<script type="application/dart" src="$dartUrl"></script>';
-        var jsUrl = '/packages/browser/dart.js';
-        var jsScript = '<script type="text/javascript" src="$jsUrl"></script>';
-        htmlContents =
-            htmlContents.replaceAll('%TEST_SCRIPTS%', '$dartScript\n$jsScript');
-      } else {
-        compiledDartWrapperFilename = '$tempDir/$nameNoExt.js';
-        htmlContents = htmlContents.replaceAll(
-            '%TEST_SCRIPTS%', '<script src="$nameNoExt.js"></script>');
-      }
-      new File(htmlPath).writeAsStringSync(htmlContents);
+      jsWrapperFileName = '$tempDir/$nameNoExt.js';
+      content = customHtml.readAsStringSync().replaceAll(
+          '%TEST_SCRIPTS%', '<script src="$nameNoExt.js"></script>');
     } else {
-      htmlPath = '$tempDir/test.html';
-      if (configuration.compiler != Compiler.dart2js &&
-          configuration.compiler != Compiler.dartdevc) {
-        // test.dart will import the dart test.
-        _createWrapperFile(dartWrapperFilename, filePath);
-      } else {
-        dartWrapperFilename = fileName;
-      }
-
-      // Create the HTML file for the test.
-      var scriptPath = dartWrapperFilename;
-      if (configuration.compiler != Compiler.none) {
-        scriptPath = compiledDartWrapperFilename;
-      }
-      scriptPath = _createUrlPathFromFile(new Path(scriptPath));
+      // Synthesize an HTML file for the test.
+      var scriptPath = _createUrlPathFromFile(new Path(jsWrapperFileName));
 
       if (configuration.compiler != Compiler.dartdevc) {
-        content = getHtmlContents(fileName, scriptType, scriptPath);
+        content = dart2jsHtml(fileName, scriptPath);
       } else {
         var jsDir = new Path(compilationTempDir)
             .relativeTo(TestUtils.dartDir)
             .toString();
         content = dartdevcHtml(nameNoExt, jsDir, buildDir);
       }
+    }
 
-      new File(htmlPath).writeAsStringSync(content);
-    }
+    var htmlPath = '$tempDir/test.html';
+    new File(htmlPath).writeAsStringSync(content);
 
     // Construct the command(s) that compile all the inputs needed by the
     // browser test. For running Dart in DRT, this will be noop commands.
     var commands = <Command>[];
 
     switch (configuration.compiler) {
       case Compiler.dart2js:
-        commands.add(_dart2jsCompileCommand(dartWrapperFilename,
-            compiledDartWrapperFilename, tempDir, optionsFromFile));
+        commands.add(_dart2jsCompileCommand(
+            fileName, jsWrapperFileName, tempDir, optionsFromFile));
         break;
 
       case Compiler.dartdevc:
         var toPath = new Path('$compilationTempDir/$nameNoExt.js')
             .toNativePath();
         commands.add(configuration.compilerConfiguration.createCommand(
             dartWrapperFilename, toPath,
             optionsFromFile["sharedOptions"] as List<String>));
         break;
 
-      case Compiler.none:
-        break;
-
       default:
         assert(false);
     }
 
     // Some tests require compiling multiple input scripts.
     for (var name in optionsFromFile['otherScripts'] as List<String>) {
       var namePath = new Path(name);
-      var fromPath = filePath.directoryPath.join(namePath);
+      var fromPath = info.filePath.directoryPath.join(namePath);
       var toPath = new Path('$tempDir/${namePath.filename}.js').toNativePath();
 
       switch (configuration.compiler) {
         case Compiler.dart2js:
-          commands.add(_dart2jsCompileCommand(fromPath.toNativePath(),
-              toPath, tempDir, optionsFromFile));
+          commands.add(_dart2jsCompileCommand(
+              fromPath.toNativePath(), toPath, tempDir, optionsFromFile));
           break;
 
         case Compiler.dartdevc:
           commands.add(configuration.compilerConfiguration.createCommand(
               fromPath.toNativePath(), toPath,
               optionsFromFile["sharedOptions"] as List<String>));
           break;
-
-        default:
-          assert(configuration.compiler == Compiler.none);
-      }
-
-      if (configuration.compiler == Compiler.none) {
-        // For the tests that require multiple input scripts but are not
-        // compiled, move the input scripts over with the script so they can
-        // be accessed.
-        new File(fromPath.toNativePath())
-            .copySync('$tempDir/${namePath.filename}');
       }
     }
 
     if (info.optionsFromFile['isMultiHtmlTest'] as bool) {
       // Variables for browser multi-tests.
       var subtestNames = info.optionsFromFile['subtestNames'] as List<String>;
       for (var subtestName in subtestNames) {
         _enqueueSingleBrowserTest(commands, info, '$testName/$subtestName',
             subtestName, expectations, vmOptions, htmlPath);
       }
@@ skipping 27 matching lines @@
       // Chrome may send a termination signal to a test.  The test will be
       // terminated if a machine (bot) doesn't have a GPU or if a test is
       // still running after a certain period of time.
       if (configuration.system == System.linux &&
           configuration.runtime == Runtime.drt) {
         contentShellOptions.add('--disable-gpu');
         // TODO(terry): Roll 50 need this in conjection with disable-gpu.
         contentShellOptions.add('--disable-gpu-early-init');
       }
 
-      if (configuration.compiler == Compiler.none) {
-        dartFlags.add('--ignore-unrecognized-flags');
-        if (configuration.isChecked) {
-          dartFlags.add('--enable_asserts');
-          dartFlags.add("--enable_type_checks");
-        }
-        dartFlags.addAll(vmOptions);
-      }
-
       commands.add(Command.contentShell(contentShellFilename, fullHtmlPath,
           contentShellOptions, dartFlags, environmentOverrides));
     } else {
       commands.add(Command.browserTest(fullHtmlPath, configuration,
           retry: !isNegative(info)));
     }
 
     // Create BrowserTestCase and queue it.
     var expectation = expectations[testName];
     var testCase = new BrowserTestCase('$suiteName/$testName', commands,
@@ skipping 103 matching lines @@
     args.add(inputFile);
 
     var options = optionsFromFile['sharedOptions'] as List<String>;
     if (options != null) args.addAll(options);
 
     return Command.compilation(Compiler.dart2js.name, outputFile,
         dart2JsBootstrapDependencies, compilerPath, args, environmentOverrides,
         alwaysCompile: !useSdk);
   }
 
-  String get scriptType {
-    switch (configuration.compiler) {
-      case Compiler.none:
-        return 'application/dart';
-      case Compiler.dart2js:
-      case Compiler.dart2analyzer:
-      case Compiler.dartdevc:
-        return 'text/javascript';
-      default:
-        print('Non-web runtime, so no scriptType for: '
-            '${configuration.compiler.name}');
-        exit(1);
-        return null;
-    }
-  }
-
   bool get hasRuntime => configuration.runtime != Runtime.none;
 
   String get contentShellFilename {
     if (configuration.drtPath != null) return configuration.drtPath;
 
     if (Platform.operatingSystem == 'macos') {
       final path = dartDir.append(
           '/client/tests/drt/Content Shell.app/Contents/MacOS/Content Shell');
       return path.toNativePath();
     }
@@ skipping 43 matching lines @@
       return null;
     }
   }
 
   /**
    * Special options for individual tests are currently specified in various
    * ways: with comments directly in test files, by using certain imports, or by
    * creating additional files in the test directories.
    *
    * Here is a list of options that are used by 'test.dart' today:
-   *   - Flags can be passed to the vm or dartium process that runs the test by
-   *   adding a comment to the test file:
+   *   - Flags can be passed to the vm process that runs the test by adding a
+   *   comment to the test file:
    *
    *     // VMOptions=--flag1 --flag2
    *
    *   - Flags can be passed to dart2js or vm by adding a comment
    *   to the test file:
    *
    *     // SharedOptions=--flag1 --flag2
    *
    *   - Flags can be passed to the dart script that contains the test also
    *   using comments, as follows:
@@ skipping 223 matching lines @@
       Compiler.dartkp,
       Compiler.precompiler,
       Compiler.appJit
     ];
 
     const runtimes = const [
       Runtime.none,
       Runtime.dartPrecompiled,
       Runtime.vm,
       Runtime.drt,
-      Runtime.dartium,
-      Runtime.contentShellOnAndroid,
-      Runtime.dartiumOnAndroid
+      Runtime.contentShellOnAndroid
     ];
 
     var needsVmOptions = compilers.contains(configuration.compiler) &&
         runtimes.contains(configuration.runtime);
     if (!needsVmOptions) return [[]];
     return optionsFromFile['vmOptions'] as List<List<String>>;
   }
 
   /**
    * Read options from a co19 test file.
@@ skipping 102 matching lines @@
       Directory dir = new Directory(suiteDir.append(testDir).toNativePath());
       if (dir.existsSync()) {
         enqueueDirectory(dir, group);
       }
     }
 
     return group.future;
   }
 }
 
+// TODO(rnystrom): Merge with DartcCompilationTestSuite since that class isn't
+// used for anything but this now.
 class AnalyzeLibraryTestSuite extends DartcCompilationTestSuite {
   static String libraryPath(Configuration configuration) =>
       configuration.useSdk ? '${configuration.buildDirectory}/dart-sdk' : 'sdk';
 
   AnalyzeLibraryTestSuite(Configuration configuration)
       : super(configuration, 'analyze_library', libraryPath(configuration),
             ['lib'], ['tests/lib/analyzer/analyze_library.status']);
 
   List<String> additionalOptions(Path filePath, {bool showSdkWarnings}) {
     var options = super.additionalOptions(filePath);
     options.add('--sdk-warnings');
     return options;
   }
 
   bool isTestFile(String filename) {
     // NOTE: We exclude tests and patch files for now.
     return filename.endsWith(".dart") &&
         !filename.endsWith("_test.dart") &&
         !filename.contains("_internal/js_runtime/lib");
   }
 
   bool get listRecursively => true;
 }