Keep zone cached in SnapshotReader to allow removing ZoneHandle(Isolate*) interface.

runtime/vm/raw_object_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/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
@@ skipping 10 matching lines @@
   ((kind == Snapshot::kFull) ?                                                 \
   reader->New##type(len) : type::New(len, HEAP_SPACE(kind)))
 
 
 RawClass* Class::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
-  Class& cls = Class::ZoneHandle(reader->isolate(), Class::null());
+  Class& cls = Class::ZoneHandle(reader->zone(), Class::null());
   if ((kind == Snapshot::kFull) ||
       (kind == Snapshot::kScript && !RawObject::IsCreatedFromSnapshot(tags))) {
     // Read in the base information.
     int32_t class_id = reader->Read<int32_t>();
 
     // Allocate class object of specified kind.
     if (kind == Snapshot::kFull) {
       cls = reader->NewClass(class_id);
     } else {
       if (class_id < kNumPredefinedCids) {
@@ skipping 90 matching lines @@
 
 
 RawUnresolvedClass* UnresolvedClass::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate unresolved class object.
   UnresolvedClass& unresolved_class = UnresolvedClass::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(UnresolvedClass));
+      reader->zone(), NEW_OBJECT(UnresolvedClass));
   reader->AddBackRef(object_id, &unresolved_class, kIsDeserialized);
 
   // Set the object tags.
   unresolved_class.set_tags(tags);
 
   // Set all non object fields.
   unresolved_class.set_token_pos(reader->Read<int32_t>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
@@ skipping 46 matching lines @@
 }
 
 
 RawType* Type::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate type object.
-  Type& type = Type::ZoneHandle(reader->isolate(), NEW_OBJECT(Type));
+  Type& type = Type::ZoneHandle(reader->zone(), NEW_OBJECT(Type));
   reader->AddBackRef(object_id, &type, kIsDeserialized);
 
   // Set all non object fields.
   type.set_token_pos(reader->Read<int32_t>());
   type.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (type.raw()->to() - type.raw()->from());
@@ skipping 54 matching lines @@
 
 
 RawTypeRef* TypeRef::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate type ref object.
   TypeRef& type_ref = TypeRef::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(TypeRef));
+      reader->zone(), NEW_OBJECT(TypeRef));
   reader->AddBackRef(object_id, &type_ref, kIsDeserialized);
 
   // Set the object tags.
   type_ref.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (type_ref.raw()->to() - type_ref.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
@@ skipping 25 matching lines @@
 
 
 RawTypeParameter* TypeParameter::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate type parameter object.
   TypeParameter& type_parameter = TypeParameter::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(TypeParameter));
+      reader->zone(), NEW_OBJECT(TypeParameter));
   reader->AddBackRef(object_id, &type_parameter, kIsDeserialized);
 
   // Set the object tags.
   type_parameter.set_tags(tags);
 
   // Set all non object fields.
   type_parameter.set_index(reader->Read<int32_t>());
   type_parameter.set_token_pos(reader->Read<int32_t>());
   type_parameter.set_type_state(reader->Read<int8_t>());
 
@@ skipping 39 matching lines @@
 
 
 RawBoundedType* BoundedType::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate bounded type object.
   BoundedType& bounded_type = BoundedType::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(BoundedType));
+      reader->zone(), NEW_OBJECT(BoundedType));
   reader->AddBackRef(object_id, &bounded_type, kIsDeserialized);
 
   // Set the object tags.
   bounded_type.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (bounded_type.raw()->to() -
                        bounded_type.raw()->from());
@@ skipping 44 matching lines @@
 RawTypeArguments* TypeArguments::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
 
   TypeArguments& type_arguments = TypeArguments::ZoneHandle(
-      reader->isolate(), NEW_OBJECT_WITH_LEN_SPACE(TypeArguments, len, kind));
+      reader->zone(), NEW_OBJECT_WITH_LEN_SPACE(TypeArguments, len, kind));
   reader->AddBackRef(object_id, &type_arguments, kIsDeserialized);
 
   // Set the instantiations field, which is only read from a full snapshot.
   if (kind == Snapshot::kFull) {
     *(reader->ArrayHandle()) ^= reader->ReadObjectImpl();
     type_arguments.set_instantiations(*(reader->ArrayHandle()));
   } else {
     type_arguments.set_instantiations(Object::zero_array());
   }
 
