Remove isolate argument from handle allocation: Part II

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"
@@ skipping 200 matching lines @@
     instructions_reader_ = new InstructionsReader(instructions_buffer);
   }
 }
 
 
 RawObject* SnapshotReader::ReadObject() {
   // Setup for long jump in case there is an exception while reading.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     PassiveObject& obj =
-        PassiveObject::Handle(isolate(), ReadObjectImpl(kAsInlinedObject));
+        PassiveObject::Handle(zone(), ReadObjectImpl(kAsInlinedObject));
     for (intptr_t i = 0; i < backward_references_->length(); i++) {
       if (!(*backward_references_)[i].is_deserialized()) {
         ReadObjectImpl(kAsInlinedObject);
         (*backward_references_)[i].set_state(kIsDeserialized);
       }
     }
     if (kind() != Snapshot::kFull) {
       ProcessDeferredCanonicalizations();
     }
     return obj.raw();
@@ skipping 69 matching lines @@
   return func.raw();
 }
 
 
 RawObject* SnapshotReader::ReadStaticImplicitClosure(intptr_t object_id,
                                                      intptr_t class_header) {
   ASSERT(kind_ != Snapshot::kFull);
 
   // First create a function object and associate it with the specified
   // 'object_id'.
-  Function& func = Function::Handle(isolate(), Function::null());
+  Function& func = Function::Handle(zone(), Function::null());
   Instance& obj = Instance::ZoneHandle(zone(), Instance::null());
   AddBackRef(object_id, &obj, kIsDeserialized);
 
   // Read the library/class/function information and lookup the function.
   str_ ^= ReadObjectImpl(kAsInlinedObject);
   library_ = Library::LookupLibrary(str_);
   if (library_.IsNull() || !library_.Loaded()) {
     SetReadException("Invalid Library object found in message.");
   }
   str_ ^= ReadObjectImpl(kAsInlinedObject);
@@ skipping 1495 matching lines @@
 
 
 // An object visitor which will iterate over all the script objects in the heap
 // and either count them or collect them into an array. This is used during
 // full snapshot generation of the VM isolate to write out all script
 // objects and their accompanying token streams.
 class ScriptVisitor : public ObjectVisitor {
  public:
   explicit ScriptVisitor(Isolate* isolate) :
       ObjectVisitor(isolate),
-      objHandle_(Object::Handle(isolate)),
+      objHandle_(Object::Handle(isolate->current_zone())),
       count_(0),
       scripts_(NULL) {}
 
   ScriptVisitor(Isolate* isolate, const Array* scripts) :
       ObjectVisitor(isolate),
-      objHandle_(Object::Handle(isolate)),
+      objHandle_(Object::Handle(isolate->current_zone())),
       count_(0),
       scripts_(scripts) {}
 
   void VisitObject(RawObject* obj) {
     if (obj->IsScript()) {
       if (scripts_ != NULL) {
         objHandle_ = obj;
         scripts_->SetAt(count_, objHandle_);
       }
       count_ += 1;
@@ skipping 18 matching lines @@
     : isolate_(Isolate::Current()),
       vm_isolate_snapshot_buffer_(vm_isolate_snapshot_buffer),
       isolate_snapshot_buffer_(isolate_snapshot_buffer),
       instructions_snapshot_buffer_(instructions_snapshot_buffer),
       alloc_(alloc),
       vm_isolate_snapshot_size_(0),
       isolate_snapshot_size_(0),
       instructions_snapshot_size_(0),
       forward_list_(NULL),
       instructions_writer_(NULL),
-      scripts_(Array::Handle(isolate_)),
-      symbol_table_(Array::Handle(isolate_)),
+      scripts_(Array::Handle(isolate_->current_zone())),
+      symbol_table_(Array::Handle(isolate_->current_zone())),
       snapshot_code_(snapshot_code),
       vm_isolate_is_symbolic_(vm_isolate_is_symbolic) {
   ASSERT(isolate_snapshot_buffer_ != NULL);
   ASSERT(alloc_ != NULL);
   ASSERT(isolate_ != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
   ObjectStore* object_store = isolate_->object_store();
   ASSERT(object_store != NULL);
   Heap* heap = isolate_->heap();
   ASSERT(heap != NULL);
@@ skipping 585 matching lines @@
     // 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(thread());
 
-    const Class& clazz = Class::Handle(isolate(), cls);
-    const Function& errorFunc = Function::Handle(isolate(), func);
+    const Class& clazz = Class::Handle(zone(), cls);
+    const Function& errorFunc = Function::Handle(zone(), func);
     ASSERT(!errorFunc.IsNull());
 
     // All other closures are errors.
     UnmarkAll();  // Unmark objects now as we are about to print stuff.
     char* chars = OS::SCreate(thread()->zone(),
         "Illegal argument in isolate message : (object is a closure - %s %s)",
         clazz.ToCString(), errorFunc.ToCString());
     SetWriteException(Exceptions::kArgument, chars);
   }
   return Function::null();
@@ skipping 10 matching lines @@
   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(thread());
     UnmarkAll();  // Unmark objects now as we are about to print stuff.
-    const Class& clazz = Class::Handle(isolate(), cls);
+    const Class& clazz = Class::Handle(zone(), cls);
     char* chars = OS::SCreate(thread()->zone(),
         "Illegal argument in isolate message"
         " : (object extends NativeWrapper - %s)",
         clazz.ToCString());
     SetWriteException(Exceptions::kArgument, chars);
   }
 }
 
 
 void SnapshotWriter::SetWriteException(Exceptions::ExceptionType type,
@@ skipping 206 matching lines @@
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart