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

vm/dart_api_message.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/dart_api_message.h"
 #include "vm/object.h"
-#include "vm/object_store.h"
+#include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
-// TODO(sgjesse): When the external message format is done these
-// duplicate constants from snapshot.cc should be removed.
-enum {
-  kInstanceId = ObjectStore::kMaxId,
-  kMaxPredefinedObjectIds,
-};
 static const int kNumInitialReferences = 4;
 
 ApiMessageReader::ApiMessageReader(const uint8_t* buffer,
                                    intptr_t length,
                                    ReAlloc alloc)
     : BaseReader(buffer, length),
       alloc_(alloc),
       backward_references_(kNumInitialReferences) {
   Init();
 }
@@ skipping 152 matching lines @@
 
 
 Dart_CObject* ApiMessageReader::ReadInlinedObject(intptr_t object_id) {
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
   intptr_t tags = ReadIntptrValue();
   USE(tags);
   intptr_t class_id;
 
   // Reading of regular dart instances is not supported.
-  if (SerializedHeaderData::decode(class_header) == kInstanceId) {
+  if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     return AllocateDartCObjectUnsupported();
   }
 
   ASSERT((class_header & kSmiTagMask) != 0);
   class_id = LookupInternalClass(class_header);
-  if (class_id == ObjectStore::kArrayClass ||
-      class_id == ObjectStore::kImmutableArrayClass) {
+  if (class_id == kArrayCid || class_id == kImmutableArrayCid) {
     intptr_t len = ReadSmiValue();
     Dart_CObject* value = GetBackRef(object_id);
     if (value == NULL) {
       value = AllocateDartCObjectArray(len);
       AddBackRef(object_id, value, kIsDeserialized);
     }
     // Skip type arguments.
     // TODO(sjesse): Remove this when message serialization format is
     // updated (currently type_arguments is leaked).
     Dart_CObject* type_arguments = ReadObjectImpl();
@@ skipping 33 matching lines @@
     int64_t untagged_value = value >> kSmiTagShift;
     if (kMinInt32 <= untagged_value && untagged_value <= kMaxInt32) {
       return AllocateDartCObjectInt32(untagged_value);
     } else {
       return AllocateDartCObjectInt64(untagged_value);
     }
   }
   ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
   if (IsVMIsolateObject(value)) {
     intptr_t object_id = GetVMIsolateObjectId(value);
-    if (object_id == Object::kNullObject) {
+    if (object_id == kNullObject) {
       return AllocateDartCObjectNull();
     }
     return ReadVMSymbol(object_id);
   }
   if (SerializedHeaderTag::decode(value) == kObjectId) {
     return ReadIndexedObject(SerializedHeaderData::decode(value));
   }
   ASSERT(SerializedHeaderTag::decode(value) == kInlined);
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
 
   // Reading of regular dart instances is not supported.
-  if (SerializedHeaderData::decode(class_header) == kInstanceId) {
+  if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     return AllocateDartCObjectUnsupported();
   }
   ASSERT((class_header & kSmiTagMask) != 0);
   intptr_t object_id = SerializedHeaderData::decode(value);
   intptr_t class_id = LookupInternalClass(class_header);
-  if (class_id == ObjectStore::kArrayClass ||
-      class_id == ObjectStore::kImmutableArrayClass) {
+  if (class_id == kArrayCid || class_id == kImmutableArrayCid) {
     ASSERT(GetBackRef(object_id) == NULL);
     intptr_t len = ReadSmiValue();
     Dart_CObject* value = AllocateDartCObjectArray(len);
     AddBackRef(object_id, value, kIsNotDeserialized);
     return value;
   }
   intptr_t tags = ReadIntptrValue();
   USE(tags);
 
   return ReadInternalVMObject(class_id, object_id);
 }
 
 
 Dart_CObject* ApiMessageReader::ReadInternalVMObject(intptr_t class_id,
                                                      intptr_t object_id) {
   switch (class_id) {
-    case Object::kClassClass: {
+    case kClassCid: {
       return AllocateDartCObjectUnsupported();
     }
-    case Object::kTypeArgumentsClass: {
+    case kTypeArgumentsCid: {
       // TODO(sjesse): Remove this when message serialization format is
       // updated (currently length is leaked).
       Dart_CObject* value = &type_arguments_marker;
       AddBackRef(object_id, value, kIsDeserialized);
       Dart_CObject* length = ReadObjectImpl();
       ASSERT(length->type == Dart_CObject::kInt32);
       for (int i = 0; i < length->value.as_int32; i++) {
         Dart_CObject* type = ReadObjectImpl();
         if (type != &dynamic_type_marker) {
           return AllocateDartCObjectUnsupported();
         }
       }
       return value;
     }
-    case Object::kTypeParameterClass: {
+    case kTypeParameterCid: {
       // TODO(sgjesse): Fix this workaround ignoring the type parameter.
       Dart_CObject* value = &dynamic_type_marker;
       AddBackRef(object_id, value, kIsDeserialized);
       intptr_t index = ReadIntptrValue();
       USE(index);
       intptr_t token_index = ReadIntptrValue();
       USE(token_index);
       int8_t type_state = Read<int8_t>();
       USE(type_state);
       Dart_CObject* parameterized_class = ReadObjectImpl();
       // The type parameter is finalized, therefore parameterized_class is null.
       ASSERT(parameterized_class->type == Dart_CObject::kNull);
       Dart_CObject* name = ReadObjectImpl();
       ASSERT(name->type == Dart_CObject::kString);
       return value;
     }
-    case ObjectStore::kMintClass: {
+    case kMintCid: {
       int64_t value = Read<int64_t>();
       Dart_CObject* object;
       if (kMinInt32 <= value && value <= kMaxInt32) {
         object = AllocateDartCObjectInt32(value);
       } else {
         object = AllocateDartCObjectInt64(value);
       }
       AddBackRef(object_id, object, kIsDeserialized);
       return object;
     }
-    case ObjectStore::kBigintClass: {
+    case kBigintCid: {
       // Read in the hex string representation of the bigint.
       intptr_t len = ReadIntptrValue();
       Dart_CObject* object = AllocateDartCObjectBigint(len);
       AddBackRef(object_id, object, kIsDeserialized);
       char* p = object->value.as_bigint;
       for (intptr_t i = 0; i < len; i++) {
         p[i] = Read<uint8_t>();
       }
       p[len] = '\0';
       return object;
     }
-    case ObjectStore::kDoubleClass: {
+    case kDoubleCid: {
       // Read the double value for the object.
       Dart_CObject* object = AllocateDartCObjectDouble(Read<double>());
       AddBackRef(object_id, object, kIsDeserialized);
       return object;
     }
-    case ObjectStore::kOneByteStringClass: {
+    case kOneByteStringCid: {
       intptr_t len = ReadSmiValue();
       intptr_t hash = ReadSmiValue();
       USE(hash);
       Dart_CObject* object = AllocateDartCObjectString(len);
       AddBackRef(object_id, object, kIsDeserialized);
       char* p = object->value.as_string;
       for (intptr_t i = 0; i < len; i++) {
         p[i] = Read<uint8_t>();
       }
       p[len] = '\0';
       return object;
     }
-    case ObjectStore::kTwoByteStringClass:
+    case kTwoByteStringCid:
       // Two byte strings not supported.
       return AllocateDartCObjectUnsupported();
-    case ObjectStore::kFourByteStringClass:
+    case kFourByteStringCid:
       // Four byte strings not supported.
       return AllocateDartCObjectUnsupported();
-    case ObjectStore::kUint8ArrayClass: {
+    case kUint8ArrayCid: {
       intptr_t len = ReadSmiValue();
       Dart_CObject* object = AllocateDartCObjectUint8Array(len);
       AddBackRef(object_id, object, kIsDeserialized);
       if (len > 0) {
         uint8_t* p = object->value.as_byte_array.values;
         for (intptr_t i = 0; i < len; i++) {
           p[i] = Read<uint8_t>();
         }
       }
       return object;
     }
     default:
       // Everything else not supported.
       return AllocateDartCObjectUnsupported();
   }
 }
 
 
 Dart_CObject* ApiMessageReader::ReadIndexedObject(intptr_t object_id) {
-  if (object_id == ObjectStore::kTrueValue) {
+  if (object_id == kTrueValue) {
     return AllocateDartCObjectBool(true);
   }
-  if (object_id == ObjectStore::kFalseValue) {
+  if (object_id == kFalseValue) {
     return AllocateDartCObjectBool(false);
   }
-  if (object_id == ObjectStore::kDynamicType ||
-      object_id == ObjectStore::kDoubleInterface ||
-      object_id == ObjectStore::kIntInterface ||
-      object_id == ObjectStore::kBoolInterface ||
-      object_id == ObjectStore::kStringInterface) {
+  if (object_id == kDynamicType ||
+      object_id == kDoubleInterface ||
+      object_id == kIntInterface ||
+      object_id == kBoolInterface ||
+      object_id == kStringInterface) {
     // Always return dynamic type (this is only a marker).
     return &dynamic_type_marker;
   }
   intptr_t index = object_id - kMaxPredefinedObjectIds;
   ASSERT((0 <= index) && (index < backward_references_.length()));
   ASSERT(backward_references_[index]->reference() != NULL);
   return backward_references_[index]->reference();
 }
 
 
@@ skipping 15 matching lines @@
     int64_t untagged_value = value >> kSmiTagShift;
     if (kMinInt32 <= untagged_value && untagged_value <= kMaxInt32) {
       return AllocateDartCObjectInt32(untagged_value);
     } else {
       return AllocateDartCObjectInt64(untagged_value);
     }
   }
   ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
   if (IsVMIsolateObject(value)) {
     intptr_t object_id = GetVMIsolateObjectId(value);
-    if (object_id == Object::kNullObject) {
+    if (object_id == kNullObject) {
       return AllocateDartCObjectNull();
     }
     return ReadVMSymbol(object_id);
   }
   if (SerializedHeaderTag::decode(value) == kObjectId) {
     return ReadIndexedObject(SerializedHeaderData::decode(value));
   }
   ASSERT(SerializedHeaderTag::decode(value) == kInlined);
   return ReadInlinedObject(SerializedHeaderData::decode(value));
 }
@@ skipping 18 matching lines @@
   }
   return NULL;
 }
 
 
 void ApiMessageWriter::WriteMessage(intptr_t field_count, intptr_t *data) {
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(kMaxPredefinedObjectIds);
 
   // Write out the class and tags information.
-  WriteIndexedObject(ObjectStore::kArrayClass);
+  WriteIndexedObject(kArrayCid);
   WriteIntptrValue(0);
 
   // Write out the length field.
   Write<RawObject*>(Smi::New(field_count));
 
   // Write out the type arguments.
   WriteNullObject();
 
   // Write out the individual Smis.
   for (int i = 0; i < field_count; i++) {
@@ skipping 66 matching lines @@
 }
 
 
 void ApiMessageWriter::WriteSmi(int64_t value) {
   ASSERT(Smi::IsValid64(value));
   Write<RawObject*>(Smi::New(value));
 }
 
 
 void ApiMessageWriter::WriteNullObject() {
-  WriteVMIsolateObject(Object::kNullObject);
+  WriteVMIsolateObject(kNullObject);
 }
 
 
 void ApiMessageWriter::WriteMint(Dart_CObject* object, int64_t value) {
   ASSERT(!Smi::IsValid64(value));
   // Write out the serialization header value for mint object.
   WriteInlinedHeader(object);
   // Write out the class and tags information.
-  WriteIndexedObject(ObjectStore::kMintClass);
+  WriteIndexedObject(kMintCid);
   WriteIntptrValue(0);
   // Write the 64-bit value.
   Write<int64_t>(value);
 }
 
 
 void ApiMessageWriter::WriteInt32(Dart_CObject* object) {
   int64_t value = object->value.as_int32;
   if (Smi::IsValid64(value)) {
     WriteSmi(value);
@@ skipping 28 matching lines @@
     intptr_t object_id = GetMarkedCObjectMark(object);
     WriteIndexedObject(kMaxPredefinedObjectIds + object_id);
     return;
   }
 
   Dart_CObject::Type type = object->type;
   if (type == Dart_CObject::kArray) {
     // Write out the serialization header value for this object.
     WriteInlinedHeader(object);
     // Write out the class and tags information.
-    WriteIndexedObject(ObjectStore::kArrayClass);
+    WriteIndexedObject(kArrayCid);
     WriteIntptrValue(0);
 
     WriteSmi(object->value.as_array.length);
     // Write out the type arguments.
     WriteNullObject();
     // Write out array elements.
     for (int i = 0; i < object->value.as_array.length; i++) {
       WriteCObjectRef(object->value.as_array.values[i]);
     }
     return;
   }
   return WriteCObjectInlined(object, type);
 }
 
 
 void ApiMessageWriter::WriteCObjectRef(Dart_CObject* object) {
   if (IsCObjectMarked(object)) {
     intptr_t object_id = GetMarkedCObjectMark(object);
     WriteIndexedObject(kMaxPredefinedObjectIds + object_id);
     return;
   }
 
   Dart_CObject::Type type = object->type;
   if (type == Dart_CObject::kArray) {
     // Write out the serialization header value for this object.
     WriteInlinedHeader(object);
     // Write out the class information.
-    WriteIndexedObject(ObjectStore::kArrayClass);
+    WriteIndexedObject(kArrayCid);
     // Write out the length information.
     WriteSmi(object->value.as_array.length);
     // Add object to forward list so that this object is serialized later.
     AddToForwardList(object);
     return;
   }
   return WriteCObjectInlined(object, type);
 }
 
 
 void ApiMessageWriter::WriteForwardedCObject(Dart_CObject* object) {
   ASSERT(IsCObjectMarked(object));
   Dart_CObject::Type type =
       static_cast<Dart_CObject::Type>(object->type & kDartCObjectTypeMask);
   ASSERT(type == Dart_CObject::kArray);
 
   // Write out the serialization header value for this object.
   intptr_t object_id = GetMarkedCObjectMark(object);
   WriteInlinedObjectHeader(kMaxPredefinedObjectIds + object_id);
   // Write out the class and tags information.
-  WriteIndexedObject(ObjectStore::kArrayClass);
+  WriteIndexedObject(kArrayCid);
   WriteIntptrValue(0);
 
   WriteSmi(object->value.as_array.length);
   // Write out the type arguments.
   WriteNullObject();
   // Write out array elements.
   for (int i = 0; i < object->value.as_array.length; i++) {
     WriteCObjectRef(object->value.as_array.values[i]);
   }
 }
 
 
 void ApiMessageWriter::WriteCObjectInlined(Dart_CObject* object,
                                            Dart_CObject::Type type) {
   switch (type) {
     case Dart_CObject::kNull:
       WriteNullObject();
       break;
     case Dart_CObject::kBool:
       if (object->value.as_bool) {
-        WriteIndexedObject(ObjectStore::kTrueValue);
+        WriteIndexedObject(kTrueValue);
       } else {
-        WriteIndexedObject(ObjectStore::kFalseValue);
+        WriteIndexedObject(kFalseValue);
       }
       break;
     case Dart_CObject::kInt32:
       WriteInt32(object);
       break;
     case Dart_CObject::kInt64:
       WriteInt64(object);
       break;
     case Dart_CObject::kBigint: {
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
-      WriteIndexedObject(ObjectStore::kBigintClass);
+      WriteIndexedObject(kBigintCid);
       WriteIntptrValue(0);
       // Write hex string length and content
       char* hex_string = object->value.as_bigint;
       intptr_t len = strlen(hex_string);
       WriteIntptrValue(len);
       for (intptr_t i = 0; i < len; i++) {
         Write<uint8_t>(hex_string[i]);
       }
       break;
     }
     case Dart_CObject::kDouble:
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
-      WriteIndexedObject(ObjectStore::kDoubleClass);
+      WriteIndexedObject(kDoubleCid);
       WriteIntptrValue(0);
       // Write double value.
       Write<double>(object->value.as_double);
       break;
     case Dart_CObject::kString: {
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
-      WriteIndexedObject(ObjectStore::kOneByteStringClass);
+      WriteIndexedObject(kOneByteStringCid);
       WriteIntptrValue(0);
       // Write string length, hash and content
       char* str = object->value.as_string;
       intptr_t len = strlen(str);
       WriteSmi(len);
       WriteSmi(0);  // TODO(sgjesse): Hash - not written.
       for (intptr_t i = 0; i < len; i++) {
         Write<uint8_t>(str[i]);
       }
       break;
     }
     case Dart_CObject::kUint8Array: {
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
-      WriteIndexedObject(ObjectStore::kUint8ArrayClass);
+      WriteIndexedObject(kUint8ArrayCid);
       WriteIntptrValue(0);
       uint8_t* bytes = object->value.as_byte_array.values;
       intptr_t len = object->value.as_byte_array.length;
       WriteSmi(len);
       for (intptr_t i = 0; i < len; i++) {
         Write<uint8_t>(bytes[i]);
       }
       break;
     }
     case Dart_CObject::kExternalUint8Array: {
       // TODO(ager): we are writing C pointers into the message in
       // order to post external arrays through ports. We need to make
       // sure that messages containing pointers can never be posted
       // to other processes.
 
       // Write out serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tag information.
-      WriteIndexedObject(ObjectStore::kExternalUint8ArrayClass);
+      WriteIndexedObject(kExternalUint8ArrayCid);
       WriteIntptrValue(0);
       int length = object->value.as_external_byte_array.length;
       uint8_t* data = object->value.as_external_byte_array.data;
       void* peer = object->value.as_external_byte_array.peer;
       Dart_PeerFinalizer callback =
           object->value.as_external_byte_array.callback;
       WriteSmi(length);
       WriteIntptrValue(reinterpret_cast<intptr_t>(data));
       WriteIntptrValue(reinterpret_cast<intptr_t>(peer));
       WriteIntptrValue(reinterpret_cast<intptr_t>(callback));
@@ skipping 11 matching lines @@
   // not been serialized yet. These would typically be fields of arrays.
   // NOTE: The forward list might grow as we process the list.
   for (intptr_t i = 0; i < forward_id_; i++) {
     WriteForwardedCObject(forward_list_[i]);
   }
   UnmarkAllCObjects(object);
   FinalizeBuffer();
 }
 
 }  // namespace dart