- reorganize DartUtils::PrepareForScriptLoading so that it does not have the wait for service load …

runtime/vm/unit_test.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 "vm/unit_test.h"
 
 #include <stdio.h>
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
+#include "bin/isolate_data.h"
 
 #include "platform/globals.h"
+
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/disassembler.h"
 #include "vm/parser.h"
 #include "vm/symbols.h"
 #include "vm/thread.h"
 #include "vm/virtual_memory.h"
 
@@ skipping 19 matching lines @@
 
 
 void TestCaseBase::RunAll() {
   TestCaseBase* test = first_;
   while (test != NULL) {
     test->RunTest();
     test = test->next_;
   }
 }
 
+
+Dart_Isolate TestCase::CreateIsolate(const uint8_t* buffer, const char* name) {
+  bin::IsolateData* isolate_data = new bin::IsolateData(name, NULL, NULL);
+  char* err;
+  Dart_Isolate isolate = Dart_CreateIsolate(
+      name, NULL, buffer, NULL, isolate_data, &err);
+  if (isolate == NULL) {
+    OS::Print("Creation of isolate failed '%s'\n", err);
+    free(err);
+  }
+  EXPECT(isolate != NULL);
+  return isolate;
+}
+
+
 static const char* kPackageScheme = "package:";
 
 static bool IsPackageSchemeURL(const char* url_name) {
   static const intptr_t kPackageSchemeLen = strlen(kPackageScheme);
   return (strncmp(url_name, kPackageScheme, kPackageSchemeLen) == 0);
 }
 
-static Dart_Handle ResolvePackageUri(Dart_Handle builtin_lib,
-                                     const char* uri_chars) {
+static Dart_Handle ResolvePackageUri(const char* uri_chars) {
   const int kNumArgs = 1;
   Dart_Handle dart_args[kNumArgs];
   dart_args[0] = DartUtils::NewString(uri_chars);
-  return Dart_Invoke(builtin_lib,
+  return Dart_Invoke(DartUtils::BuiltinLib(),
                      DartUtils::NewString("_filePathFromUri"),
                      kNumArgs,
                      dart_args);
 }
 
 static Dart_Handle LibraryTagHandler(Dart_LibraryTag tag,
                                      Dart_Handle library,
                                      Dart_Handle url) {
   if (!Dart_IsLibrary(library)) {
     return Dart_NewApiError("not a library");
   }
   if (!Dart_IsString(url)) {
     return Dart_NewApiError("url is not a string");
   }
   const char* url_chars = NULL;
   Dart_Handle result = Dart_StringToCString(url, &url_chars);
   if (Dart_IsError(result)) {
     return Dart_NewApiError("accessing url characters failed");
   }
   Dart_Handle library_url = Dart_LibraryUrl(library);
   const char* library_url_string = NULL;
   result = Dart_StringToCString(library_url, &library_url_string);
   if (Dart_IsError(result)) {
     return result;
   }
 
-  Dart_Handle builtin_lib =
-      Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
-  DART_CHECK_VALID(builtin_lib);
-
   bool is_dart_scheme_url = DartUtils::IsDartSchemeURL(url_chars);
   bool is_io_library = DartUtils::IsDartIOLibURL(library_url_string);
   if (tag == Dart_kCanonicalizeUrl) {
     // If this is a Dart Scheme URL then it is not modified as it will be
     // handled by the VM internally.
     if (is_dart_scheme_url || is_io_library) {
       return url;
     }
 
     Dart_Handle library_url = Dart_LibraryUrl(library);
     if (Dart_IsError(library_url)) {
       return library_url;
     }
-    return DartUtils::ResolveUri(library_url, url, builtin_lib);
+    return DartUtils::ResolveUri(library_url, url);
   }
   if (is_dart_scheme_url) {
     ASSERT(tag == Dart_kImportTag);
     // Handle imports of other built-in libraries present in the SDK.
     if (DartUtils::IsDartIOLibURL(url_chars)) {
       return Builtin::LoadAndCheckLibrary(Builtin::kIOLibrary);
     } else if (DartUtils::IsDartBuiltinLibURL(url_chars)) {
-      return builtin_lib;
+      return Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
     } else {
       return DartUtils::NewError("Do not know how to load '%s'", url_chars);
     }
   }
   if (is_io_library) {
     ASSERT(tag == Dart_kSourceTag);
     return Dart_LoadSource(library,
                            url,
                            Builtin::PartSource(Builtin::kIOLibrary,
                                                url_chars),
                            0, 0);
   }
   if (IsPackageSchemeURL(url_chars)) {
-    Dart_Handle resolved_uri = ResolvePackageUri(builtin_lib, url_chars);
+    Dart_Handle resolved_uri = ResolvePackageUri(url_chars);
     DART_CHECK_VALID(resolved_uri);
     url_chars = NULL;
     Dart_Handle result = Dart_StringToCString(resolved_uri, &url_chars);
     if (Dart_IsError(result)) {
       return Dart_NewApiError("accessing url characters failed");
     }
   }
   // Do sync loading since unit_test doesn't support async.
   Dart_Handle source = DartUtils::ReadStringFromFile(url_chars);
   EXPECT_VALID(source);
@@ skipping 159 matching lines @@
   }
   // Copy the remainder of in to out.
   while (*in != '\0') {
     *out++ = *in++;
   }
   *out = '\0';
 }
 
 
 }  // namespace dart