Remove dead full snapshot support from the recursive descent serializer.

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/native_entry.h"
 #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"
 
 namespace dart {
 
 DECLARE_FLAG(bool, remove_script_timestamps_for_test);
 
-#define NEW_OBJECT(type)                                                       \
-  ((Snapshot::IsFull(kind)) ? reader->New##type() : type::New())
-
-#define NEW_OBJECT_WITH_LEN(type, len)                                         \
-  ((Snapshot::IsFull(kind)) ? reader->New##type(len) : type::New(len))
-
-#define NEW_OBJECT_WITH_LEN_SPACE(type, len, kind)                             \
-  ((Snapshot::IsFull(kind)) ?                                                  \
-  reader->New##type(len) : type::New(len, HEAP_SPACE(kind)))
-
 #define OFFSET_OF_FROM(obj)                                                    \
   obj.raw()->from() - reinterpret_cast<RawObject**>(obj.raw()->ptr())
 
 // TODO(18854): Need to assert No GC can happen here, even though
 // allocations may happen.
 #define READ_OBJECT_FIELDS(object, from, to, as_reference)                     \
   intptr_t num_flds = (to) - (from);                                           \
   intptr_t from_offset = OFFSET_OF_FROM(object);                               \
   for (intptr_t i = 0; i <= num_flds; i++) {                                   \
     (*reader->PassiveObjectHandle()) =                                         \
         reader->ReadObjectImpl(as_reference, object_id, (i + from_offset));    \
     object.StorePointer(((from) + i),                                          \
                         reader->PassiveObjectHandle()->raw());                 \
   }
 
 RawClass* Class::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind,
                           bool as_reference) {
   ASSERT(reader != NULL);
 
   Class& cls = Class::ZoneHandle(reader->zone(), Class::null());
   bool is_in_fullsnapshot = reader->Read<bool>();
-  if (Snapshot::IsFull(kind) ||
-      (kind == Snapshot::kScript && !is_in_fullsnapshot)) {
+  if ((kind == Snapshot::kScript) && !is_in_fullsnapshot) {
     // Read in the base information.
     classid_t class_id = reader->ReadClassIDValue();
 
     // Allocate class object of specified kind.
-    if (Snapshot::IsFull(kind)) {
-      cls = reader->NewClass(class_id);
+    if (class_id < kNumPredefinedCids) {
+      ASSERT((class_id >= kInstanceCid) && (class_id <= kMirrorReferenceCid));
+      cls = reader->isolate()->class_table()->At(class_id);
     } else {
-      if (class_id < kNumPredefinedCids) {
-        ASSERT((class_id >= kInstanceCid) && (class_id <= kMirrorReferenceCid));
-        cls = reader->isolate()->class_table()->At(class_id);
-      } else {
-        cls = Class::NewInstanceClass();
-      }
+      cls = Class::NewInstanceClass();
     }
     reader->AddBackRef(object_id, &cls, kIsDeserialized);
 
     // Set all non object fields.
     if (!RawObject::IsInternalVMdefinedClassId(class_id)) {
       // Instance size of a VM defined class is already set up.
       cls.set_instance_size_in_words(reader->Read<int32_t>());
       cls.set_next_field_offset_in_words(reader->Read<int32_t>());
     }
     cls.set_type_arguments_field_offset_in_words(reader->Read<int32_t>());
     cls.set_num_type_arguments(reader->Read<int16_t>());
     cls.set_num_own_type_arguments(reader->Read<int16_t>());
     cls.set_num_native_fields(reader->Read<uint16_t>());
     cls.set_token_pos(TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
     cls.set_state_bits(reader->Read<uint16_t>());
 
     // Set all the object fields.
     READ_OBJECT_FIELDS(cls,
                        cls.raw()->from(),
                        cls.raw()->to_snapshot(kind),
                        kAsReference);
     cls.StorePointer(&cls.raw_ptr()->dependent_code_, Array::null());
-    ASSERT(!cls.IsInFullSnapshot() || (Snapshot::IsFull(kind)));
+    ASSERT(!cls.IsInFullSnapshot());
   } else {
     cls ^= reader->ReadClassId(object_id);
     ASSERT((kind == Snapshot::kMessage) || cls.IsInFullSnapshot());
   }
   return cls.raw();
 }
 
 
 void RawClass::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind,
                        bool as_reference) {
   ASSERT(writer != NULL);
   bool is_in_fullsnapshot = Class::IsInFullSnapshot(this);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kClassCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the boolean is_in_fullsnapshot first as this will
   // help the reader decide how the rest of the information needs
   // to be interpreted.
   writer->Write<bool>(is_in_fullsnapshot);
 
-  if (Snapshot::IsFull(kind) ||
-      (kind == Snapshot::kScript && !is_in_fullsnapshot)) {
+  if ((kind == Snapshot::kScript) && !is_in_fullsnapshot) {
     // Write out all the non object pointer fields.
     // NOTE: cpp_vtable_ is not written.
     classid_t class_id = ptr()->id_;
     ASSERT(class_id != kIllegalCid);
     writer->Write<classid_t>(class_id);
     if (!RawObject::IsInternalVMdefinedClassId(class_id)) {
       // We don't write the instance size of VM defined classes as they
       // are already setup during initialization as part of pre populating
       // the class table.
       writer->Write<int32_t>(ptr()->instance_size_in_words_);
@@ skipping 25 matching lines @@
 
 RawUnresolvedClass* UnresolvedClass::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind,
                                               bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate unresolved class object.
   UnresolvedClass& unresolved_class = UnresolvedClass::ZoneHandle(
-      reader->zone(), NEW_OBJECT(UnresolvedClass));
+      reader->zone(), UnresolvedClass::New());
   reader->AddBackRef(object_id, &unresolved_class, kIsDeserialized);
 
   // Set all non object fields.
   unresolved_class.set_token_pos(
       TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(unresolved_class,
                      unresolved_class.raw()->from(),
                      unresolved_class.raw()->to(),
@@ skipping 47 matching lines @@
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind,
                         bool as_reference) {
   ASSERT(reader != NULL);
 
   // Determine if the type class of this type is in the full snapshot.
   bool typeclass_is_in_fullsnapshot = reader->Read<bool>();
 
   // Allocate type object.
-  Type& type = Type::ZoneHandle(reader->zone(), NEW_OBJECT(Type));
+  Type& type = Type::ZoneHandle(reader->zone(), Type::New());
   bool is_canonical = RawObject::IsCanonical(tags);
   bool defer_canonicalization = is_canonical &&
       (!Snapshot::IsFull(kind) && typeclass_is_in_fullsnapshot);
   reader->AddBackRef(object_id, &type, kIsDeserialized, defer_canonicalization);
 
   // Set all non object fields.
   type.set_token_pos(TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
   type.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
@@ skipping 60 matching lines @@
 
 RawTypeRef* TypeRef::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind,
                               bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate type ref object.
   TypeRef& type_ref = TypeRef::ZoneHandle(
-      reader->zone(), NEW_OBJECT(TypeRef));
+      reader->zone(), TypeRef::New());
   reader->AddBackRef(object_id, &type_ref, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(type_ref,
                      type_ref.raw()->from(), type_ref.raw()->to(),
                      kAsReference);
 
   return type_ref.raw();
 }
 
@@ skipping 19 matching lines @@
 
 RawTypeParameter* TypeParameter::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate type parameter object.
   TypeParameter& type_parameter = TypeParameter::ZoneHandle(
-      reader->zone(), NEW_OBJECT(TypeParameter));
+      reader->zone(), TypeParameter::New());
   reader->AddBackRef(object_id, &type_parameter, kIsDeserialized);
 
   // Set all non object fields.
   type_parameter.set_token_pos(
       TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
   type_parameter.set_index(reader->Read<int16_t>());
   type_parameter.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(type_parameter,
@@ skipping 43 matching lines @@
 
 RawBoundedType* BoundedType::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind,
                                       bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate bounded type object.
   BoundedType& bounded_type = BoundedType::ZoneHandle(
-      reader->zone(), NEW_OBJECT(BoundedType));
+      reader->zone(), BoundedType::New());
   reader->AddBackRef(object_id, &bounded_type, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(bounded_type,
                      bounded_type.raw()->from(), bounded_type.raw()->to(),
                      kAsReference);
 
   return bounded_type.raw();
 }
 
@@ skipping 39 matching lines @@
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   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->zone(), NEW_OBJECT_WITH_LEN_SPACE(TypeArguments, len, kind));
+      reader->zone(), TypeArguments::New(len, HEAP_SPACE(kind)));
   bool is_canonical = RawObject::IsCanonical(tags);
   bool defer_canonicalization = is_canonical && (!Snapshot::IsFull(kind));
   reader->AddBackRef(object_id,
                      &type_arguments,
                      kIsDeserialized,
                      defer_canonicalization);
 
   // Set the instantiations field, which is only read from a full snapshot.
-  if (Snapshot::IsFull(kind)) {
-    *(reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
-    type_arguments.set_instantiations(*(reader->ArrayHandle()));
-  } else {
-    type_arguments.set_instantiations(Object::zero_array());
-  }
+  type_arguments.set_instantiations(Object::zero_array());
 
   // Now set all the type fields.
   intptr_t offset = type_arguments.TypeAddr(0) -
       reinterpret_cast<RawAbstractType**>(type_arguments.raw()->ptr());
   for (intptr_t i = 0; i < len; i++) {
     *reader->TypeHandle() ^=
         reader->ReadObjectImpl(kAsReference, object_id, (i + offset));
     type_arguments.SetTypeAt(i, *reader->TypeHandle());
   }
 
@@ skipping 15 matching lines @@
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kTypeArgumentsCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the length field.
   writer->Write<RawObject*>(ptr()->length_);
 
-  // Write out the instantiations field, but only in a full snapshot.
-  if (Snapshot::IsFull(kind)) {
-    writer->WriteObjectImpl(ptr()->instantiations_, kAsInlinedObject);
-  }
-
   // Write out the individual types.
   intptr_t len = Smi::Value(ptr()->length_);
   for (intptr_t i = 0; i < len; i++) {
     writer->WriteObjectImpl(ptr()->types()[i], kAsReference);
   }
 }
 
 
 RawPatchClass* PatchClass::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind,
                                     bool as_reference) {
   ASSERT(reader != NULL);
+  ASSERT(kind == Snapshot::kScript);
 
   // Allocate function object.
   PatchClass& cls = PatchClass::ZoneHandle(reader->zone(),
-                                            NEW_OBJECT(PatchClass));
+                                           PatchClass::New());
   reader->AddBackRef(object_id, &cls, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(cls, cls.raw()->from(), cls.raw()->to(), kAsReference);
 
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
   return cls.raw();
 }
 
 
 void RawPatchClass::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind,
                             bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kPatchClassCid);
   writer->WriteTags(writer->GetObjectTags(this));
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawClosure* Closure::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind,
                               bool as_reference) {
-  ASSERT(reader != NULL);
-  ASSERT(Snapshot::IsFull(kind));
-
-  // Allocate closure object.
-  Closure& closure = Closure::ZoneHandle(
-      reader->zone(), NEW_OBJECT(Closure));
-  reader->AddBackRef(object_id, &closure, kIsDeserialized);
-
-  // Set all the object fields.
-  READ_OBJECT_FIELDS(closure,
-                     closure.raw()->from(), closure.raw()->to(),
-                     kAsReference);
-
-  // Set the canonical bit.
-  if (RawObject::IsCanonical(tags)) {
-    closure.SetCanonical();
-  }
-  return closure.raw();
+  UNREACHABLE();
+  return Closure::null();
 }
 
 
 void RawClosure::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind,
                          bool as_reference) {
   ASSERT(writer != NULL);
-  if ((kind == Snapshot::kMessage) || (kind == Snapshot::kScript)) {
-    // Check if closure is serializable, throw an exception otherwise.
-    RawFunction* func = writer->IsSerializableClosure(this);
-    if (func != Function::null()) {
-      writer->WriteStaticImplicitClosure(object_id,
-                                         func,
-                                         writer->GetObjectTags(this));
-      return;
-    }
+  ASSERT((kind == Snapshot::kMessage) || (kind == Snapshot::kScript));
+
+  // Check if closure is serializable, throw an exception otherwise.
+  RawFunction* func = writer->IsSerializableClosure(this);
+  if (func != Function::null()) {
+    writer->WriteStaticImplicitClosure(object_id,
+                                       func,
+                                       writer->GetObjectTags(this));
+    return;
   }
 
-  // Write out the serialization header value for this object.
-  writer->WriteInlinedObjectHeader(object_id);
-
-  // Write out the class and tags information.
-  writer->WriteIndexedObject(kClosureCid);
-  writer->WriteTags(writer->GetObjectTags(this));
-
-  // Write out all the object pointer fields.
-  SnapshotWriterVisitor visitor(writer, kAsReference);
-  visitor.VisitPointers(from(), to());
+  UNREACHABLE();
 }
 
 
 RawClosureData* ClosureData::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind,
                                       bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Allocate closure data object.
-  ClosureData& data = ClosureData::ZoneHandle(
-      reader->zone(), NEW_OBJECT(ClosureData));
+  ClosureData& data = ClosureData::ZoneHandle(reader->zone(),
+                                              ClosureData::New());
   reader->AddBackRef(object_id, &data, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(data,
                      data.raw()->from(), data.raw()->to(),
                      kAsInlinedObject);
 
   return data.raw();
 }
 
 
 void RawClosureData::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind,
                              bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kClosureDataCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Context scope.
   if (ptr()->context_scope_ == Object::empty_context_scope().raw()) {
     writer->WriteVMIsolateObject(kEmptyContextScopeObject);
-  } else if (ptr()->context_scope_->ptr()->is_implicit_ ||
-             (kind == Snapshot::kAppWithJIT)) {
+  } else if (ptr()->context_scope_->ptr()->is_implicit_) {
     writer->WriteObjectImpl(ptr()->context_scope_, kAsInlinedObject);
   } else {
     // We don't write non implicit context scopes in the snapshot.
     writer->WriteVMIsolateObject(kNullObject);
   }
 
   // Parent function.
   writer->WriteObjectImpl(ptr()->parent_function_, kAsInlinedObject);
 
   // Signature type.
   writer->WriteObjectImpl(ptr()->signature_type_, kAsInlinedObject);
 
   // Canonical static closure.
   writer->WriteObjectImpl(ptr()->closure_, kAsInlinedObject);
 }
 
 
 RawRedirectionData* RedirectionData::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind,
                                               bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Allocate redirection data object.
-  RedirectionData& data = RedirectionData::ZoneHandle(
-      reader->zone(), NEW_OBJECT(RedirectionData));
+  RedirectionData& data = RedirectionData::ZoneHandle(reader->zone(),
+                                                      RedirectionData::New());
   reader->AddBackRef(object_id, &data, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(data,
                      data.raw()->from(), data.raw()->to(),
                      kAsReference);
 
   return data.raw();
 }
 
 
 void RawRedirectionData::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind,
                                  bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kRedirectionDataCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawFunction* Function::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   bool is_in_fullsnapshot = reader->Read<bool>();
-  if ((Snapshot::IsFull(kind)) || !is_in_fullsnapshot) {
+  if (!is_in_fullsnapshot) {
     // Allocate function object.
-    Function& func = Function::ZoneHandle(
-        reader->zone(), NEW_OBJECT(Function));
+    Function& func = Function::ZoneHandle(reader->zone(),
+                                          Function::New());
     reader->AddBackRef(object_id, &func, kIsDeserialized);
 
     // Set all the non object fields. Read the token positions now but
     // don't set them until after setting the kind.
     const int32_t token_pos = reader->Read<int32_t>();
     const int32_t end_token_pos = reader->Read<uint32_t>();
     func.set_num_fixed_parameters(reader->Read<int16_t>());
     func.set_num_optional_parameters(reader->Read<int16_t>());
     func.set_kind_tag(reader->Read<uint32_t>());
     func.set_token_pos(TokenPosition::SnapshotDecode(token_pos));
     func.set_end_token_pos(TokenPosition::SnapshotDecode(end_token_pos));
-    if (kind == Snapshot::kAppNoJIT) {
-      func.set_usage_counter(0);
-      func.set_deoptimization_counter(0);
-      func.set_optimized_instruction_count(0);
-      func.set_optimized_call_site_count(0);
-    } else {
-      func.set_usage_counter(reader->Read<int32_t>());
-      func.set_deoptimization_counter(reader->Read<int8_t>());
-      func.set_optimized_instruction_count(reader->Read<uint16_t>());
-      func.set_optimized_call_site_count(reader->Read<uint16_t>());
-    }
+    func.set_usage_counter(reader->Read<int32_t>());
+    func.set_deoptimization_counter(reader->Read<int8_t>());
+    func.set_optimized_instruction_count(reader->Read<uint16_t>());
+    func.set_optimized_call_site_count(reader->Read<uint16_t>());
     func.set_was_compiled(false);
 
     // Set all the object fields.
     READ_OBJECT_FIELDS(func,
                        func.raw()->from(), func.raw()->to_snapshot(),
                        kAsReference);
     // Initialize all fields that are not part of the snapshot.
-    if (kind == Snapshot::kAppNoJIT) {
-      // Read the code object and fixup entry point.
-      func.ClearICDataArray();
-      func.ClearCode();
-      (*reader->CodeHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
-      func.SetInstructions(*reader->CodeHandle());
-    } else if (kind == Snapshot::kAppWithJIT) {
+    bool is_optimized = func.usage_counter() != 0;
+    if (is_optimized) {
+      // Read the ic data array as the function is an optimized one.
       (*reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsReference);
       func.set_ic_data_array(*reader->ArrayHandle());
-      (*reader->CodeHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
-      func.set_unoptimized_code(*reader->CodeHandle());
-      if (!reader->CodeHandle()->IsNull()) {
-        func.SetInstructions(*reader->CodeHandle());
-        func.set_was_compiled(true);
-      } else {
-        func.ClearCode();
-      }
     } else {
-      bool is_optimized = func.usage_counter() != 0;
-      if (is_optimized) {
-        // Read the ic data array as the function is an optimized one.
-        (*reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsReference);
-        func.set_ic_data_array(*reader->ArrayHandle());
-      } else {
-        func.ClearICDataArray();
-      }
-      func.ClearCode();
+      func.ClearICDataArray();
     }
+    func.ClearCode();
     return func.raw();
   } else {
     return reader->ReadFunctionId(object_id);
   }
 }
 
 
 void RawFunction::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind,
                           bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
   bool is_in_fullsnapshot = false;
   bool owner_is_class = false;
   if ((kind == Snapshot::kScript) && !Function::IsSignatureFunction(this)) {
     intptr_t tags = writer->GetObjectTags(ptr()->owner_);
     intptr_t cid = ClassIdTag::decode(tags);
     owner_is_class = (cid == kClassCid);
     is_in_fullsnapshot = owner_is_class ?
         Class::IsInFullSnapshot(reinterpret_cast<RawClass*>(ptr()->owner_)) :
         PatchClass::IsInFullSnapshot(
             reinterpret_cast<RawPatchClass*>(ptr()->owner_));
   }
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kFunctionCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the boolean is_in_fullsnapshot first as this will
   // help the reader decide how the rest of the information needs
   // to be interpreted.
   writer->Write<bool>(is_in_fullsnapshot);
 
-  if (Snapshot::IsFull(kind) || !is_in_fullsnapshot) {
+  if (!is_in_fullsnapshot) {
     bool is_optimized = Code::IsOptimized(ptr()->code_);
 
     // Write out all the non object fields.
     writer->Write<int32_t>(ptr()->token_pos_.SnapshotEncode());
     writer->Write<int32_t>(ptr()->end_token_pos_.SnapshotEncode());
     writer->Write<int16_t>(ptr()->num_fixed_parameters_);
     writer->Write<int16_t>(ptr()->num_optional_parameters_);
     writer->Write<uint32_t>(ptr()->kind_tag_);
-    if (kind == Snapshot::kAppNoJIT) {
-      // Omit fields used to support de/reoptimization.
+    if (is_optimized) {
+      writer->Write<int32_t>(FLAG_optimization_counter_threshold);
     } else {
-      if (is_optimized) {
-        writer->Write<int32_t>(FLAG_optimization_counter_threshold);
-      } else {
-        writer->Write<int32_t>(0);
-      }
-      writer->Write<int8_t>(ptr()->deoptimization_counter_);
-      writer->Write<uint16_t>(ptr()->optimized_instruction_count_);
-      writer->Write<uint16_t>(ptr()->optimized_call_site_count_);
+      writer->Write<int32_t>(0);
     }
+    writer->Write<int8_t>(ptr()->deoptimization_counter_);
+    writer->Write<uint16_t>(ptr()->optimized_instruction_count_);
+    writer->Write<uint16_t>(ptr()->optimized_call_site_count_);
 
     // Write out all the object pointer fields.
     SnapshotWriterVisitor visitor(writer, kAsReference);
     visitor.VisitPointers(from(), to_snapshot());
-    if (kind == Snapshot::kAppNoJIT) {
-      ASSERT(ptr()->ic_data_array_ == Array::null());
-      ASSERT((ptr()->code_ == ptr()->unoptimized_code_) ||
-             (ptr()->unoptimized_code_ == Code::null()));
-      writer->WriteObjectImpl(ptr()->code_, kAsInlinedObject);
-    } else if (kind == Snapshot::kAppWithJIT) {
-      writer->WriteObjectImpl(ptr()->ic_data_array_, kAsReference);
-      writer->WriteObjectImpl(ptr()->unoptimized_code_, kAsInlinedObject);
-    } else if (is_optimized) {
+    if (is_optimized) {
       // Write out the ic data array as the function is optimized.
       writer->WriteObjectImpl(ptr()->ic_data_array_, kAsReference);
     }
   } else {
     writer->WriteFunctionId(this, owner_is_class);
   }
 }
 
 
 RawField* Field::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind,
                           bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Allocate field object.
-  Field& field = Field::ZoneHandle(reader->zone(), NEW_OBJECT(Field));
+  Field& field = Field::ZoneHandle(reader->zone(), Field::New());
   reader->AddBackRef(object_id, &field, kIsDeserialized);
 
   // Set all non object fields.
-  if (kind == Snapshot::kAppNoJIT) {
-    field.set_token_pos(TokenPosition::kNoSource);
-    ASSERT(!FLAG_use_field_guards);
-  } else {
-    field.set_token_pos(
-        TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
-    field.set_guarded_cid(reader->Read<int32_t>());
-    field.set_is_nullable(reader->Read<int32_t>());
-  }
+  field.set_token_pos(
+      TokenPosition::SnapshotDecode(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>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(field,
                      field.raw()->from(),
                      field.raw()->to_snapshot(kind),
                      kAsReference);
   field.StorePointer(&field.raw_ptr()->dependent_code_, Array::null());
 
   if (!FLAG_use_field_guards) {
     field.set_guarded_cid(kDynamicCid);
     field.set_is_nullable(true);
     field.set_guarded_list_length(Field::kNoFixedLength);
     field.set_guarded_list_length_in_object_offset(Field::kUnknownLengthOffset);
   } else {
     field.InitializeGuardedListLengthInObjectOffset();
   }
 
   return field.raw();
 }
 
 
 void RawField::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind,
                        bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kFieldCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
-  if (kind != Snapshot::kAppNoJIT) {
-    writer->Write<int32_t>(ptr()->token_pos_.SnapshotEncode());
-    writer->Write<int32_t>(ptr()->guarded_cid_);
-    writer->Write<int32_t>(ptr()->is_nullable_);
-  }
+  writer->Write<int32_t>(ptr()->token_pos_.SnapshotEncode());
+  writer->Write<int32_t>(ptr()->guarded_cid_);
+  writer->Write<int32_t>(ptr()->is_nullable_);
   writer->Write<uint8_t>(ptr()->kind_bits_);
 
   // Write out the name.
   writer->WriteObjectImpl(ptr()->name_, kAsReference);
   // Write out the owner.
   writer->WriteObjectImpl(ptr()->owner_, kAsReference);
   // Write out the type.
   writer->WriteObjectImpl(ptr()->type_, kAsReference);
   // Write out the initial static value or field offset.
   if (Field::StaticBit::decode(ptr()->kind_bits_)) {
-    if (kind == Snapshot::kAppNoJIT) {
-      // For precompiled static fields, the value was already reset and
-      // initializer_ now contains a Function.
-      writer->WriteObjectImpl(ptr()->value_.static_value_, kAsReference);
-    } else if (Field::ConstBit::decode(ptr()->kind_bits_)) {
+    if (Field::ConstBit::decode(ptr()->kind_bits_)) {
       // Do not reset const fields.
       writer->WriteObjectImpl(ptr()->value_.static_value_, kAsReference);
     } else {
       // Otherwise, for static fields we write out the initial static value.
       writer->WriteObjectImpl(ptr()->initializer_.saved_value_, kAsReference);
     }
   } else {
     writer->WriteObjectImpl(ptr()->value_.offset_, kAsReference);
   }
   // Write out the initializer function or saved initial value.
-  if (kind == Snapshot::kAppNoJIT) {
-    writer->WriteObjectImpl(ptr()->initializer_.precompiled_, kAsReference);
-  } else {
-    writer->WriteObjectImpl(ptr()->initializer_.saved_value_, kAsReference);
-  }
-  if (kind != Snapshot::kAppNoJIT) {
-    // Write out the guarded list length.
-    writer->WriteObjectImpl(ptr()->guarded_list_length_, kAsReference);
-  }
+  writer->WriteObjectImpl(ptr()->initializer_.saved_value_, kAsReference);
+  // Write out the guarded list length.
+  writer->WriteObjectImpl(ptr()->guarded_list_length_, kAsReference);
 }
 
 
 RawLiteralToken* LiteralToken::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind,
                                         bool as_reference) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
   // Create the literal token object.
-  LiteralToken& literal_token = LiteralToken::ZoneHandle(
-      reader->zone(), NEW_OBJECT(LiteralToken));
+  LiteralToken& literal_token = LiteralToken::ZoneHandle(reader->zone(),
+                                                         LiteralToken::New());
   reader->AddBackRef(object_id, &literal_token, kIsDeserialized);
 
   // 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.
   READ_OBJECT_FIELDS(literal_token,
                      literal_token.raw()->from(), literal_token.raw()->to(),
                      kAsReference);
@@ skipping 24 matching lines @@
   visitor.VisitPointers(from(), to());
 }
 
 
 RawTokenStream* TokenStream::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind,
                                       bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // 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->zone(), NEW_OBJECT_WITH_LEN(TokenStream, len));
+  TokenStream& token_stream = TokenStream::ZoneHandle(reader->zone(),
+                                                      TokenStream::New(len));
   reader->AddBackRef(object_id, &token_stream, kIsDeserialized);
 
   // Read the stream of tokens into the TokenStream object for script
   // snapshots as we made a copy of token stream.
   if (kind == Snapshot::kScript) {
     NoSafepointScope no_safepoint;
     RawExternalTypedData* stream = token_stream.GetStream();
     reader->ReadBytes(stream->ptr()->data_, len);
   }
 
   // Read in the literal/identifier token array.
   *(reader->TokensHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
   token_stream.SetTokenObjects(*(reader->TokensHandle()));
   // Read in the private key in use by the token stream.
   *(reader->StringHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
   token_stream.SetPrivateKey(*(reader->StringHandle()));
 
   return token_stream.raw();
 }
 
 
 void RawTokenStream::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind,
                              bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kTokenStreamCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the length field and the token stream.
   RawExternalTypedData* stream = ptr()->stream_;
   intptr_t len = Smi::Value(stream->ptr()->length_);
   writer->Write<RawObject*>(stream->ptr()->length_);
   writer->WriteBytes(stream->ptr()->data_, len);
 
   // Write out the literal/identifier token array.
   writer->WriteObjectImpl(ptr()->token_objects_, kAsInlinedObject);
   // Write out the private key in use by the token stream.
   writer->WriteObjectImpl(ptr()->private_key_, kAsInlinedObject);
 }
 
 
 RawScript* Script::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind,
                             bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Allocate script object.
-  Script& script = Script::ZoneHandle(reader->zone(), NEW_OBJECT(Script));
+  Script& script = Script::ZoneHandle(reader->zone(), Script::New());
   reader->AddBackRef(object_id, &script, kIsDeserialized);
 
   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_,
                          reader->Read<int8_t>());
 
   *reader->StringHandle() ^= String::null();
@@ skipping 17 matching lines @@
   return script.raw();
 }
 
 
 void RawScript::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind,
                         bool as_reference) {
   ASSERT(writer != NULL);
   ASSERT(tokens_ != TokenStream::null());
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kScriptCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->Write<int32_t>(ptr()->line_offset_);
@@ skipping 18 matching lines @@
   reader->AddBackRef(object_id, &library, kIsDeserialized);
 
   bool is_in_fullsnapshot = reader->Read<bool>();
   if ((kind == Snapshot::kScript) && is_in_fullsnapshot) {
     // Lookup the object as it should already exist in the heap.
     *reader->StringHandle() ^= reader->ReadObjectImpl(kAsInlinedObject);
     library = Library::LookupLibrary(reader->thread(), *reader->StringHandle());
     ASSERT(library.is_in_fullsnapshot());
   } else {
     // Allocate library object.
-    library = NEW_OBJECT(Library);
+    library = Library::New();
 
     // Set all non object fields.
     library.StoreNonPointer(&library.raw_ptr()->index_,
                             reader->ReadClassIDValue());
     library.StoreNonPointer(&library.raw_ptr()->num_imports_,
                             reader->Read<uint16_t>());
     library.StoreNonPointer(&library.raw_ptr()->load_state_,
                             reader->Read<int8_t>());
     library.StoreNonPointer(&library.raw_ptr()->corelib_imported_,
                             reader->Read<bool>());
     library.StoreNonPointer(&library.raw_ptr()->is_dart_scheme_,
                             reader->Read<bool>());
     library.StoreNonPointer(&library.raw_ptr()->debuggable_,
                             reader->Read<bool>());
-    if (Snapshot::IsFull(kind)) {
-      is_in_fullsnapshot = true;
-    }
     library.StoreNonPointer(&library.raw_ptr()->is_in_fullsnapshot_,
                             is_in_fullsnapshot);
     // The native resolver and symbolizer are not serialized.
     library.set_native_entry_resolver(NULL);
     library.set_native_entry_symbol_resolver(NULL);
 
     // Set all the object fields.
     // TODO(5411462): Need to assert No GC can happen here, even though
     // allocations may happen.
     intptr_t num_flds = (library.raw()->to_snapshot() - library.raw()->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
       (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
       library.StorePointer((library.raw()->from() + i),
                            reader->PassiveObjectHandle()->raw());
     }
     // Initialize cache of resolved names.
     const intptr_t kInitialNameCacheSize = 64;
-    if (!Snapshot::IsFull(kind)) {
-      // The cache of resolved names in library scope is not serialized.
-      library.InitResolvedNamesCache(kInitialNameCacheSize);
-      library.Register(reader->thread());
-    } else {
-      library.InitResolvedNamesCache(kInitialNameCacheSize, reader);
-    }
+    // The cache of resolved names in library scope is not serialized.
+    library.InitResolvedNamesCache(kInitialNameCacheSize);
+    library.Register(reader->thread());
     library.StorePointer(&library.raw_ptr()->exported_names_, Array::null());
     // Initialize cache of loaded scripts.
     library.StorePointer(&library.raw_ptr()->loaded_scripts_, Array::null());
   }
   return library.raw();
 }
 
 
 void RawLibrary::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
@@ skipping 11 matching lines @@
 
   // Write out the boolean is_in_fullsnapshot_ first as this will
   // help the reader decide how the rest of the information needs
   // to be interpreted.
   writer->Write<bool>(ptr()->is_in_fullsnapshot_);
 
   if ((kind == Snapshot::kScript) && ptr()->is_in_fullsnapshot_) {
     // Write out library URL so that it can be looked up when reading.
     writer->WriteObjectImpl(ptr()->url_, kAsInlinedObject);
   } else {
-    ASSERT((Snapshot::IsFull(kind)) || !ptr()->is_in_fullsnapshot_);
+    ASSERT(!ptr()->is_in_fullsnapshot_);
     // Write out all non object fields.
     ASSERT(ptr()->index_ != static_cast<classid_t>(-1));
     writer->WriteClassIDValue(ptr()->index_);
     writer->Write<uint16_t>(ptr()->num_imports_);
     writer->Write<int8_t>(ptr()->load_state_);
     writer->Write<bool>(ptr()->corelib_imported_);
     writer->Write<bool>(ptr()->is_dart_scheme_);
     writer->Write<bool>(ptr()->debuggable_);
     // We do not serialize the native resolver or symbolizer. These need to be
     // explicitly set after deserialization.
 
     // We do not write the loaded_scripts_ and resolved_names_ caches to the
     // snapshot. They get initialized when reading the library from the
     // snapshot and will be rebuilt lazily.
     // Write out all the object pointer fields.
     SnapshotWriterVisitor visitor(writer, kAsReference);
     visitor.VisitPointers(from(), to_snapshot());
   }
 }
 
 
 RawLibraryPrefix* LibraryPrefix::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Allocate library prefix object.
-  LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(
-      reader->zone(), NEW_OBJECT(LibraryPrefix));
+  LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(reader->zone(),
+                                                    LibraryPrefix::New());
   reader->AddBackRef(object_id, &prefix, kIsDeserialized);
 
   // Set all non object fields.
   prefix.StoreNonPointer(&prefix.raw_ptr()->num_imports_,
                          reader->Read<int16_t>());
   prefix.StoreNonPointer(&prefix.raw_ptr()->is_deferred_load_,
                          reader->Read<bool>());
   prefix.StoreNonPointer(&prefix.raw_ptr()->is_loaded_, reader->Read<bool>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(prefix,
                      prefix.raw()->from(),
                      prefix.raw()->to_snapshot(kind),
                      kAsReference);
-  if (kind == Snapshot::kAppNoJIT) {
-    prefix.StorePointer(&prefix.raw_ptr()->imports_,
-                        Object::empty_array().raw());
-  }
   prefix.StorePointer(&prefix.raw_ptr()->dependent_code_,
                       Array::null());
 
   return prefix.raw();
 }
 
 
 void RawLibraryPrefix::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kLibraryPrefixCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all non object fields.
   writer->Write<int16_t>(ptr()->num_imports_);
   writer->Write<bool>(ptr()->is_deferred_load_);
   writer->Write<bool>(ptr()->is_loaded_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
   visitor.VisitPointers(from(), to_snapshot(kind));
 }
 
 
 RawNamespace* Namespace::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind,
                                   bool as_reference) {
   ASSERT(reader != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Allocate Namespace object.
-  Namespace& ns = Namespace::ZoneHandle(
-      reader->zone(), NEW_OBJECT(Namespace));
+  Namespace& ns = Namespace::ZoneHandle(reader->zone(), Namespace::New());
   reader->AddBackRef(object_id, &ns, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(ns, ns.raw()->from(), ns.raw()->to(), kAsReference);
 
   return ns.raw();
 }
 
 
 void RawNamespace::WriteTo(SnapshotWriter* writer,
                            intptr_t object_id,
                            Snapshot::Kind kind,
                            bool as_reference) {
   ASSERT(writer != NULL);
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kNamespaceCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, kAsReference);
@@ skipping 152 matching lines @@
                               bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate context object.
   int32_t num_vars = reader->Read<int32_t>();
   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);
+    context ^= Context::New(num_vars);
 
     // Set all the object fields.
     // TODO(5411462): Need to assert No GC can happen here, even though
     // allocations may happen.
     intptr_t num_flds = (context.raw()->to(num_vars) - context.raw()->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
       (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
       context.StorePointer((context.raw()->from() + i),
                            reader->PassiveObjectHandle()->raw());
     }
@@ skipping 30 matching lines @@
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind,
                                         bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate context object.
   bool is_implicit = reader->Read<bool>();
   if (is_implicit) {
     ContextScope& context_scope = ContextScope::ZoneHandle(reader->zone());
-    if (Snapshot::IsFull(kind)) {
-      context_scope = reader->NewContextScope(1);
-      context_scope.set_is_implicit(true);
-    } else {
-      context_scope = ContextScope::New(1, true);
-    }
+    context_scope = ContextScope::New(1, true);
     reader->AddBackRef(object_id, &context_scope, kIsDeserialized);
 
     *reader->TypeHandle() ^= reader->ReadObjectImpl(kAsInlinedObject);
 
     // Create a descriptor for 'this' variable.
     context_scope.SetTokenIndexAt(0, TokenPosition::kMinSource);
     context_scope.SetNameAt(0, Symbols::This());
     context_scope.SetIsFinalAt(0, true);
     context_scope.SetIsConstAt(0, false);
     context_scope.SetTypeAt(0, *reader->TypeHandle());
     context_scope.SetContextIndexAt(0, 0);
     context_scope.SetContextLevelAt(0, 0);
     return context_scope.raw();
-  } else if (kind == Snapshot::kAppWithJIT) {
-    int32_t num_vars = reader->Read<int32_t>();
-
-    ContextScope& context_scope = ContextScope::ZoneHandle(reader->zone());
-    context_scope = reader->NewContextScope(num_vars);
-    context_scope.set_is_implicit(false);
-    reader->AddBackRef(object_id, &context_scope, kIsDeserialized);
-
-    READ_OBJECT_FIELDS(context_scope,
-                       context_scope.raw()->from(),
-                       context_scope.raw()->to(num_vars),
-                       kAsInlinedObject);
-    return context_scope.raw();
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 void RawContextScope::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind,
                               bool as_reference) {
@@ skipping 10 matching lines @@
     writer->WriteVMIsolateObject(kContextScopeCid);
     writer->WriteTags(writer->GetObjectTags(this));
 
     // Write out is_implicit flag for the context scope.
     writer->Write<bool>(true);
 
     // Write out the type of 'this' the variable.
     writer->WriteObjectImpl(var->type, kAsInlinedObject);
 
     return;
-  } else if (kind == Snapshot::kAppWithJIT) {
-    // Write out the serialization header value for this object.
-    writer->WriteInlinedObjectHeader(object_id);
-
-    // Write out the class and tags information.
-    writer->WriteVMIsolateObject(kContextScopeCid);
-    writer->WriteTags(writer->GetObjectTags(this));
-
-    // Write out is_implicit flag for the context scope.
-    writer->Write<bool>(false);
-    int32_t num_vars = ptr()->num_variables_;
-    writer->Write<int32_t>(num_vars);
-
-    SnapshotWriterVisitor visitor(writer, kAsInlinedObject);
-    visitor.VisitPointers(from(), to(num_vars));
-
-    return;
   }
   UNREACHABLE();
 }
 
 
 RawICData* ICData::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind,
                             bool as_reference) {
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
-  ICData& result = ICData::ZoneHandle(reader->zone(), NEW_OBJECT(ICData));
+  ICData& result = ICData::ZoneHandle(reader->zone(), ICData::New());
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   result.set_deopt_id(reader->Read<int32_t>());
   result.set_state_bits(reader->Read<uint32_t>());
 #if defined(TAG_IC_DATA)
   result.set_tag(reader->Read<int16_t>());
 #endif
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(result,
                      result.raw()->from(),
                      result.raw()->to_snapshot(kind),
                      kAsReference);
-  if (kind == Snapshot::kAppNoJIT) {
-    result.set_owner(Function::Handle(reader->zone()));
-  }
 
   return result.raw();
 }
 
 
 void RawICData::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind,
                         bool as_reference) {
-  ASSERT((kind == Snapshot::kScript) || (Snapshot::IsFull(kind)));
+  ASSERT(kind == Snapshot::kScript);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kICDataCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->Write<int32_t>(ptr()->deopt_id_);
@@ skipping 66 matching lines @@
 
 RawApiError* ApiError::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate ApiError object.
   ApiError& api_error =
-      ApiError::ZoneHandle(reader->zone(), NEW_OBJECT(ApiError));
+      ApiError::ZoneHandle(reader->zone(), ApiError::New());
   reader->AddBackRef(object_id, &api_error, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(api_error,
                      api_error.raw()->from(), api_error.raw()->to(),
                      kAsReference);
 
   return api_error.raw();
 }
 
@@ skipping 19 matching lines @@
 
 RawLanguageError* LanguageError::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate LanguageError object.
   LanguageError& language_error =
-      LanguageError::ZoneHandle(reader->zone(), NEW_OBJECT(LanguageError));
+      LanguageError::ZoneHandle(reader->zone(), LanguageError::New());
   reader->AddBackRef(object_id, &language_error, kIsDeserialized);
 
   // Set all non object fields.
   language_error.set_token_pos(
       TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
   language_error.set_report_after_token(reader->Read<bool>());
   language_error.set_kind(reader->Read<uint8_t>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(language_error,
@@ skipping 27 matching lines @@
   visitor.VisitPointers(from(), to());
 }
 
 
 RawUnhandledException* UnhandledException::ReadFrom(SnapshotReader* reader,
                                                     intptr_t object_id,
                                                     intptr_t tags,
                                                     Snapshot::Kind kind,
                                                     bool as_reference) {
   UnhandledException& result = UnhandledException::ZoneHandle(
-      reader->zone(), NEW_OBJECT(UnhandledException));
+      reader->zone(), UnhandledException::New());
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(result,
                      result.raw()->from(), result.raw()->to(),
                      kAsReference);
 
   return result.raw();
 }
 
@@ skipping 35 matching lines @@
 RawInstance* Instance::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
   ASSERT(reader != NULL);
 
   // Create an Instance object or get canonical one if it is a canonical
   // constant.
   Instance& obj = Instance::ZoneHandle(reader->zone(), Instance::null());
-  if (Snapshot::IsFull(kind)) {
-    obj = reader->NewInstance();
-    // Set the canonical bit.
-    if (RawObject::IsCanonical(tags)) {
-      obj.SetCanonical();
-    }
-  } else {
-    obj ^= Object::Allocate(kInstanceCid,
-                            Instance::InstanceSize(),
-                            HEAP_SPACE(kind));
-    if (RawObject::IsCanonical(tags)) {
-      obj = obj.CheckAndCanonicalize(reader->thread(), NULL);
-    }
+  obj ^= Object::Allocate(kInstanceCid,
+                          Instance::InstanceSize(),
+                          HEAP_SPACE(kind));
+  if (RawObject::IsCanonical(tags)) {
+    obj = obj.CheckAndCanonicalize(reader->thread(), NULL);
   }
   reader->AddBackRef(object_id, &obj, kIsDeserialized);
 
   return obj.raw();
 }
 
 
 void RawInstance::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind,
@@ skipping 23 matching lines @@
   // architecture, if so return the object as a Smi.
   if (Smi::IsValid(value)) {
     Smi& smi = Smi::ZoneHandle(reader->zone(),
                                Smi::New(static_cast<intptr_t>(value)));
     reader->AddBackRef(object_id, &smi, kIsDeserialized);
     return smi.raw();
   }
 
   // Create a Mint object or get canonical one if it is a canonical constant.
   Mint& mint = Mint::ZoneHandle(reader->zone(), Mint::null());
-  if (Snapshot::IsFull(kind)) {
-    mint = reader->NewMint(value);
-    // Set the canonical bit.
-    if (RawObject::IsCanonical(tags)) {
-      mint.SetCanonical();
-    }
+  // 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)) {
+    mint = Mint::NewCanonical(value);
+    ASSERT(mint.IsCanonical());
   } 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)) {
-      mint = Mint::NewCanonical(value);
-      ASSERT(mint.IsCanonical());
-    } else {
-      mint = Mint::New(value, HEAP_SPACE(kind));
-    }
+    mint = Mint::New(value, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &mint, kIsDeserialized);
   return mint.raw();
 }
 
 
 void RawMint::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind,
                       bool as_reference) {
@@ skipping 12 matching lines @@
 
 
 RawBigint* Bigint::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind,
                             bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate bigint object.
-  Bigint& obj = Bigint::ZoneHandle(reader->zone(), NEW_OBJECT(Bigint));
+  Bigint& obj = Bigint::ZoneHandle(reader->zone(), Bigint::New());
   reader->AddBackRef(object_id, &obj, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(obj, obj.raw()->from(), obj.raw()->to(), kAsInlinedObject);
 
   // If it is a canonical constant make it one.
   // When reading a full snapshot we don't need to canonicalize the object
   // as it would already be a canonical object.
   // When reading a script snapshot or a message snapshot we always have
   // to canonicalize the object.
   if (RawObject::IsCanonical(tags)) {
-    if (Snapshot::IsFull(kind)) {
-      // Set the canonical bit.
-      obj.SetCanonical();
-    } else {
-      obj ^= obj.CheckAndCanonicalize(reader->thread(), NULL);
-      ASSERT(!obj.IsNull());
-      ASSERT(obj.IsCanonical());
-    }
+    obj ^= obj.CheckAndCanonicalize(reader->thread(), NULL);
+    ASSERT(!obj.IsNull());
+    ASSERT(obj.IsCanonical());
   }
   return obj.raw();
 }
 
 
 void RawBigint::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind,
                         bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 16 matching lines @@
                             intptr_t tags,
                             Snapshot::Kind kind,
                             bool as_reference) {
   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->zone(), Double::null());
-  if (Snapshot::IsFull(kind)) {
-    dbl = reader->NewDouble(value);
-    // Set the canonical bit.
-    if (RawObject::IsCanonical(tags)) {
-      dbl.SetCanonical();
-    }
+  // 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)) {
+    dbl = Double::NewCanonical(value);
+    ASSERT(dbl.IsCanonical());
   } 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)) {
-      dbl = Double::NewCanonical(value);
-      ASSERT(dbl.IsCanonical());
-    } else {
-      dbl = Double::New(value, HEAP_SPACE(kind));
-    }
+    dbl = Double::New(value, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &dbl, kIsDeserialized);
   return dbl.raw();
 }
 
 
 void RawDouble::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind,
                         bool as_reference) {
@@ skipping 63 matching lines @@
 
 
 RawOneByteString* OneByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   // 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::ZoneHandle(reader->zone(), String::null());
 
-  if (Snapshot::IsFull(kind)) {
-    // We currently only expect the Dart mutator to read snapshots.
-    reader->isolate()->AssertCurrentThreadIsMutator();
-    ASSERT(Thread::Current()->no_safepoint_scope_depth() != 0);
-    RawOneByteString* obj = reader->NewOneByteString(len);
-    str_obj = obj;
-    if (RawObject::IsCanonical(tags)) {
-      str_obj.SetCanonical();
-    }
-    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);
-  }
+  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,
                                           bool as_reference) {
   // 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::ZoneHandle(reader->zone(), String::null());
 
-  if (Snapshot::IsFull(kind)) {
-    RawTwoByteString* obj = reader->NewTwoByteString(len);
-    str_obj = obj;
-    if (RawObject::IsCanonical(tags)) {
-      str_obj.SetCanonical();
-    }
-    str_obj.SetHash(hash);
-    NoSafepointScope no_safepoint;
-    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.
-      *raw_ptr = reader->Read<uint16_t>();
-      raw_ptr += 1;
-    }
-    ASSERT(String::Hash(str_obj, 0, str_obj.Length()) == hash);
-  } else {
-    String::ReadFromImpl<TwoByteString, uint16_t>(
-        reader, &str_obj, len, tags, Symbols::FromUTF16, kind);
-  }
+  String::ReadFromImpl<TwoByteString, uint16_t>(
+      reader, &str_obj, len, tags, Symbols::FromUTF16, kind);
   reader->AddBackRef(object_id, &str_obj, kIsDeserialized);
   return raw(str_obj);
 }
 
 
 template<typename T>
 static void StringWriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind,
                           intptr_t class_id,
                           intptr_t tags,
                           RawSmi* length,
-                          RawSmi* hash,
                           T* data) {
   ASSERT(writer != NULL);
   intptr_t len = Smi::Value(length);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(class_id);
   writer->WriteTags(tags);
 
   // Write out the length field.
   writer->Write<RawObject*>(length);
 
-  // Write out the hash field.
-  writer->Write<RawObject*>(hash);
-
   // Write out the string.
   if (len > 0) {
     if (class_id == kOneByteStringCid) {
       writer->WriteBytes(reinterpret_cast<const uint8_t*>(data), len);
     } else {
       for (intptr_t i = 0; i < len; i++) {
         writer->Write(data[i]);
       }
     }
   }
 }
 
 
 void RawOneByteString::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
   StringWriteTo(writer,
                 object_id,
                 kind,
                 kOneByteStringCid,
                 writer->GetObjectTags(this),
                 ptr()->length_,
-                ptr()->hash_,
                 ptr()->data());
 }
 
 
 void RawTwoByteString::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
   StringWriteTo(writer,
                 object_id,
                 kind,
                 kTwoByteStringCid,
                 writer->GetObjectTags(this),
                 ptr()->length_,
-                ptr()->hash_,
                 ptr()->data());
 }
 
 
 RawExternalOneByteString* ExternalOneByteString::ReadFrom(
     SnapshotReader* reader,
     intptr_t object_id,
     intptr_t tags,
     Snapshot::Kind kind,
     bool as_reference) {
@@ skipping 17 matching lines @@
                                        intptr_t object_id,
                                        Snapshot::Kind kind,
                                        bool as_reference) {
   // Serialize as a non-external one byte string.
   StringWriteTo(writer,
                 object_id,
                 kind,
                 kOneByteStringCid,
                 writer->GetObjectTags(this),
                 ptr()->length_,
-                ptr()->hash_,
                 ptr()->external_data_->data());
 }
 
 
 void RawExternalTwoByteString::WriteTo(SnapshotWriter* writer,
                                        intptr_t object_id,
                                        Snapshot::Kind kind,
                                        bool as_reference) {
   // Serialize as a non-external two byte string.
   StringWriteTo(writer,
                 object_id,
                 kind,
                 kTwoByteStringCid,
                 writer->GetObjectTags(this),
                 ptr()->length_,
-                ptr()->hash_,
                 ptr()->external_data_->data());
 }
 
 
 RawBool* Bool::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind,
                         bool as_reference) {
   UNREACHABLE();
@@ skipping 21 matching lines @@
   Array* array = NULL;
   DeserializeState state;
   if (!as_reference) {
     array = reinterpret_cast<Array*>(reader->GetBackRef(object_id));
     state = kIsDeserialized;
   } else {
     state = kIsNotDeserialized;
   }
   if (array == NULL) {
     array = &(Array::ZoneHandle(reader->zone(),
-                                NEW_OBJECT_WITH_LEN_SPACE(Array, len, kind)));
+                                Array::New(len, HEAP_SPACE(kind))));
     reader->AddBackRef(object_id, array, state);
   }
   if (!as_reference) {
     // Read all the individual elements for inlined objects.
     ASSERT(!RawObject::IsCanonical(tags));
     reader->ArrayReadFrom(object_id, *array, len, tags);
   }
   return array->raw();
 }
 
@@ skipping 11 matching lines @@
   DeserializeState state;
   if (!as_reference) {
     array = reinterpret_cast<Array*>(reader->GetBackRef(object_id));
     state = kIsDeserialized;
   } else {
     state = kIsNotDeserialized;
   }
   if (array == NULL) {
     array = &(Array::ZoneHandle(
         reader->zone(),
-        NEW_OBJECT_WITH_LEN_SPACE(ImmutableArray, len, kind)));
+        ImmutableArray::New(len, HEAP_SPACE(kind))));
     reader->AddBackRef(object_id, array, state);
   }
   if (!as_reference) {
     // Read all the individual elements for inlined objects.
     reader->ArrayReadFrom(object_id, *array, len, tags);
     if (RawObject::IsCanonical(tags)) {
-      if (Snapshot::IsFull(kind)) {
-        array->SetCanonical();
-      } else {
-        *array ^= array->CheckAndCanonicalize(reader->thread(), NULL);
-      }
+      *array ^= array->CheckAndCanonicalize(reader->thread(), NULL);
     }
   }
   return raw(*array);
 }
 
 
 void RawArray::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind,
                        bool as_reference) {
@@ skipping 25 matching lines @@
 RawGrowableObjectArray* GrowableObjectArray::ReadFrom(SnapshotReader* reader,
                                                       intptr_t object_id,
                                                       intptr_t tags,
                                                       Snapshot::Kind kind,
                                                       bool as_reference) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   GrowableObjectArray& array = GrowableObjectArray::ZoneHandle(
       reader->zone(), GrowableObjectArray::null());
-  if (Snapshot::IsFull(kind)) {
-    array = reader->NewGrowableObjectArray();
-  } else {
-    array = GrowableObjectArray::New(0, HEAP_SPACE(kind));
-  }
+  array = GrowableObjectArray::New(0, HEAP_SPACE(kind));
   reader->AddBackRef(object_id, &array, kIsDeserialized);
 
   // Read type arguments of growable array object.
   const intptr_t typeargs_offset =
       GrowableObjectArray::type_arguments_offset() / kWordSize;
   *reader->TypeArgumentsHandle() ^=
       reader->ReadObjectImpl(kAsInlinedObject, object_id, typeargs_offset);
   array.StorePointer(&array.raw_ptr()->type_arguments_,
                      reader->TypeArgumentsHandle()->raw());
 
@@ skipping 34 matching lines @@
 
 RawLinkedHashMap* LinkedHashMap::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   ASSERT(reader != NULL);
 
   LinkedHashMap& map = LinkedHashMap::ZoneHandle(
       reader->zone(), LinkedHashMap::null());
-  if (Snapshot::IsFull(kind) || kind == Snapshot::kScript) {
+  if (kind == Snapshot::kScript) {
     // The immutable maps that seed map literals are not yet VM-internal, so
     // we don't reach this.
     UNREACHABLE();
   } else {
     // Since the map might contain itself as a key or value, allocate first.
-    if (Snapshot::IsFull(kind)) {
-      map = reader->NewLinkedHashMap();
-    } else {
-      map = LinkedHashMap::NewUninitialized(HEAP_SPACE(kind));
-    }
+    map = LinkedHashMap::NewUninitialized(HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &map, kIsDeserialized);
 
   // Read the type arguments.
   const intptr_t typeargs_offset =
       GrowableObjectArray::type_arguments_offset() / kWordSize;
   *reader->TypeArgumentsHandle() ^=
       reader->ReadObjectImpl(kAsInlinedObject, object_id, typeargs_offset);
   map.SetTypeArguments(*reader->TypeArgumentsHandle());
 
   // Read the number of key/value pairs.
   intptr_t len = reader->ReadSmiValue();
   intptr_t used_data = (len << 1);
   map.SetUsedData(used_data);
 
   // Allocate the data array.
   intptr_t data_size = Utils::Maximum(
       Utils::RoundUpToPowerOfTwo(used_data),
       static_cast<uintptr_t>(LinkedHashMap::kInitialIndexSize));
   Array& data = Array::ZoneHandle(reader->zone(),
-                                  NEW_OBJECT_WITH_LEN_SPACE(Array,
-                                                            data_size,
-                                                            kind));
+                                  Array::New(data_size, HEAP_SPACE(kind)));
   map.SetData(data);
   map.SetDeletedKeys(0);
 
   // The index and hashMask is regenerated by the maps themselves on demand.
   // Thus, the index will probably be allocated in new space (unless it's huge).
   // TODO(koda): Eagerly rehash here when no keys have user-defined '==', and
   // in particular, if/when (const) maps are needed in the VM isolate snapshot.
   ASSERT(reader->isolate() != Dart::vm_isolate());
   map.SetHashMask(0);  // Prefer sentinel 0 over null for better type feedback.
 
   // Read the keys and values.
   bool read_as_reference = RawObject::IsCanonical(tags) ? false : true;
   for (intptr_t i = 0; i < used_data; i++) {
     *reader->PassiveObjectHandle() = reader->ReadObjectImpl(read_as_reference);
     data.SetAt(i, *reader->PassiveObjectHandle());
   }
   return map.raw();
 }
 
 
 void RawLinkedHashMap::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
-  if (Snapshot::IsFull(kind) || kind == Snapshot::kScript) {
+  if (kind == Snapshot::kScript) {
     // The immutable maps that seed map literals are not yet VM-internal, so
     // we don't reach this.
   }
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kLinkedHashMapCid);
@@ skipping 41 matching lines @@
   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->zone(),
                                           Float32x4::null());
-  if (Snapshot::IsFull(kind)) {
-    simd = reader->NewFloat32x4(value0, value1, value2, value3);
-  } else {
-    simd = Float32x4::New(value0, value1, value2, value3, HEAP_SPACE(kind));
-  }
+  simd = Float32x4::New(value0, value1, value2, value3, HEAP_SPACE(kind));
   reader->AddBackRef(object_id, &simd, kIsDeserialized);
   return simd.raw();
 }
 
 
 void RawFloat32x4::WriteTo(SnapshotWriter* writer,
                            intptr_t object_id,
                            Snapshot::Kind kind,
                            bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 20 matching lines @@
                               bool as_reference) {
   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->zone(), Int32x4::null());
-
-  if (Snapshot::IsFull(kind)) {
-    simd = reader->NewInt32x4(value0, value1, value2, value3);
-  } else {
-    simd = Int32x4::New(value0, value1, value2, value3, HEAP_SPACE(kind));
-  }
+  simd = Int32x4::New(value0, value1, value2, value3, HEAP_SPACE(kind));
   reader->AddBackRef(object_id, &simd, kIsDeserialized);
   return simd.raw();
 }
 
 
 void RawInt32x4::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind,
                          bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 19 matching lines @@
                                   Snapshot::Kind kind,
                                   bool as_reference) {
   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->zone(),
                                           Float64x2::null());
-  if (Snapshot::IsFull(kind)) {
-    simd = reader->NewFloat64x2(value0, value1);
-  } else {
-    simd = Float64x2::New(value0, value1, HEAP_SPACE(kind));
-  }
+  simd = Float64x2::New(value0, value1, HEAP_SPACE(kind));
   reader->AddBackRef(object_id, &simd, kIsDeserialized);
   return simd.raw();
 }
 
 
 void RawFloat64x2::WriteTo(SnapshotWriter* writer,
                            intptr_t object_id,
                            Snapshot::Kind kind,
                            bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 19 matching lines @@
 
 RawTypedData* TypedData::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind,
                                   bool as_reference) {
   ASSERT(reader != NULL);
 
   intptr_t cid = RawObject::ClassIdTag::decode(tags);
   intptr_t len = reader->ReadSmiValue();
-  TypedData& result = TypedData::ZoneHandle(reader->zone(),
-      (Snapshot::IsFull(kind)) ? reader->NewTypedData(cid, len)
-                                : TypedData::New(cid, len, HEAP_SPACE(kind)));
+  TypedData& result = TypedData::ZoneHandle(
+      reader->zone(), TypedData::New(cid, len, HEAP_SPACE(kind)));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Setup the array elements.
   intptr_t element_size = ElementSizeInBytes(cid);
   intptr_t length_in_bytes = len * element_size;
   switch (cid) {
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid: {
       NoSafepointScope no_safepoint;
@@ skipping 27 matching lines @@
       break;
     default:
       UNREACHABLE();
   }
   // If it is a canonical constant make it one.
   // When reading a full snapshot we don't need to canonicalize the object
   // as it would already be a canonical object.
   // When reading a script snapshot or a message snapshot we always have
   // to canonicalize the object.
   if (RawObject::IsCanonical(tags)) {
-    if (Snapshot::IsFull(kind)) {
-      // Set the canonical bit.
-      result.SetCanonical();
-    } else {
-      result ^= result.CheckAndCanonicalize(reader->thread(), NULL);
-      ASSERT(!result.IsNull());
-      ASSERT(result.IsCanonical());
-    }
+    result ^= result.CheckAndCanonicalize(reader->thread(), NULL);
+    ASSERT(!result.IsNull());
+    ASSERT(result.IsCanonical());
   }
   return result.raw();
 }
 #undef TYPED_DATA_READ
 
 
 RawExternalTypedData* ExternalTypedData::ReadFrom(SnapshotReader* reader,
                                                   intptr_t object_id,
                                                   intptr_t tags,
                                                   Snapshot::Kind kind,
@@ skipping 235 matching lines @@
   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,
                                     bool as_reference) {
-  if (Snapshot::IsFull(kind)) {
-    Stacktrace& result = Stacktrace::ZoneHandle(reader->zone(),
-                                                reader->NewStacktrace());
-    reader->AddBackRef(object_id, &result, kIsDeserialized);
-
-    bool expand_inlined = reader->Read<bool>();
-    result.set_expand_inlined(expand_inlined);
-
-    // Set all the object fields.
-    READ_OBJECT_FIELDS(result,
-                       result.raw()->from(), result.raw()->to(),
-                       kAsReference);
-
-    return result.raw();
-  }
   UNREACHABLE();  // Stacktraces are not sent in a snapshot.
   return Stacktrace::null();
 }
 
 
 void RawStacktrace::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind,
                             bool as_reference) {
-  if (Snapshot::IsFull(kind)) {
-    ASSERT(writer != NULL);
-    ASSERT(this == Isolate::Current()->object_store()->
-           preallocated_stack_trace());
-
-    // Write out the serialization header value for this object.
-    writer->WriteInlinedObjectHeader(object_id);
-
-    // Write out the class and tags information.
-    writer->WriteIndexedObject(kStacktraceCid);
-    writer->WriteTags(writer->GetObjectTags(this));
-
-    writer->Write(ptr()->expand_inlined_);
-
-    // Write out all the object pointer fields.
-    SnapshotWriterVisitor visitor(writer, kAsReference);
-    visitor.VisitPointers(from(), to());
-  } else {
-    // Stacktraces are not allowed in other snapshot forms.
-    writer->SetWriteException(Exceptions::kArgument,
-                              "Illegal argument in isolate message"
-                              " : (object is a stacktrace)");
-  }
+  ASSERT(kind == Snapshot::kMessage);
+  writer->SetWriteException(Exceptions::kArgument,
+                            "Illegal argument in isolate message"
+                            " : (object is a stacktrace)");
 }
 
 
 RawRegExp* RegExp::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind,
                             bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate RegExp object.