@@ skipping 58 matching lines @@
 RawPatchClass* PatchClass::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Allocate function object.
-  PatchClass& cls = PatchClass::ZoneHandle(reader->isolate(),
+  PatchClass& cls = PatchClass::ZoneHandle(reader->zone(),
                                             NEW_OBJECT(PatchClass));
   reader->AddBackRef(object_id, &cls, kIsDeserialized);
 
   // Set the object tags.
   cls.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (cls.raw()->to() - cls.raw()->from());
@@ skipping 31 matching lines @@
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Allocate closure data object.
   ClosureData& data = ClosureData::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(ClosureData));
+      reader->zone(), NEW_OBJECT(ClosureData));
   reader->AddBackRef(object_id, &data, kIsDeserialized);
 
   // Set the object tags.
   data.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (data.raw()->to() - data.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
@@ skipping 39 matching lines @@
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Allocate redirection data object.
   RedirectionData& data = RedirectionData::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(RedirectionData));
+      reader->zone(), NEW_OBJECT(RedirectionData));
   reader->AddBackRef(object_id, &data, kIsDeserialized);
 
   // Set the object tags.
   data.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (data.raw()->to() - data.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
@@ skipping 31 matching lines @@
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Allocate function object.
   Function& func = Function::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(Function));
+      reader->zone(), NEW_OBJECT(Function));
   reader->AddBackRef(object_id, &func, kIsDeserialized);
 
   // Set the object tags.
   func.set_tags(tags);
 
   // Set all the non object fields.
   func.set_token_pos(reader->Read<int32_t>());
   func.set_end_token_pos(reader->Read<int32_t>());
   func.set_usage_counter(reader->Read<int32_t>());
   func.set_num_fixed_parameters(reader->Read<int16_t>());
@@ skipping 57 matching lines @@
 RawField* Field::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Allocate field object.
-  Field& field = Field::ZoneHandle(reader->isolate(), NEW_OBJECT(Field));
+  Field& field = Field::ZoneHandle(reader->zone(), NEW_OBJECT(Field));
   reader->AddBackRef(object_id, &field, kIsDeserialized);
 
   // Set the object tags.
   field.set_tags(tags);
 
   // Set all non object fields.
   field.set_token_pos(reader->Read<int32_t>());
   field.set_guarded_cid(reader->Read<int32_t>());
   field.set_is_nullable(reader->Read<int32_t>());
   field.set_kind_bits(reader->Read<uint8_t>());
@@ skipping 43 matching lines @@
 
 RawLiteralToken* LiteralToken::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
   // Create the literal token object.
   LiteralToken& literal_token = LiteralToken::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(LiteralToken));
+      reader->zone(), NEW_OBJECT(LiteralToken));
   reader->AddBackRef(object_id, &literal_token, kIsDeserialized);
 
   // Set the object tags.
   literal_token.set_tags(tags);
 
   // Read the token attributes.
   Token::Kind token_kind = static_cast<Token::Kind>(reader->Read<int32_t>());
   literal_token.set_kind(token_kind);
 
   // Set all the object fields.
