- Ensure that HandleScope is initialized with a thread. (Remove

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 9009 matching lines @@
 };
 
 
 typedef UnorderedHashSet<LibraryUrlTraits> LibraryLoadErrorSet;
 
 
 RawInstance* Library::TransitiveLoadError() const {
   if (LoadError() != Instance::null()) {
     return LoadError();
   }
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
   ObjectStore* object_store = isolate->object_store();
   LibraryLoadErrorSet set(object_store->library_load_error_table());
   bool present = false;
   if (set.GetOrNull(*this, &present) != Object::null()) {
     object_store->set_library_load_error_table(set.Release());
     return Instance::null();
   }
   // Ensure we don't repeatedly visit the same library again.
   set.Insert(*this);
   object_store->set_library_load_error_table(set.Release());
   intptr_t num_imp = num_imports();
   Library& lib = Library::Handle(isolate);
   Instance& error = Instance::Handle(isolate);
   for (intptr_t i = 0; i < num_imp; i++) {
-    HANDLESCOPE(isolate);
+    HANDLESCOPE(thread);
     lib = ImportLibraryAt(i);
     error = lib.TransitiveLoadError();
     if (!error.IsNull()) {
       break;
     }
   }
   return error.raw();
 }
 
 
@@ skipping 1249 matching lines @@
     const Array& imports = Array::Handle(this->imports());
     Namespace& import = Namespace::Handle();
     import ^= imports.At(index);
     return import.library();
   }
   return Library::null();
 }
 
 
 RawInstance* LibraryPrefix::LoadError() const {
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
   ObjectStore* object_store = isolate->object_store();
   GrowableObjectArray& libs =
       GrowableObjectArray::Handle(isolate, object_store->libraries());
   ASSERT(!libs.IsNull());
   LibraryLoadErrorSet set(HashTables::New<LibraryLoadErrorSet>(libs.Length()));
   object_store->set_library_load_error_table(set.Release());
   Library& lib = Library::Handle(isolate);
   Instance& error = Instance::Handle(isolate);
   for (int32_t i = 0; i < num_imports(); i++) {
     lib = GetLibrary(i);
     ASSERT(!lib.IsNull());
-    HANDLESCOPE(isolate);
+    HANDLESCOPE(thread);
     error = lib.TransitiveLoadError();
     if (!error.IsNull()) {
       break;
     }
   }
   object_store->set_library_load_error_table(Object::empty_array());
   return error.raw();
 }
 
 
@@ skipping 3843 matching lines @@
 
 
 void UnhandledException::set_stacktrace(const Instance& stacktrace) const {
   StorePointer(&raw_ptr()->stacktrace_, stacktrace.raw());
 }
 
 
 const char* UnhandledException::ToErrorCString() const {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
-  HANDLESCOPE(isolate);
+  HANDLESCOPE(thread);
   Object& strtmp = Object::Handle();
   const char* exc_str;
   if (exception() == isolate->object_store()->out_of_memory()) {
     exc_str = "Out of Memory";
   } else if (exception() == isolate->object_store()->stack_overflow()) {
     exc_str = "Stack Overflow";
   } else {
     const Instance& exc = Instance::Handle(exception());
     strtmp = DartLibraryCalls::ToString(exc);
     if (!strtmp.IsError()) {
@@ skipping 7288 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart