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

runtime/vm/snapshot.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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/heap.h"
 #include "vm/lockers.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 #include "vm/verified_memory.h"
 #include "vm/version.h"
 
 // We currently only expect the Dart mutator to read snapshots.
 #define ASSERT_NO_SAFEPOINT_SCOPE()                            \
     isolate()->AssertCurrentThreadIsMutator();                 \
-    ASSERT(Thread::Current()->no_safepoint_scope_depth() != 0)
+    ASSERT(thread()->no_safepoint_scope_depth() != 0)
 
 namespace dart {
 
 static const int kNumVmIsolateSnapshotReferences = 32 * KB;
 static const int kNumInitialReferencesInFullSnapshot = 160 * KB;
 static const int kNumInitialReferences = 64;
 
 
 static bool IsSingletonClassId(intptr_t class_id) {
   // Check if this is a singleton object class which is shared by all isolates.
@@ skipping 129 matching lines @@
 intptr_t BaseReader::ReadSmiValue() {
   return Smi::Value(ReadAsSmi());
 }
 
 
 SnapshotReader::SnapshotReader(
     const uint8_t* buffer,
     intptr_t size,
     Snapshot::Kind kind,
     ZoneGrowableArray<BackRefNode>* backward_refs,
-    Isolate* isolate,
-    Zone* zone)
+    Thread* thread)
     : BaseReader(buffer, size),
       kind_(kind),
       snapshot_code_(false),
-      isolate_(isolate),
-      zone_(zone),
-      heap_(isolate->heap()),
-      old_space_(isolate->heap()->old_space()),
-      cls_(Class::Handle(isolate)),
-      obj_(Object::Handle(isolate)),
-      pobj_(PassiveObject::Handle(isolate)),
-      array_(Array::Handle(isolate)),
-      field_(Field::Handle(isolate)),
-      str_(String::Handle(isolate)),
-      library_(Library::Handle(isolate)),
-      type_(AbstractType::Handle(isolate)),
-      type_arguments_(TypeArguments::Handle(isolate)),
-      tokens_(Array::Handle(isolate)),
-      stream_(TokenStream::Handle(isolate)),
-      data_(ExternalTypedData::Handle(isolate)),
-      typed_data_(TypedData::Handle(isolate)),
-      error_(UnhandledException::Handle(isolate)),
+      thread_(thread),
+      zone_(thread->zone()),
+      heap_(isolate()->heap()),
+      old_space_(thread_->isolate()->heap()->old_space()),
+      cls_(Class::Handle(zone_)),
+      obj_(Object::Handle(zone_)),
+      pobj_(PassiveObject::Handle(zone_)),
+      array_(Array::Handle(zone_)),
+      field_(Field::Handle(zone_)),
+      str_(String::Handle(zone_)),
+      library_(Library::Handle(zone_)),
+      type_(AbstractType::Handle(zone_)),
+      type_arguments_(TypeArguments::Handle(zone_)),
+      tokens_(Array::Handle(zone_)),
+      stream_(TokenStream::Handle(zone_)),
+      data_(ExternalTypedData::Handle(zone_)),
+      typed_data_(TypedData::Handle(zone_)),
+      error_(UnhandledException::Handle(zone_)),
       max_vm_isolate_object_id_(
           (kind == Snapshot::kFull) ?
               Object::vm_isolate_snapshot_object_table().Length() : 0),
       backward_references_(backward_refs) {
 }
 
 
 RawObject* SnapshotReader::ReadObject() {
   // Setup for long jump in case there is an exception while reading.
   LongJumpScope jump;
@@ skipping 88 matching lines @@
 }
 
 
 intptr_t SnapshotReader::NextAvailableObjectId() const {
   return backward_references_->length() +
       kMaxPredefinedObjectIds + max_vm_isolate_object_id_;
 }
 
 
 void SnapshotReader::SetReadException(const char* msg) {
-  Thread* thread = Thread::Current();
-  Zone* zone = thread->zone();
-  const String& error_str = String::Handle(zone, String::New(msg));
-  const Array& args = Array::Handle(zone, Array::New(1));
+  const String& error_str = String::Handle(zone(), String::New(msg));
+  const Array& args = Array::Handle(zone(), Array::New(1));
   args.SetAt(0, error_str);
-  Object& result = Object::Handle(zone);
-  const Library& library = Library::Handle(zone, Library::CoreLibrary());
+  Object& result = Object::Handle(zone());
+  const Library& library = Library::Handle(zone(), Library::CoreLibrary());
   result = DartLibraryCalls::InstanceCreate(library,
                                             Symbols::ArgumentError(),
                                             Symbols::Dot(),
                                             args);
-  const Stacktrace& stacktrace = Stacktrace::Handle(zone);
+  const Stacktrace& stacktrace = Stacktrace::Handle(zone());
   const UnhandledException& error = UnhandledException::Handle(
-      zone, UnhandledException::New(Instance::Cast(result), stacktrace));
-  thread->long_jump_base()->Jump(1, error);
+      zone(), UnhandledException::New(Instance::Cast(result), stacktrace));
+  thread()->long_jump_base()->Jump(1, error);
 }
 
 
 RawObject* SnapshotReader::VmIsolateSnapshotObject(intptr_t index) const {
   return Object::vm_isolate_snapshot_object_table().At(index);
 }
 
 
 bool SnapshotReader::is_vm_isolate() const {
-  return isolate_ == Dart::vm_isolate();
+  return isolate() == Dart::vm_isolate();
 }
 
 
 RawObject* SnapshotReader::ReadObjectImpl(bool as_reference,
                                           intptr_t patch_object_id,
                                           intptr_t patch_offset) {
   int64_t header_value = Read<int64_t>();
   if ((header_value & kSmiTagMask) == kSmiTag) {
     return NewInteger(header_value);
   }
@@ skipping 750 matching lines @@
   uword address =
       old_space()->TryAllocateSmiInitializedLocked(size,
                                                    PageSpace::kForceGrowth);
   if (address == 0) {
     // Use the preallocated out of memory exception to avoid calling
     // into dart code or allocating any code.
     // We do a longjmp at this point to unwind out of the entire
     // read part and return the error object back.
     const UnhandledException& error = UnhandledException::Handle(
         object_store()->preallocated_unhandled_exception());
-    Thread::Current()->long_jump_base()->Jump(1, error);
+    thread()->long_jump_base()->Jump(1, error);
   }
   VerifiedMemory::Accept(address, size);
 
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
   uword tags = 0;
   ASSERT(class_id != kIllegalCid);
   tags = RawObject::ClassIdTag::update(class_id, tags);
   tags = RawObject::SizeTag::update(size, tags);
   tags = RawObject::VMHeapObjectTag::update(is_vm_isolate(), tags);
   raw_obj->ptr()->tags_ = tags;
@@ skipping 156 matching lines @@
     *PassiveObjectHandle() = ReadObjectImpl(as_reference,
                                             object_id,
                                             (i + offset));
     result.SetAt(i, *PassiveObjectHandle());
   }
 }
 
 
 VmIsolateSnapshotReader::VmIsolateSnapshotReader(const uint8_t* buffer,
                                                  intptr_t size,
-                                                 Zone* zone)
+                                                 Thread* thread)
     : SnapshotReader(buffer,
                      size,
                      Snapshot::kFull,
                      new ZoneGrowableArray<BackRefNode>(
                          kNumVmIsolateSnapshotReferences),
-                     Dart::vm_isolate(),
-                     zone) {
+                     thread) {
 }
 
 
 VmIsolateSnapshotReader::~VmIsolateSnapshotReader() {
   intptr_t len = GetBackwardReferenceTable()->length();
   Object::InitVmIsolateSnapshotObjectTable(len);
   ZoneGrowableArray<BackRefNode>* backrefs = GetBackwardReferenceTable();
   for (intptr_t i = 0; i < len; i++) {
     Object::vm_isolate_snapshot_object_table().SetAt(
         i, *(backrefs->At(i).reference()));
@@ skipping 37 matching lines @@
     isolate->ValidateClassTable();
 #endif
 
     return ApiError::null();
   }
 }
 
 
 IsolateSnapshotReader::IsolateSnapshotReader(const uint8_t* buffer,
                                              intptr_t size,
-                                             Isolate* isolate,
-                                             Zone* zone)
+                                             Thread* thread)
     : SnapshotReader(buffer,
                      size,
                      Snapshot::kFull,
                      new ZoneGrowableArray<BackRefNode>(
                          kNumInitialReferencesInFullSnapshot),
-                     isolate,
-                     zone) {
+                     thread) {
 }
 
 
 IsolateSnapshotReader::~IsolateSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 ScriptSnapshotReader::ScriptSnapshotReader(const uint8_t* buffer,
                                            intptr_t size,
-                                           Isolate* isolate,
-                                           Zone* zone)
+                                           Thread* thread)
     : SnapshotReader(buffer,
                      size,
                      Snapshot::kScript,
                      new ZoneGrowableArray<BackRefNode>(kNumInitialReferences),
-                     isolate,
-                     zone) {
+                     thread) {
 }
 
 
 ScriptSnapshotReader::~ScriptSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 MessageSnapshotReader::MessageSnapshotReader(const uint8_t* buffer,
                                              intptr_t size,
-                                             Isolate* isolate,
-                                             Zone* zone)
+                                             Thread* thread)
     : SnapshotReader(buffer,
                      size,
                      Snapshot::kMessage,
                      new ZoneGrowableArray<BackRefNode>(kNumInitialReferences),
-                     isolate,
-                     zone) {
+                     thread) {
 }
 
 
 MessageSnapshotReader::~MessageSnapshotReader() {
   ResetBackwardReferenceTable();
 }
 
 
 SnapshotWriter::SnapshotWriter(Snapshot::Kind kind,
                                uint8_t** buffer,
                                ReAlloc alloc,
                                intptr_t initial_size,
                                ForwardList* forward_list,
                                bool can_send_any_object,
                                bool snapshot_code)
     : BaseWriter(buffer, alloc, initial_size),
       kind_(kind),
