Unify class ids and snapshot object ids list so that we don't have disparate and sometimes confusin…

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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
@@ skipping 16 matching lines @@
 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());
   if ((kind == Snapshot::kFull) ||
       (kind == Snapshot::kScript && !RawObject::IsCreatedFromSnapshot(tags))) {
     // Read in the base information.
-    ObjectKind object_kind = reader->Read<ObjectKind>();
+    intptr_t class_id = reader->ReadIntptrValue();
+    bool is_signature_class = reader->Read<bool>();
 
     // Allocate class object of specified kind.
     if (kind == Snapshot::kFull) {
-      cls = reader->NewClass(object_kind);
+      cls = reader->NewClass(class_id, is_signature_class);
     } else {
-      cls = Class::GetClass(object_kind);
+      cls = Class::GetClass(class_id, is_signature_class);
     }
     reader->AddBackRef(object_id, &cls, kIsDeserialized);
 
     // Set the object tags.
     cls.set_tags(tags);
 
     // Set all non object fields.
     cls.set_instance_size(reader->ReadIntptrValue());
     cls.set_type_arguments_instance_field_offset(reader->ReadIntptrValue());
     cls.set_next_field_offset(reader->ReadIntptrValue());
@@ skipping 26 matching lines @@
                        Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   if ((kind == Snapshot::kFull) ||
       (kind == Snapshot::kScript &&
        !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)))) {
     // Write out the class and tags information.
-    writer->WriteVMIsolateObject(Object::kClassClass);
+    writer->WriteVMIsolateObject(kClassCid);
     writer->WriteIntptrValue(writer->GetObjectTags(this));
 
     // Write out all the non object pointer fields.
     // NOTE: cpp_vtable_ is not written.
-    writer->Write<ObjectKind>(ptr()->instance_kind_);
+    writer->WriteIntptrValue(ptr()->id_);
+    writer->Write<bool>(Class::IsSignatureClass(this) ? true : false);
     writer->WriteIntptrValue(ptr()->instance_size_);
     writer->WriteIntptrValue(ptr()->type_arguments_instance_field_offset_);
     writer->WriteIntptrValue(ptr()->next_field_offset_);
     writer->WriteIntptrValue(ptr()->num_native_fields_);
     writer->WriteIntptrValue(ptr()->token_pos_);
     writer->Write<int8_t>(ptr()->class_state_);
     writer->Write<bool>(ptr()->is_const_);
     writer->Write<bool>(ptr()->is_interface_);
 
     // Write out all the object pointer fields.
@@ skipping 36 matching lines @@
 
 void RawUnresolvedClass::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kUnresolvedClassClass);
+  writer->WriteVMIsolateObject(kUnresolvedClassCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->token_pos_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
@@ skipping 51 matching lines @@
 
 void RawType::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kTypeClass);
+  writer->WriteVMIsolateObject(kTypeCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->token_pos_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, false);
   visitor.VisitPointers(from(), to());
 }
@@ skipping 33 matching lines @@
 
 void RawTypeParameter::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kTypeParameterClass);
+  writer->WriteVMIsolateObject(kTypeParameterCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->index_);
   writer->WriteIntptrValue(ptr()->token_pos_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, false);
   visitor.VisitPointers(from(), to());
@@ skipping 51 matching lines @@
 
 void RawTypeArguments::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kTypeArgumentsClass);
+  writer->WriteVMIsolateObject(kTypeArgumentsCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out the length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // 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]);
   }
@@ skipping 32 matching lines @@
 void RawInstantiatedTypeArguments::WriteTo(SnapshotWriter* writer,
                                            intptr_t object_id,
                                            Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kInstantiatedTypeArgumentsClass);
+  writer->WriteVMIsolateObject(kInstantiatedTypeArgumentsCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer, false);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawFunction* Function::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
@@ skipping 40 matching lines @@
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kFunctionClass);
+  writer->WriteVMIsolateObject(kFunctionCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->WriteIntptrValue(ptr()->token_pos_);
   writer->WriteIntptrValue(ptr()->end_token_pos_);
   writer->WriteIntptrValue(ptr()->num_fixed_parameters_);
   writer->WriteIntptrValue(ptr()->num_optional_parameters_);
   writer->WriteIntptrValue(ptr()->usage_counter_);
   writer->WriteIntptrValue(ptr()->deoptimization_counter_);
   writer->WriteIntptrValue(GetKind());
@@ skipping 46 matching lines @@
                        intptr_t object_id,
                        Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kFieldClass);
+  writer->WriteVMIsolateObject(kFieldCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->WriteIntptrValue(ptr()->token_pos_);
   writer->Write<bool>(ptr()->is_static_);
   writer->Write<bool>(ptr()->is_final_);
   writer->Write<bool>(ptr()->is_const_);
   writer->Write<bool>(ptr()->has_initializer_);
 
   // Write out all the object pointer fields.
@@ skipping 32 matching lines @@
 void RawLiteralToken::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kLiteralTokenClass);
+  writer->WriteVMIsolateObject(kLiteralTokenCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out the kind field.
   writer->Write<intptr_t>(ptr()->kind_);
 
   // Write out literal and value fields.
   writer->WriteObjectImpl(ptr()->literal_);
   writer->WriteObjectImpl(ptr()->value_);
 }
 
@@ skipping 35 matching lines @@
                              intptr_t object_id,
                              Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kTokenStreamClass);
+  writer->WriteVMIsolateObject(kTokenStreamCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out the length field and the token stream.
   intptr_t len = Smi::Value(ptr()->length_);
   writer->Write<RawObject*>(ptr()->length_);
   writer->WriteBytes(reinterpret_cast<uint8_t*>(ptr()->data_), len);
 
   // Write out the literal/identifier token array.
   writer->WriteObjectImpl(ptr()->token_objects_);
 }
@@ skipping 33 matching lines @@
                         Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(tokens_ != TokenStream::null());
   ASSERT(kind != Snapshot::kMessage &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kScriptClass);
+  writer->WriteVMIsolateObject(kScriptCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
   writer->WriteObjectImpl(ptr()->url_);
   writer->WriteObjectImpl(ptr()->tokens_);
 }
 
 
 RawLibrary* Library::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
@@ skipping 51 matching lines @@
 void RawLibrary::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kLibraryClass);
+  writer->WriteVMIsolateObject(kLibraryCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   if (RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this))) {
     ASSERT(kind != Snapshot::kFull);
     // Write out library URL so that it can be looked up when reading.
     writer->WriteObjectImpl(ptr()->url_);
   } else {
     // Write out all non object fields.
     writer->WriteIntptrValue(ptr()->index_);
     writer->WriteIntptrValue(ptr()->num_imports_);
@@ skipping 50 matching lines @@
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kLibraryPrefixClass);
+  writer->WriteVMIsolateObject(kLibraryPrefixCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all non object fields.
   writer->WriteIntptrValue(ptr()->num_libs_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
@@ skipping 148 matching lines @@
 
 void RawContext::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kContextClass);
+  writer->WriteVMIsolateObject(kContextCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out num of variables in the context.
   writer->WriteIntptrValue(ptr()->num_variables_);
 
   // Can't serialize the isolate pointer, we set it implicitly on read.
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to(ptr()->num_variables_));
@@ skipping 31 matching lines @@
 void RawContextScope::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteVMIsolateObject(Object::kContextScopeClass);
+  writer->WriteVMIsolateObject(kContextScopeCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Serialize number of variables.
   writer->WriteIntptrValue(ptr()->num_variables_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to(ptr()->num_variables_));
 }
 
@@ skipping 157 matching lines @@
 
 void RawMint::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   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(ObjectStore::kMintClass);
+  writer->WriteIndexedObject(kMintCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out the 64 bit value.
   writer->Write<int64_t>(ptr()->value_);
 }
 
 
 RawBigint* Bigint::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
@@ skipping 27 matching lines @@
 
 void RawBigint::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   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(ObjectStore::kBigintClass);
+  writer->WriteIndexedObject(kBigintCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out the bigint value as a HEXCstring.
   intptr_t length = ptr()->signed_length_;
   bool is_negative = false;
   if (length <= 0) {
     length = -length;
     is_negative = true;
   }
   uword data_start = reinterpret_cast<uword>(ptr()) + sizeof(RawBigint);
@@ skipping 49 matching lines @@
 
 void RawDouble::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   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(ObjectStore::kDoubleClass);
+  writer->WriteIndexedObject(kDoubleCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out the double value.
   writer->Write<double>(ptr()->value_);
 }
 
 
 RawString* String::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
@@ skipping 149 matching lines @@
   writer->WriteIntptrValue(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 == ObjectStore::kOneByteStringClass) {
+    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) {
   StringWriteTo(writer,
                 object_id,
                 kind,
-                ObjectStore::kOneByteStringClass,
+                kOneByteStringCid,
                 writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->data_);
 }
 
 
 void RawTwoByteString::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   StringWriteTo(writer,
                 object_id,
                 kind,
-                ObjectStore::kTwoByteStringClass,
+                kTwoByteStringCid,
                 writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->data_);
 }
 
 
 void RawFourByteString::WriteTo(SnapshotWriter* writer,
                                 intptr_t object_id,
                                 Snapshot::Kind kind) {
   StringWriteTo(writer,
                 object_id,
                 kind,
-                ObjectStore::kFourByteStringClass,
+                kFourByteStringCid,
                 writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->data_);
 }
 
 
 RawExternalOneByteString* ExternalOneByteString::ReadFrom(
     SnapshotReader* reader,
     intptr_t object_id,
@@ skipping 24 matching lines @@
 }
 
 
 void RawExternalOneByteString::WriteTo(SnapshotWriter* writer,
                                        intptr_t object_id,
                                        Snapshot::Kind kind) {
   // Serialize as a non-external one byte string.
   StringWriteTo(writer,
                 object_id,
                 kind,
-                ObjectStore::kOneByteStringClass,
+                kOneByteStringCid,
                 writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->external_data_->data());
 }
 
 
 void RawExternalTwoByteString::WriteTo(SnapshotWriter* writer,
                                        intptr_t object_id,
                                        Snapshot::Kind kind) {
   // Serialize as a non-external two byte string.
   StringWriteTo(writer,
                 object_id,
                 kind,
-                ObjectStore::kTwoByteStringClass,
+                kTwoByteStringCid,
                 writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->external_data_->data());
 }
 
 
 void RawExternalFourByteString::WriteTo(SnapshotWriter* writer,
                                         intptr_t object_id,
                                         Snapshot::Kind kind) {
   // Serialize as a non-external four byte string.
   StringWriteTo(writer,
                 object_id,
                 kind,
-                ObjectStore::kFourByteStringClass,
+                kFourByteStringCid,
                 writer->GetObjectTags(this),
                 ptr()->length_,
                 ptr()->hash_,
                 ptr()->external_data_->data());
 }
 
 
 RawBool* Bool::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
@@ skipping 47 matching lines @@
   }
   reader->ArrayReadFrom(*array, len, tags);
   return array->raw();
 }
 
 
 void RawArray::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind) {
   writer->ArrayWriteTo(object_id,
-                       ObjectStore::kArrayClass,
+                       kArrayCid,
                        writer->GetObjectTags(this),
                        ptr()->length_,
                        ptr()->type_arguments_,
                        ptr()->data());
 }
 
 
 void RawImmutableArray::WriteTo(SnapshotWriter* writer,
                                 intptr_t object_id,
                                 Snapshot::Kind kind) {
   writer->ArrayWriteTo(object_id,
-                       ObjectStore::kImmutableArrayClass,
+                       kImmutableArrayCid,
                        writer->GetObjectTags(this),
                        ptr()->length_,
                        ptr()->type_arguments_,
                        ptr()->data());
 }
 
 
 RawGrowableObjectArray* GrowableObjectArray::ReadFrom(SnapshotReader* reader,
                                                       intptr_t object_id,
                                                       intptr_t tags,
@@ skipping 23 matching lines @@
 
 void RawGrowableObjectArray::WriteTo(SnapshotWriter* writer,
                                      intptr_t object_id,
                                      Snapshot::Kind kind) {
   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(ObjectStore::kGrowableObjectArrayClass);
+  writer->WriteIndexedObject(kGrowableObjectArrayCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out the used length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the Array object.
   writer->WriteObjectImpl(ptr()->data_);
 }
 
 
@@ skipping 116 matching lines @@
 }
 
 
 #define BYTEARRAY_WRITE_TO(name, lname, type)                                  \
 void Raw##name##Array::WriteTo(SnapshotWriter* writer,                         \
                                intptr_t object_id,                             \
                                Snapshot::Kind kind) {                          \
   ByteArrayWriteTo(writer,                                                     \
                    object_id,                                                  \
                    kind,                                                       \
-                   ObjectStore::k##name##ArrayClass,                           \
+                   k##name##ArrayCid,                                          \
                    writer->GetObjectTags(this),                                \
                    ptr()->length_,                                             \
                    reinterpret_cast<uint8_t*>(ptr()->data_));                  \
 }                                                                              \
 
 
 BYTEARRAY_TYPE_LIST(BYTEARRAY_WRITE_TO)
 #undef BYTEARRAY_WRITE_TO
 
 
 #define EXTERNALARRAY_WRITE_TO(name, lname, type)                              \
 void RawExternal##name##Array::WriteTo(SnapshotWriter* writer,                 \
                                        intptr_t object_id,                     \
                                        Snapshot::Kind kind) {                  \
   ByteArrayWriteTo(writer,                                                     \
                    object_id,                                                  \
                    kind,                                                       \
-                   ObjectStore::k##name##ArrayClass,                           \
+                   k##name##ArrayCid,                                          \
                    writer->GetObjectTags(this),                                \
                    ptr()->length_,                                             \
                    reinterpret_cast<uint8_t*>(ptr()->external_data_->data())); \
 }                                                                              \
 
 
 BYTEARRAY_TYPE_LIST(EXTERNALARRAY_WRITE_TO)
 #undef BYTEARRAY_WRITE_TO
 #undef BYTEARRAY_TYPE_LIST
 
@@ skipping 65 matching lines @@
 void RawJSRegExp::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
-  writer->WriteIndexedObject(ObjectStore::kJSRegExpClass);
+  writer->WriteIndexedObject(kJSRegExpCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out the data length field.
   writer->Write<RawObject*>(ptr()->data_length_);
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->num_bracket_expressions_);
   writer->WriteObjectImpl(ptr()->pattern_);
   writer->WriteIntptrValue(ptr()->type_);
   writer->WriteIntptrValue(ptr()->flags_);
 
   // Do not write out the data part which is native.
 }
 
 
 }  // namespace dart