Revert "Use Kernel frontend from run_vm_tests."

runtime/bin/run_vm_tests.cc

 // 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.
 
 #include <stdio.h>
 
 #include "bin/dartutils.h"
 #include "bin/file.h"
-#include "bin/loader.h"
 #include "bin/platform.h"
-#include "bin/snapshot_utils.h"
 #include "platform/assert.h"
 #include "vm/benchmark_test.h"
 #include "vm/dart.h"
 #include "vm/unit_test.h"
 
 
 // TODO(iposva, asiva): This is a placeholder for the real unittest framework.
 namespace dart {
 
 // Defined in vm/os_thread_win.cc
 extern bool private_flag_windows_run_tls_destructors;
 
 // vm_snapshot_data_buffer points to a snapshot for the vm isolate if we
 // link in a snapshot otherwise it is initialized to NULL.
 extern const uint8_t* bin::vm_snapshot_data;
 extern const uint8_t* bin::vm_snapshot_instructions;
 
 // Only run tests that match the filter string. The default does not match any
 // tests.
 static const char* const kNone = "No Test or Benchmarks";
 static const char* const kList = "List all Tests and Benchmarks";
 static const char* const kAllBenchmarks = "All Benchmarks";
 static const char* run_filter = kNone;
-static const char* kernel_snapshot = NULL;
 
 static int run_matches = 0;
 
 
 void TestCase::Run() {
   OS::Print("Running test: %s\n", name());
   (*run_)();
   OS::Print("Done: %s\n", name());
 }
 
@@ skipping 25 matching lines @@
     run_matches++;
   } else if (run_filter == kList) {
     OS::Print("%s\n", this->name());
     run_matches++;
   }
 }
 
 
 static void PrintUsage() {
   OS::PrintErr(
-      "Usage: one of the following\n"
-      "  run_vm_tests --list\n"
-      "  run_vm_tests [--dfe=<snapshot file name>] --benchmarks\n"
-      "  run_vm_tests [--dfe=<snapshot file name>] [vm-flags ...] <test name>\n"
-      "  run_vm_tests [--dfe=<snapshot file name>] [vm-flags ...] <benchmark "
-      "name>\n");
+      "run_vm_tests [--list | --benchmarks | "
+      "<test name> | <benchmark name>]\n");
+  OS::PrintErr("run_vm_tests [vm-flags ...] <test name>\n");
+  OS::PrintErr("run_vm_tests [vm-flags ...] <benchmark name>\n");
 }
 