@@ skipping 39 matching lines @@
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Read the length so that we can determine number of tokens to read.
   intptr_t len = reader->ReadSmiValue();
 
   // Create the token stream object.
   TokenStream& token_stream = TokenStream::ZoneHandle(
-      reader->isolate(), NEW_OBJECT_WITH_LEN(TokenStream, len));
+      reader->zone(), NEW_OBJECT_WITH_LEN(TokenStream, len));
   reader->AddBackRef(object_id, &token_stream, kIsDeserialized);
 
   // Set the object tags.
   token_stream.set_tags(tags);
 
   // Read the stream of tokens into the TokenStream object for script
   // snapshots as we made a copy of token stream.
   if (kind == Snapshot::kScript) {
     NoGCScope no_gc;
     RawExternalTypedData* stream = token_stream.GetStream();
@@ skipping 42 matching lines @@
 RawScript* Script::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Allocate script object.
-  Script& script = Script::ZoneHandle(reader->isolate(), NEW_OBJECT(Script));
+  Script& script = Script::ZoneHandle(reader->zone(), NEW_OBJECT(Script));
   reader->AddBackRef(object_id, &script, kIsDeserialized);
 
   // Set the object tags.
   script.set_tags(tags);
 
   script.StoreNonPointer(&script.raw_ptr()->line_offset_,
                          reader->Read<int32_t>());
   script.StoreNonPointer(&script.raw_ptr()->col_offset_,
                          reader->Read<int32_t>());
   script.StoreNonPointer(&script.raw_ptr()->kind_,
@@ skipping 43 matching lines @@
 }
 
 
 RawLibrary* Library::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
-  Library& library = Library::ZoneHandle(reader->isolate(), Library::null());
+  Library& library = Library::ZoneHandle(reader->zone(), Library::null());
   reader->AddBackRef(object_id, &library, kIsDeserialized);
 
   if ((kind == Snapshot::kScript) && RawObject::IsCreatedFromSnapshot(tags)) {
     ASSERT(kind != Snapshot::kFull);
     // Lookup the object as it should already exist in the heap.
     *reader->StringHandle() ^= reader->ReadObjectImpl();
     library = Library::LookupLibrary(*reader->StringHandle());
   } else {
     // Allocate library object.
     library = NEW_OBJECT(Library);
@@ skipping 94 matching lines @@
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Allocate library prefix object.
   LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(LibraryPrefix));
+      reader->zone(), NEW_OBJECT(LibraryPrefix));
   reader->AddBackRef(object_id, &prefix, kIsDeserialized);
 
   // Set the object tags.
   prefix.set_tags(tags);
 
   // Set all non object fields.
   prefix.StoreNonPointer(&prefix.raw_ptr()->num_imports_,
                          reader->Read<int32_t>());
   prefix.StoreNonPointer(&prefix.raw_ptr()->is_deferred_load_,
                          reader->Read<bool>());
@@ skipping 43 matching lines @@
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Allocate Namespace object.
   Namespace& ns = Namespace::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(Namespace));
+      reader->zone(), NEW_OBJECT(Namespace));
   reader->AddBackRef(object_id, &ns, kIsDeserialized);
 
   // Set the object tags.
   ns.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (ns.raw()->to() - ns.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
@@ skipping 142 matching lines @@
 
 
 RawContext* Context::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate context object.
   int32_t num_vars = reader->Read<int32_t>();
-  Context& context = Context::ZoneHandle(reader->isolate());
+  Context& context = Context::ZoneHandle(reader->zone());
   reader->AddBackRef(object_id, &context, kIsDeserialized);
   if (num_vars == 0) {
     context ^= reader->object_store()->empty_context();
   } else {
     context ^= NEW_OBJECT_WITH_LEN(Context, num_vars);
 
     // Set the object tags.
     context.set_tags(tags);
 
     // Set all the object fields.
@@ skipping 114 matching lines @@
 
 
 RawApiError* ApiError::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate ApiError object.
   ApiError& api_error =
-      ApiError::ZoneHandle(reader->isolate(), NEW_OBJECT(ApiError));
+      ApiError::ZoneHandle(reader->zone(), NEW_OBJECT(ApiError));
   reader->AddBackRef(object_id, &api_error, kIsDeserialized);
 
   // Set the object tags.
   api_error.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (api_error.raw()->to() - api_error.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
@@ skipping 25 matching lines @@
 
 
 RawLanguageError* LanguageError::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate LanguageError object.
   LanguageError& language_error =
-      LanguageError::ZoneHandle(reader->isolate(), NEW_OBJECT(LanguageError));
+      LanguageError::ZoneHandle(reader->zone(), NEW_OBJECT(LanguageError));
   reader->AddBackRef(object_id, &language_error, kIsDeserialized);
 
   // Set the object tags.
   language_error.set_tags(tags);
 
   // Set all non object fields.
   language_error.set_token_pos(reader->Read<int32_t>());
   language_error.set_kind(reader->Read<uint8_t>());
 
   // Set all the object fields.
@@ skipping 31 matching lines @@
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawUnhandledException* UnhandledException::ReadFrom(SnapshotReader* reader,
                                                     intptr_t object_id,
                                                     intptr_t tags,
                                                     Snapshot::Kind kind) {
   UnhandledException& result = UnhandledException::ZoneHandle(
-      reader->isolate(), NEW_OBJECT(UnhandledException));
+      reader->zone(), NEW_OBJECT(UnhandledException));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set the object tags.
   result.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (result.raw()->to() - result.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
@@ skipping 38 matching lines @@
 
 
 RawInstance* Instance::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Create an Instance object or get canonical one if it is a canonical
   // constant.
-  Instance& obj = Instance::ZoneHandle(reader->isolate(), Instance::null());
+  Instance& obj = Instance::ZoneHandle(reader->zone(), Instance::null());
   if (kind == Snapshot::kFull) {
     obj = reader->NewInstance();
   } else {
     obj ^= Object::Allocate(kInstanceCid,
                             Instance::InstanceSize(),
                             HEAP_SPACE(kind));
     // When reading a script snapshot we need to canonicalize only those object
     // references that are objects from the core library (loaded from a
     // full snapshot). Objects that are only in the script need not be
     // canonicalized as they are already canonical.
@@ skipping 30 matching lines @@
 RawMint* Mint::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the 64 bit value for the object.
   int64_t value = reader->Read<int64_t>();
 
   // Create a Mint object or get canonical one if it is a canonical constant.
-  Mint& mint = Mint::ZoneHandle(reader->isolate(), Mint::null());
+  Mint& mint = Mint::ZoneHandle(reader->zone(), Mint::null());
   if (kind == Snapshot::kFull) {
     mint = reader->NewMint(value);
   } else {
     // When reading a script snapshot we need to canonicalize only those object
     // references that are objects from the core library (loaded from a
     // full snapshot). Objects that are only in the script need not be
     // canonicalized as they are already canonical.
     // When reading a message snapshot we always have to canonicalize.
     if (RawObject::IsCanonical(tags) &&
         (RawObject::IsCreatedFromSnapshot(tags) ||
@@ skipping 29 matching lines @@
 }
 
 
 RawBigint* Bigint::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate bigint object.
-  Bigint& obj = Bigint::ZoneHandle(reader->isolate(), NEW_OBJECT(Bigint));
+  Bigint& obj = Bigint::ZoneHandle(reader->zone(), NEW_OBJECT(Bigint));
   reader->AddBackRef(object_id, &obj, kIsDeserialized);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (obj.raw()->to() - obj.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl();
     obj.StorePointer(obj.raw()->from() + i,
                      reader->PassiveObjectHandle()->raw());
@@ skipping 42 matching lines @@
 RawDouble* Double::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
   // Read the double value for the object.
   double value = reader->ReadDouble();
 
   // Create a Double object or get canonical one if it is a canonical constant.
-  Double& dbl = Double::ZoneHandle(reader->isolate(), Double::null());
+  Double& dbl = Double::ZoneHandle(reader->zone(), Double::null());
   if (kind == Snapshot::kFull) {
     dbl = reader->NewDouble(value);
   } else {
     // When reading a script snapshot we need to canonicalize only those object
     // references that are objects from the core library (loaded from a
     // full snapshot). Objects that are only in the script need not be
     // canonicalized as they are already canonical.
     if (RawObject::IsCanonical(tags) &&
         RawObject::IsCreatedFromSnapshot(tags)) {
       dbl = Double::NewCanonical(value);
@@ skipping 46 matching lines @@
 template<typename StringType, typename CharacterType, typename CallbackType>
 void String::ReadFromImpl(SnapshotReader* reader,
                           String* str_obj,
                           intptr_t len,
                           intptr_t tags,
                           CallbackType new_symbol,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   if (RawObject::IsCanonical(tags)) {
     // Set up canonical string object.
-    Isolate* isolate = reader->isolate();
     ASSERT(reader != NULL);
-    CharacterType* ptr =
-        isolate->current_zone()->Alloc<CharacterType>(len);
+    CharacterType* ptr = reader->zone()->Alloc<CharacterType>(len);
     for (intptr_t i = 0; i < len; i++) {
       ptr[i] = reader->Read<CharacterType>();
     }
     *str_obj ^= (*new_symbol)(ptr, len);
   } else {
     // Set up the string object.
     *str_obj = StringType::New(len, HEAP_SPACE(kind));
     str_obj->set_tags(tags);
     str_obj->SetHash(0);  // Will get computed when needed.
     if (len == 0) {
@@ skipping 10 matching lines @@
 
 
 RawOneByteString* OneByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   // Read the length so that we can determine instance size to allocate.
   ASSERT(reader != NULL);
   intptr_t len = reader->ReadSmiValue();
   intptr_t hash = reader->ReadSmiValue();
-  String& str_obj = String::Handle(reader->isolate(), String::null());
+  String& str_obj = String::Handle(reader->zone(), String::null());
 
   if (kind == Snapshot::kFull) {
     ASSERT(reader->isolate()->no_gc_scope_depth() != 0);
     RawOneByteString* obj = reader->NewOneByteString(len);
     str_obj = obj;
     str_obj.set_tags(tags);
     str_obj.SetHash(hash);
     if (len > 0) {
       uint8_t* raw_ptr = CharAddr(str_obj, 0);
       reader->ReadBytes(raw_ptr, len);
     }
     ASSERT((hash == 0) || (String::Hash(str_obj, 0, str_obj.Length()) == hash));
   } else {
     String::ReadFromImpl<OneByteString, uint8_t>(
         reader, &str_obj, len, tags, Symbols::FromLatin1, kind);
   }
   reader->AddBackRef(object_id, &str_obj, kIsDeserialized);
   return raw(str_obj);
 }
 
 
 RawTwoByteString* TwoByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   // Read the length so that we can determine instance size to allocate.
   ASSERT(reader != NULL);
   intptr_t len = reader->ReadSmiValue();
   intptr_t hash = reader->ReadSmiValue();
-  String& str_obj = String::Handle(reader->isolate(), String::null());
+  String& str_obj = String::Handle(reader->zone(), String::null());
 
   if (kind == Snapshot::kFull) {
     RawTwoByteString* obj = reader->NewTwoByteString(len);
     str_obj = obj;
     str_obj.set_tags(tags);
     str_obj.SetHash(hash);
     NoGCScope no_gc;
     uint16_t* raw_ptr = (len > 0)? CharAddr(str_obj, 0) : NULL;
     for (intptr_t i = 0; i < len; i++) {
       ASSERT(CharAddr(str_obj, i) == raw_ptr);  // Will trigger assertions.
@@ skipping 146 matching lines @@
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
   Array* array = reinterpret_cast<Array*>(
       reader->GetBackRef(object_id));
   if (array == NULL) {
-    array = &(Array::ZoneHandle(reader->isolate(),
+    array = &(Array::ZoneHandle(reader->zone(),
                                 NEW_OBJECT_WITH_LEN_SPACE(Array, len, kind)));
     reader->AddBackRef(object_id, array, kIsDeserialized);
   }
   ASSERT(!RawObject::IsCanonical(tags));
   reader->ArrayReadFrom(*array, len, tags);
   return array->raw();
 }
 
 
 RawImmutableArray* ImmutableArray::ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
   Array* array = reinterpret_cast<Array*>(reader->GetBackRef(object_id));
   if (array == NULL) {
     array = &(Array::ZoneHandle(
-        reader->isolate(),
+        reader->zone(),
         NEW_OBJECT_WITH_LEN_SPACE(ImmutableArray, len, kind)));
     reader->AddBackRef(object_id, array, kIsDeserialized);
   }
   reader->ArrayReadFrom(*array, len, tags);
   if (RawObject::IsCanonical(tags)) {
     *array ^= array->CheckAndCanonicalize(NULL);
   }
   return raw(*array);
 }
 
@@ skipping 24 matching lines @@
 
 
 RawGrowableObjectArray* GrowableObjectArray::ReadFrom(SnapshotReader* reader,
                                                       intptr_t object_id,
                                                       intptr_t tags,
                                                       Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   GrowableObjectArray& array = GrowableObjectArray::ZoneHandle(
-      reader->isolate(), GrowableObjectArray::null());
+      reader->zone(), GrowableObjectArray::null());
   if (kind == Snapshot::kFull) {
     array = reader->NewGrowableObjectArray();
   } else {
     array = GrowableObjectArray::New(0, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &array, kIsDeserialized);
   intptr_t length = reader->ReadSmiValue();
   array.SetLength(length);
   *(reader->ArrayHandle()) ^= reader->ReadObjectImpl();
   array.SetData(*(reader->ArrayHandle()));
@@ skipping 23 matching lines @@
 }
 
 
 RawLinkedHashMap* LinkedHashMap::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   LinkedHashMap& map = LinkedHashMap::ZoneHandle(
-      reader->isolate(), LinkedHashMap::null());
+      reader->zone(), LinkedHashMap::null());
   if (kind == Snapshot::kFull || kind == Snapshot::kScript) {
     // The immutable maps that seed map literals are not yet VM-internal, so
     // we don't reach this.
     UNREACHABLE();
   } else {
     map = LinkedHashMap::New(HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &map, kIsDeserialized);
   *(reader->ArrayHandle()) ^= reader->ReadObjectImpl();
   map.SetData(*(reader->ArrayHandle()));
@@ skipping 32 matching lines @@
                                   intptr_t tags,
                                   Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   // Read the values.
   float value0 = reader->Read<float>();
   float value1 = reader->Read<float>();
   float value2 = reader->Read<float>();
   float value3 = reader->Read<float>();
 
   // Create a Float32x4 object.
-  Float32x4& simd = Float32x4::ZoneHandle(reader->isolate(),
+  Float32x4& simd = Float32x4::ZoneHandle(reader->zone(),
                                           Float32x4::null());
   if (kind == Snapshot::kFull) {
     simd = reader->NewFloat32x4(value0, value1, value2, value3);
   } else {
     simd = Float32x4::New(value0, value1, value2, value3, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &simd, kIsDeserialized);
   // Set the object tags.
   simd.set_tags(tags);
   return simd.raw();
@@ skipping 25 matching lines @@
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   // Read the values.
   uint32_t value0 = reader->Read<uint32_t>();
   uint32_t value1 = reader->Read<uint32_t>();
   uint32_t value2 = reader->Read<uint32_t>();
   uint32_t value3 = reader->Read<uint32_t>();
 
   // Create a Float32x4 object.
-  Int32x4& simd = Int32x4::ZoneHandle(reader->isolate(), Int32x4::null());
+  Int32x4& simd = Int32x4::ZoneHandle(reader->zone(), Int32x4::null());
 
   if (kind == Snapshot::kFull) {
     simd = reader->NewInt32x4(value0, value1, value2, value3);
   } else {
     simd = Int32x4::New(value0, value1, value2, value3, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &simd, kIsDeserialized);
   // Set the object tags.
   simd.set_tags(tags);
   return simd.raw();
@@ skipping 23 matching lines @@
 RawFloat64x2* Float64x2::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   // Read the values.
   double value0 = reader->Read<double>();
   double value1 = reader->Read<double>();
 
   // Create a Float64x2 object.
-  Float64x2& simd = Float64x2::ZoneHandle(reader->isolate(),
+  Float64x2& simd = Float64x2::ZoneHandle(reader->zone(),
                                           Float64x2::null());
   if (kind == Snapshot::kFull) {
     simd = reader->NewFloat64x2(value0, value1);
   } else {
     simd = Float64x2::New(value0, value1, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &simd, kIsDeserialized);
   // Set the object tags.
   simd.set_tags(tags);
   return simd.raw();
@@ skipping 25 matching lines @@
 
 
 RawTypedData* TypedData::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   intptr_t cid = RawObject::ClassIdTag::decode(tags);
   intptr_t len = reader->ReadSmiValue();
-  TypedData& result = TypedData::ZoneHandle(reader->isolate(),
+  TypedData& result = TypedData::ZoneHandle(reader->zone(),
       (kind == Snapshot::kFull) ? reader->NewTypedData(cid, len)
                                 : TypedData::New(cid, len, HEAP_SPACE(kind)));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set the object tags.
   result.set_tags(tags);
 
   // Setup the array elements.
   intptr_t element_size = ElementSizeInBytes(cid);
   intptr_t length_in_bytes = len * element_size;
@@ skipping 191 matching lines @@
 #undef TYPED_DATA_WRITE
 #undef EXT_TYPED_DATA_WRITE
 
 
 RawCapability* Capability::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind) {
   uint64_t id = reader->Read<uint64_t>();
 
-  Capability& result = Capability::ZoneHandle(reader->isolate(),
+  Capability& result = Capability::ZoneHandle(reader->zone(),
                                               Capability::New(id));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
   return result.raw();
 }
 
 
 void RawCapability::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind) {
   // Write out the serialization header value for this object.
@@ skipping 30 matching lines @@
 }
 
 
 RawSendPort* SendPort::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   uint64_t id = reader->Read<uint64_t>();
   uint64_t origin_id = reader->Read<uint64_t>();
 
-  SendPort& result = SendPort::ZoneHandle(reader->isolate(),
+  SendPort& result = SendPort::ZoneHandle(reader->zone(),
                                           SendPort::New(id, origin_id));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
   return result.raw();
 }
 
 
 void RawSendPort::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kSendPortCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   writer->Write<uint64_t>(ptr()->id_);
   writer->Write<uint64_t>(ptr()->origin_id_);
 }
 
 
 RawStacktrace* Stacktrace::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind) {
   if (kind == Snapshot::kFull) {
-    Stacktrace& result = Stacktrace::ZoneHandle(reader->isolate(),
+    Stacktrace& result = Stacktrace::ZoneHandle(reader->zone(),
                                                 reader->NewStacktrace());
     reader->AddBackRef(object_id, &result, kIsDeserialized);
 
     // Set all the object fields.
     // TODO(5411462): Need to assert No GC can happen here, even though
     // allocations may happen.
     intptr_t num_flds = (result.raw()->to() - result.raw()->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
       (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
       result.StorePointer((result.raw()->from() + i),
@@ skipping 44 matching lines @@
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
 
   // Allocate JSRegExp object.
   JSRegExp& regex = JSRegExp::ZoneHandle(
-      reader->isolate(), JSRegExp::New(len, HEAP_SPACE(kind)));
+      reader->zone(), JSRegExp::New(len, HEAP_SPACE(kind)));
   reader->AddBackRef(object_id, &regex, kIsDeserialized);
 
   // Set the object tags.
   regex.set_tags(tags);
 
   // Read and Set all the other fields.
   regex.StoreSmi(&regex.raw_ptr()->num_bracket_expressions_,
                  reader->ReadAsSmi());
   *reader->StringHandle() ^= reader->ReadObjectImpl();
   regex.set_pattern(*reader->StringHandle());
@@ skipping 32 matching lines @@
 
 
 RawWeakProperty* WeakProperty::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate the weak property object.
   WeakProperty& weak_property = WeakProperty::ZoneHandle(
-      reader->isolate(), WeakProperty::New(HEAP_SPACE(kind)));
+      reader->zone(), WeakProperty::New(HEAP_SPACE(kind)));
   reader->AddBackRef(object_id, &weak_property, kIsDeserialized);
 
   // Set the object tags.
   weak_property.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (weak_property.raw()->to() -
                        weak_property.raw()->from());
@@ skipping 64 matching lines @@
     // We do not allow objects with native fields in an isolate message.
     writer->SetWriteException(Exceptions::kArgument,
                               "Illegal argument in isolate message"
                               " : (object is a UserTag)");
   } else {
     UNREACHABLE();
   }
 }
 
 }  // namespace dart