Address review comments from a previous CL.

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"
 
 namespace dart {
 
@@ skipping 173 matching lines @@
   USE(tags);
   intptr_t class_id;
 
   // Reading of regular dart instances is not supported.
   if (SerializedHeaderData::decode(class_header) == kInstanceId) {
     return AllocateDartCObjectUnsupported();
   }
 
   ASSERT((class_header & kSmiTagMask) != 0);
   class_id = LookupInternalClass(class_header);
-  if (class_id == ObjectStore::kArrayClass ||
-      class_id == ObjectStore::kImmutableArrayClass) {
+  if (class_id == kArray || class_id == kImmutableArray) {

[regis, 2012/07/24 13:49:25]

Not your cl, but parentheses are missing here and at other locations in this
file.

[siva, 2012/08/13 20:38:25]

Done.

     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 32 matching lines @@
   // 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) {
     return AllocateDartCObjectUnsupported();
   }
   ASSERT((class_header & kSmiTagMask) != 0);
   intptr_t object_id = header_value;
   intptr_t class_id = LookupInternalClass(class_header);
-  if (class_id == ObjectStore::kArrayClass ||
-      class_id == ObjectStore::kImmutableArrayClass) {
+  if (class_id == kArray || class_id == kImmutableArray) {
     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 kClass: {
       return AllocateDartCObjectUnsupported();
     }
-    case Object::kTypeArgumentsClass: {
+    case kTypeArguments: {
       // 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 kTypeParameter: {
       // 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 kMint: {
       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 kBigint: {
       // 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 kDouble: {
       // Read the double value for the object.
       Dart_CObject* object = AllocateDartCObjectDouble(Read<double>());
       AddBackRef(object_id, object, kIsDeserialized);
       return object;
     }
-    case ObjectStore::kOneByteStringClass: {
+    case kOneByteString: {
       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 kTwoByteString:
       // Two byte strings not supported.
       return AllocateDartCObjectUnsupported();
-    case ObjectStore::kFourByteStringClass:
+    case kFourByteString:
       // Four byte strings not supported.
       return AllocateDartCObjectUnsupported();
-    case ObjectStore::kUint8ArrayClass: {
+    case kUint8Array: {
       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;
@@ skipping 83 matching lines @@
   }
   return NULL;
 }
 
 
 void ApiMessageWriter::WriteMessage(intptr_t field_count, intptr_t *data) {
   // Write out the serialization header value for this object.
   WriteSerializationMarker(kInlined, kMaxPredefinedObjectIds);
 
   // Write out the class and tags information.
-  WriteObjectHeader(ObjectStore::kArrayClass, 0);
+  WriteObjectHeader(kArray, 0);
 
   // Write out the length field.
   Write<RawObject*>(Smi::New(field_count));
 
   // Write out the type arguments.
   WriteIndexedObject(Object::kNullObject);
 
   // Write out the individual Smis.
   for (int i = 0; i < field_count; i++) {
     Write<RawObject*>(Integer::New(data[i]));
@@ skipping 69 matching lines @@
   ASSERT(Smi::IsValid64(value));
   Write<RawObject*>(Smi::New(value));
 }
 
 
 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.
-  WriteObjectHeader(ObjectStore::kMintClass, 0);
+  WriteObjectHeader(kMint, 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);
   } else {
@@ skipping 27 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.
-    WriteObjectHeader(ObjectStore::kArrayClass, 0);
+    WriteObjectHeader(kArray, 0);
     WriteSmi(object->value.as_array.length);
     // Write out the type arguments.
     WriteIndexedObject(Object::kNullObject);
     // 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(kArray);
     // 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);
   WriteSerializationMarker(kInlined, kMaxPredefinedObjectIds + object_id);
   // Write out the class and tags information.
-  WriteObjectHeader(ObjectStore::kArrayClass, 0);
+  WriteObjectHeader(kArray, 0);
   WriteSmi(object->value.as_array.length);
   // Write out the type arguments.
   WriteIndexedObject(Object::kNullObject);
   // Write out array elements.
   for (int i = 0; i < object->value.as_array.length; i++) {
     WriteCObjectRef(object->value.as_array.values[i]);
   }
 }
 
 
@@ skipping 13 matching lines @@
     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.
-      WriteObjectHeader(ObjectStore::kBigintClass, 0);
+      WriteObjectHeader(kBigint, 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.
-      WriteObjectHeader(ObjectStore::kDoubleClass, 0);
+      WriteObjectHeader(kDouble, 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.
-      WriteObjectHeader(ObjectStore::kOneByteStringClass, 0);
+      WriteObjectHeader(kOneByteString, 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.
-      WriteObjectHeader(ObjectStore::kUint8ArrayClass, 0);
+      WriteObjectHeader(kUint8Array, 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.
-      WriteObjectHeader(ObjectStore::kExternalUint8ArrayClass, 0);
+      WriteObjectHeader(kExternalUint8Array, 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));
       break;
@@ skipping 10 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