-      isolate_(Isolate::Current()),
-      object_store_(isolate_->object_store()),
-      class_table_(isolate_->class_table()),
+      thread_(Thread::Current()),
+      object_store_(thread_->isolate()->object_store()),
+      class_table_(thread_->isolate()->class_table()),
       forward_list_(forward_list),
       exception_type_(Exceptions::kNone),
       exception_msg_(NULL),
       unmarked_objects_(false),
       can_send_any_object_(can_send_any_object),
       snapshot_code_(snapshot_code) {
   ASSERT(forward_list_ != NULL);
 }
 
 
@@ skipping 792 matching lines @@
     // isolate message.
     RawFunction* func = Closure::GetFunction(obj);
     // We only allow closure of top level methods or static functions in a
     // class to be sent in isolate messages.
     if (can_send_any_object() &&
         Function::IsImplicitStaticClosureFunction(func)) {
       return func;
     }
     // Not a closure of a top level method or static function, throw an
     // exception as we do not allow these objects to be serialized.
-    HANDLESCOPE(isolate());
+    HANDLESCOPE(thread());
 
     const Class& clazz = Class::Handle(isolate(), cls);
     const Function& errorFunc = Function::Handle(isolate(), func);
     ASSERT(!errorFunc.IsNull());
 
     // All other closures are errors.
     const char* format = "Illegal argument in isolate message"
         " : (object is a closure - %s %s)";
     UnmarkAll();  // Unmark objects now as we are about to print stuff.
     intptr_t len = OS::SNPrint(NULL, 0, format,
                                clazz.ToCString(), errorFunc.ToCString()) + 1;