-  RegExp& regex = RegExp::ZoneHandle(reader->zone(), NEW_OBJECT(RegExp));
+  RegExp& regex = RegExp::ZoneHandle(reader->zone(), RegExp::New());
   reader->AddBackRef(object_id, &regex, kIsDeserialized);
 
   // Read and Set all the other fields.
   regex.StoreSmi(&regex.raw_ptr()->num_bracket_expressions_,
                  reader->ReadAsSmi());
   *reader->StringHandle() ^= reader->ReadObjectImpl(kAsInlinedObject);
   regex.set_pattern(*reader->StringHandle());
   regex.StoreNonPointer(&regex.raw_ptr()->num_registers_,
                         reader->Read<int32_t>());
   regex.StoreNonPointer(&regex.raw_ptr()->type_flags_,
@@ skipping 36 matching lines @@
 
 
 RawWeakProperty* WeakProperty::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind,
                                         bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate the weak property object.
-  WeakProperty& weak_property = WeakProperty::ZoneHandle(
-      reader->zone(), NEW_OBJECT(WeakProperty));
+  WeakProperty& weak_property = WeakProperty::ZoneHandle(reader->zone(),
+                                                         WeakProperty::New());
   reader->AddBackRef(object_id, &weak_property, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(weak_property,
                      weak_property.raw()->from(), weak_property.raw()->to(),
                      kAsReference);
 
   return weak_property.raw();
 }
 
@@ skipping 60 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