Remove isolate parameter when allocating handles

runtime/vm/bootstrap.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/bootstrap.h"
 
 #include "include/dart_api.h"
 
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
@@ skipping 143 matching lines @@
     } else {
       // Compilation errors are not Dart instances, so just mark the library
       // as having failed to load without providing an error instance.
       library.SetLoadError(Object::null_instance());
     }
   }
   return error.raw();
 }
 
 
-static Dart_Handle LoadPartSource(Isolate* isolate,
+static Dart_Handle LoadPartSource(Thread* thread,
                                   const Library& lib,
                                   const String& uri) {
+  Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
   const String& part_source = String::Handle(
-      isolate, GetLibrarySource(lib, uri, false));
-  const String& lib_uri = String::Handle(isolate, lib.url());
+      zone, GetLibrarySource(lib, uri, false));
+  const String& lib_uri = String::Handle(zone, lib.url());
   if (part_source.IsNull()) {
     return Api::NewError("Unable to read part file '%s' of library '%s'",
                          uri.ToCString(), lib_uri.ToCString());
   }
 
   // Prepend the library URI to form a unique script URI for the part.
-  const Array& strings = Array::Handle(isolate, Array::New(3));
+  const Array& strings = Array::Handle(zone, Array::New(3));
   strings.SetAt(0, lib_uri);
   strings.SetAt(1, Symbols::Slash());
   strings.SetAt(2, uri);
-  const String& part_uri = String::Handle(isolate, String::ConcatAll(strings));
+  const String& part_uri = String::Handle(zone, String::ConcatAll(strings));
 
   // Create a script object and compile the part.
   const Script& part_script = Script::Handle(
-      isolate, Script::New(part_uri, part_source, RawScript::kSourceTag));
-  const Error& error = Error::Handle(isolate, Compile(lib, part_script));
+      zone, Script::New(part_uri, part_source, RawScript::kSourceTag));
+  const Error& error = Error::Handle(zone, Compile(lib, part_script));
   return Api::NewHandle(isolate, error.raw());
 }
 
 
 static Dart_Handle BootstrapLibraryTagHandler(Dart_LibraryTag tag,
                                               Dart_Handle library,
                                               Dart_Handle uri) {
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
   if (!Dart_IsLibrary(library)) {
     return Api::NewError("not a library");
   }
   if (!Dart_IsString(uri)) {
     return Api::NewError("uri is not a string");
   }
   if (tag == Dart_kCanonicalizeUrl) {
     // In the bootstrap loader we do not try and do any canonicalization.
     return uri;
   }
-  const String& uri_str = Api::UnwrapStringHandle(isolate, uri);
+  const String& uri_str = Api::UnwrapStringHandle(zone, uri);
   ASSERT(!uri_str.IsNull());
   if (tag == Dart_kImportTag) {
     // We expect the core bootstrap libraries to only import other
     // core bootstrap libraries.
     // We have precreated all the bootstrap library objects hence
     // we do not expect to be called back with the tag set to kImportTag.
     // The bootstrap process explicitly loads all the libraries one by one.
     return Api::NewError("Invalid import of '%s' in a bootstrap library",
                          uri_str.ToCString());
   }
   ASSERT(tag == Dart_kSourceTag);
-  const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
+  const Library& lib = Api::UnwrapLibraryHandle(zone, library);
   ASSERT(!lib.IsNull());
-  return LoadPartSource(isolate, lib, uri_str);
+  return LoadPartSource(thread, lib, uri_str);
 }
 
 
-static RawError* LoadPatchFiles(Isolate* isolate,
+static RawError* LoadPatchFiles(Zone* zone,
                                 const Library& lib,
                                 const String& patch_uri,
                                 const char** patch_files) {
-  String& patch_file_uri = String::Handle(isolate);
-  String& source = String::Handle(isolate);
-  Script& script = Script::Handle(isolate);
-  Error& error = Error::Handle(isolate);
-  const Array& strings = Array::Handle(isolate, Array::New(3));
+  String& patch_file_uri = String::Handle(zone);
+  String& source = String::Handle(zone);
+  Script& script = Script::Handle(zone);
+  Error& error = Error::Handle(zone);
+  const Array& strings = Array::Handle(zone, Array::New(3));
   strings.SetAt(0, patch_uri);
   strings.SetAt(1, Symbols::Slash());
   for (intptr_t j = 0; patch_files[j] != NULL; j += 2) {
     patch_file_uri = String::New(patch_files[j]);
     source = GetLibrarySource(lib, patch_file_uri, true);
     if (source.IsNull()) {
       const String& message = String::Handle(
           String::NewFormatted("Unable to find dart patch source for %s",
                                patch_file_uri.ToCString()));
       return ApiError::New(message);
     }
     // Prepend the patch library URI to form a unique script URI for the patch.
     strings.SetAt(2, patch_file_uri);
     patch_file_uri = String::ConcatAll(strings);
     script = Script::New(patch_file_uri, source, RawScript::kPatchTag);
     error = lib.Patch(script);
     if (!error.IsNull()) {
       return error.raw();
     }
   }
   return Error::null();
 }
 
 
 RawError* Bootstrap::LoadandCompileScripts() {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
-  String& uri = String::Handle(isolate);
-  String& patch_uri = String::Handle(isolate);
-  String& source = String::Handle(isolate);
-  Script& script = Script::Handle(isolate);
-  Library& lib = Library::Handle(isolate);
-  Error& error = Error::Handle(isolate);
+  Zone* zone = thread->zone();
+  String& uri = String::Handle(zone);
+  String& patch_uri = String::Handle(zone);
+  String& source = String::Handle(zone);
+  Script& script = Script::Handle(zone);
+  Library& lib = Library::Handle(zone);
+  Error& error = Error::Handle(zone);
   Dart_LibraryTagHandler saved_tag_handler = isolate->library_tag_handler();
 
   // Set the library tag handler for the isolate to the bootstrap
   // library tag handler so that we can load all the bootstrap libraries.
   isolate->set_library_tag_handler(BootstrapLibraryTagHandler);
 
   HANDLESCOPE(thread);
 
   // Create library objects for all the bootstrap libraries.
   for (intptr_t i = 0;
@@ skipping 26 matching lines @@
       break;
     }
     script = Script::New(uri, source, RawScript::kLibraryTag);
     error = Compile(lib, script);
     if (!error.IsNull()) {
       break;
     }
     // If a patch exists, load and patch the script.
     if (bootstrap_libraries[i].patch_paths_ != NULL) {
       patch_uri = Symbols::New(bootstrap_libraries[i].patch_uri_);
-      error = LoadPatchFiles(isolate,
+      error = LoadPatchFiles(zone,
                              lib,
                              patch_uri,
                              bootstrap_libraries[i].patch_paths_);
       if (!error.IsNull()) {
         break;
       }
     }
   }
   if (error.IsNull()) {
     SetupNativeResolver();
     ClassFinalizer::ProcessPendingClasses();
 
-    Class& cls = Class::Handle(isolate);
+    Class& cls = Class::Handle(zone);
     // Eagerly compile the function implementation class as it is the super
     // class of signature classes. This allows us to just finalize signature
     // classes without going through the hoops of trying to compile them.
     const Type& type =
-        Type::Handle(isolate, isolate->object_store()->function_impl_type());
+        Type::Handle(zone, isolate->object_store()->function_impl_type());
     cls = type.type_class();
     Compiler::CompileClass(cls);
   }
 
   // Restore the library tag handler for the isolate.
   isolate->set_library_tag_handler(saved_tag_handler);
 
   return error.raw();
 }
 
 }  // namespace dart