-    char* chars = Thread::Current()->zone()->Alloc<char>(len);
+    char* chars = thread()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, clazz.ToCString(), errorFunc.ToCString());
     SetWriteException(Exceptions::kArgument, chars);
   }
   return Function::null();
 }
 
 
 RawClass* SnapshotWriter::GetFunctionOwner(RawFunction* func) {
   RawObject* owner = func->ptr()->owner_;
   uword tags = GetObjectTags(owner);
   intptr_t class_id = RawObject::ClassIdTag::decode(tags);
   if (class_id == kClassCid) {
     return reinterpret_cast<RawClass*>(owner);
   }
   ASSERT(class_id == kPatchClassCid);
   return reinterpret_cast<RawPatchClass*>(owner)->ptr()->patched_class_;
 }
 
 
 void SnapshotWriter::CheckForNativeFields(RawClass* cls) {
   if (cls->ptr()->num_native_fields_ != 0) {
     // We do not allow objects with native fields in an isolate message.
-    HANDLESCOPE(isolate());
+    HANDLESCOPE(thread());
     const char* format = "Illegal argument in isolate message"
                          " : (object extends NativeWrapper - %s)";
     UnmarkAll();  // Unmark objects now as we are about to print stuff.
     const Class& clazz = Class::Handle(isolate(), cls);
     intptr_t len = OS::SNPrint(NULL, 0, format, clazz.ToCString()) + 1;
-    char* chars = Thread::Current()->zone()->Alloc<char>(len);
+    char* chars = thread()->zone()->Alloc<char>(len);
     OS::SNPrint(chars, len, format, clazz.ToCString());
     SetWriteException(Exceptions::kArgument, chars);
   }
 }
 
 
 void SnapshotWriter::SetWriteException(Exceptions::ExceptionType type,
                                        const char* msg) {
   set_exception_type(type);
   set_exception_msg(msg);
@@ skipping 219 matching lines @@
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart