Finishes removing intptr_t from raw object fields.

runtime/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/bigint_operations.h"
 #include "vm/dart_api_message.h"
 #include "vm/object.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 #include "vm/unicode.h"
@@ skipping 239 matching lines @@
       return view_class_names[i].type;
     }
     i++;
   }
   return Dart_TypedData_kInvalid;
 }
 
 
 Dart_CObject* ApiMessageReader::ReadInlinedObject(intptr_t object_id) {
   // Read the class header information and lookup the class.
-  intptr_t class_header = ReadIntptrValue();
+  intptr_t class_header = Read<int32_t>();
   intptr_t tags = ReadTags();
   USE(tags);
   intptr_t class_id;
 
   // There is limited support for reading regular dart instances. Only
   // typed data views are currently handled.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     Dart_CObject_Internal* object =
         reinterpret_cast<Dart_CObject_Internal*>(GetBackRef(object_id));
     if (object == NULL) {
@@ skipping 122 matching lines @@
   ASSERT((value64 <= kIntptrMax) && (value64 >= kIntptrMin));
   intptr_t value = static_cast<intptr_t>(value64);
   if (IsVMIsolateObject(value)) {
     return ReadVMIsolateObject(value);
   }
   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();
+  intptr_t class_header = Read<int32_t>();
 
   // Reading of regular dart instances has limited support in order to
   // read typed data views.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     intptr_t object_id = SerializedHeaderData::decode(value);
     Dart_CObject_Internal* object =
         AllocateDartCObjectInternal(Dart_CObject_Internal::kUninitialized);
     AddBackRef(object_id, object, kIsNotDeserialized);
     // Read class of object.
     object->cls = reinterpret_cast<Dart_CObject_Internal*>(ReadObjectImpl());
@@ skipping 68 matching lines @@
         if (type != &dynamic_type_marker) {
           return AllocateDartCObjectUnsupported();
         }
       }
       return value;
     }
     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();
+      intptr_t index = Read<int32_t>();
       USE(index);
-      intptr_t token_index = ReadIntptrValue();
+      intptr_t token_index = Read<int32_t>();
       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 kMintCid: {
       int64_t value64 = Read<int64_t>();
       Dart_CObject* object;
       if ((kMinInt32 <= value64) && (value64 <= kMaxInt32)) {
         object = AllocateDartCObjectInt32(static_cast<int32_t>(value64));
       } else {
         object = AllocateDartCObjectInt64(value64);
       }
       AddBackRef(object_id, object, kIsDeserialized);
       return object;
     }
     case kBigintCid: {
       // Read in the hex string representation of the bigint.
-      intptr_t len = ReadIntptrValue();
+      intptr_t len = Read<int32_t>();
       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 kDoubleCid: {
@@ skipping 505 matching lines @@
           chunk_len > Bigint::kMaxElements) {
         return false;
       }
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
       WriteIndexedObject(kBigintCid);
       WriteTags(0);
       // Write hex string length and content
       intptr_t len = strlen(hex_string);
-      WriteIntptrValue(len);
+      Write<int32_t>(len);
       for (intptr_t i = 0; i < len; i++) {
         Write<uint8_t>(hex_string[i]);
       }
       break;
     }
     case Dart_CObject_kDouble:
       WriteVMIsolateObject(kDoubleObject);
       WriteDouble(object->value.as_double);
       break;
     case Dart_CObject_kString: {
@@ skipping 126 matching lines @@
     if (!success) {
       UnmarkAllCObjects(object);
       return false;
     }
   }
   UnmarkAllCObjects(object);
   return true;
 }
 
 }  // namespace dart