-#define CHECK_RESULT(result)                                                   \
-  if (Dart_IsError(result)) {                                                  \
-    *error = strdup(Dart_GetError(result));                                    \
-    Dart_ExitScope();                                                          \
-    Dart_ShutdownIsolate();                                                    \
-    return NULL;                                                               \
-  }
-
-
-static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
-                                          const char* main,
-                                          const char* package_root,
-                                          const char* packages_config,
-                                          Dart_IsolateFlags* flags,
-                                          void* data,
-                                          char** error) {
-  ASSERT(script_uri != NULL);
-  const bool is_service_isolate =
-      strcmp(script_uri, DART_VM_SERVICE_ISOLATE_NAME) == 0;
-  if (is_service_isolate) {
-    // We don't need service isolate for VM tests.
-    return NULL;
-  }
-  const bool is_kernel_isolate =
-      strcmp(script_uri, DART_KERNEL_ISOLATE_NAME) == 0;
-  if (!is_kernel_isolate) {
-    *error =
-        strdup("Spawning of only Kernel isolate is supported in run_vm_tests.");
-    return NULL;
-  }
-  if (kernel_snapshot == NULL) {
-    *error =
-        strdup("Kernel snapshot location has to be specified via --dfe option");
-    return NULL;
-  }
-  script_uri = kernel_snapshot;
-
-  bin::AppSnapshot* app_snapshot =
-      bin::Snapshot::TryReadAppSnapshot(script_uri);
-  if (app_snapshot == NULL) {
-    *error = strdup("Failed to read kernel service app snapshot");
-    return NULL;
-  }
-
-  const uint8_t* isolate_snapshot_data = bin::core_isolate_snapshot_data;
-  const uint8_t* isolate_snapshot_instructions =
-      bin::core_isolate_snapshot_instructions;
-
-  const uint8_t* ignore_vm_snapshot_data;
-  const uint8_t* ignore_vm_snapshot_instructions;
-  app_snapshot->SetBuffers(
-      &ignore_vm_snapshot_data, &ignore_vm_snapshot_instructions,
-      &isolate_snapshot_data, &isolate_snapshot_instructions);
-
-  bin::IsolateData* isolate_data = new bin::IsolateData(
-      script_uri, package_root, packages_config, NULL /* app_snapshot */);
-  Dart_Isolate isolate = Dart_CreateIsolate(
-      script_uri, main, isolate_snapshot_data, isolate_snapshot_instructions,
-      flags, isolate_data, error);
-  if (isolate == NULL) {
-    *error = strdup("Failed to create isolate");
-    delete isolate_data;
-    return NULL;
-  }
-
-  Dart_EnterScope();
-
-  bin::DartUtils::SetOriginalWorkingDirectory();
-  Dart_Handle result = bin::DartUtils::PrepareForScriptLoading(
-      false /* is_service_isolate */, false /* trace_loading */);
-  CHECK_RESULT(result);
-
-  Dart_ExitScope();
-  Dart_ExitIsolate();
-  bool retval = Dart_IsolateMakeRunnable(isolate);
-  if (!retval) {
-    *error = strdup("Invalid isolate state - Unable to make it runnable");
-    Dart_EnterIsolate(isolate);
-    Dart_ShutdownIsolate();
-    return NULL;
-  }
-
-  return isolate;
-}
 
 static int Main(int argc, const char** argv) {
   // Flags being passed to the Dart VM.
   int dart_argc = 0;
   const char** dart_argv = NULL;
 
   // Perform platform specific initialization.
   if (!dart::bin::Platform::Initialize()) {
     OS::PrintErr("Initialization failed\n");
   }
 
   if (argc < 2) {
     // Bad parameter count.
     PrintUsage();
     return 1;
-  }
-
-  if (argc == 2 && strcmp(argv[1], "--list") == 0) {
-    run_filter = kList;
-    // List all tests and benchmarks and exit without initializing the VM.
-    TestCaseBase::RunAll();
-    Benchmark::RunAll(argv[0]);
-    TestCaseBase::RunAllRaw();
-    fflush(stdout);
-    return 0;
-  }
-
-  int arg_pos = 1;
-  if (strstr(argv[arg_pos], "--dfe") == argv[arg_pos]) {
-    const char* delim = strstr(argv[1], "=");
-    if (delim == NULL || strlen(delim + 1) == 0) {
-      OS::PrintErr("Invalid value for the option: %s\n", argv[1]);
-      PrintUsage();
-      return 1;
+  } else if (argc == 2) {
+    if (strcmp(argv[1], "--list") == 0) {
+      run_filter = kList;
+      // List all tests and benchmarks and exit without initializing the VM.
+      TestCaseBase::RunAll();
+      Benchmark::RunAll(argv[0]);
+      TestCaseBase::RunAllRaw();
+      fflush(stdout);
+      return 0;
+    } else if (strcmp(argv[1], "--benchmarks") == 0) {
+      run_filter = kAllBenchmarks;
+    } else {
+      run_filter = argv[1];
     }
-    kernel_snapshot = strdup(delim + 1);
-    // VM needs '--use-dart-frontend' option, which we will insert in place
-    // of '--dfe' option.
-    argv[arg_pos] = strdup("--use-dart-frontend");
-    ++arg_pos;
-  }
-
-  if (arg_pos == argc - 1 && strcmp(argv[arg_pos], "--benchmarks") == 0) {
-    // "--benchmarks" is the last argument.
-    run_filter = kAllBenchmarks;
   } else {
     // Last argument is the test name, the rest are vm flags.
     run_filter = argv[argc - 1];
     // Remove the first value (executable) from the arguments and
     // exclude the last argument which is the test name.
     dart_argc = argc - 2;
     dart_argv = &argv[1];
   }
-
   bool set_vm_flags_success =
       Flags::ProcessCommandLineFlags(dart_argc, dart_argv);
   ASSERT(set_vm_flags_success);
   const char* err_msg = Dart::InitOnce(
-      dart::bin::vm_snapshot_data, dart::bin::vm_snapshot_instructions,
-      CreateIsolateAndSetup /* create */, NULL /* shutdown */,
-      NULL /* cleanup */, NULL /* thread_exit */,
-      dart::bin::DartUtils::OpenFile, dart::bin::DartUtils::ReadFile,
-      dart::bin::DartUtils::WriteFile, dart::bin::DartUtils::CloseFile,
-      NULL /* entropy_source */, NULL /* get_service_assets */);
-
+      dart::bin::vm_snapshot_data, dart::bin::vm_snapshot_instructions, NULL,
+      NULL, NULL, NULL, dart::bin::DartUtils::OpenFile,
+      dart::bin::DartUtils::ReadFile, dart::bin::DartUtils::WriteFile,
+      dart::bin::DartUtils::CloseFile, NULL, NULL);
   ASSERT(err_msg == NULL);
   // Apply the filter to all registered tests.
   TestCaseBase::RunAll();
   // Apply the filter to all registered benchmarks.
   Benchmark::RunAll(argv[0]);
 
   err_msg = Dart::Cleanup();
   ASSERT(err_msg == NULL);
 
   TestCaseBase::RunAllRaw();
   // Print a warning message if no tests or benchmarks were matched.
   if (run_matches == 0) {
     OS::PrintErr("No tests matched: %s\n", run_filter);
     return 1;
   }
   if (DynamicAssertionHelper::failed()) {
     return 255;
   }
   return 0;
 }
 
 }  // namespace dart
 
 
 int main(int argc, const char** argv) {
   dart::bin::Platform::Exit(dart::Main(argc, argv));
 }