VM: Re-format to use at most one newline between functions

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/dart_api_message.h"
 #include "vm/object.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 #include "vm/unicode.h"
 
 namespace dart {
 
 static const int kNumInitialReferences = 4;
 
 ApiMessageReader::ApiMessageReader(const uint8_t* buffer, intptr_t length)
     : BaseReader(buffer, length),
       zone_(NULL),
       backward_references_(kNumInitialReferences),
       vm_isolate_references_(kNumInitialReferences),
       vm_symbol_references_(NULL) {}
 
-
 ApiMessageReader::ApiMessageReader(Message* msg)
     : BaseReader(msg->IsRaw() ? reinterpret_cast<uint8_t*>(msg->raw_obj())
                               : msg->data(),
                  msg->len()),
       zone_(NULL),
       backward_references_(kNumInitialReferences),
       vm_isolate_references_(kNumInitialReferences),
       vm_symbol_references_(NULL) {}
 
-
 void ApiMessageReader::Init() {
   // We need to have an enclosing ApiNativeScope.
   ASSERT(ApiNativeScope::Current() != NULL);
   zone_ = ApiNativeScope::Current()->zone();
   ASSERT(zone_ != NULL);
 
   // Initialize marker objects used to handle Lists.
   // TODO(sjesse): Remove this when message serialization format is
   // updated.
   memset(&type_arguments_marker, 0, sizeof(type_arguments_marker));
   memset(&dynamic_type_marker, 0, sizeof(dynamic_type_marker));
   type_arguments_marker.type =
       static_cast<Dart_CObject_Type>(Dart_CObject_Internal::kTypeArguments);
   dynamic_type_marker.type =
       static_cast<Dart_CObject_Type>(Dart_CObject_Internal::kDynamicType);
 }
 
-
 Dart_CObject* ApiMessageReader::ReadMessage() {
   Init();
   if (PendingBytes() > 0) {
     // Read the object out of the message.
     return ReadObject();
   } else {
     const RawObject* raw_obj =
         reinterpret_cast<const RawObject*>(CurrentBufferAddress());
     ASSERT(ApiObjectConverter::CanConvert(raw_obj));
     Dart_CObject* cobj =
         reinterpret_cast<Dart_CObject*>(allocator(sizeof(Dart_CObject)));
     ApiObjectConverter::Convert(raw_obj, cobj);
     return cobj;
   }
 }
 
-
 intptr_t ApiMessageReader::LookupInternalClass(intptr_t class_header) {
   if (IsVMIsolateObject(class_header)) {
     return GetVMIsolateObjectId(class_header);
   }
   ASSERT(SerializedHeaderTag::decode(class_header) == kObjectId);
   return SerializedHeaderData::decode(class_header);
 }
 
-
 Dart_CObject* ApiMessageReader::AllocateDartCObject(Dart_CObject_Type type) {
   Dart_CObject* value =
       reinterpret_cast<Dart_CObject*>(allocator(sizeof(Dart_CObject)));
   ASSERT(value != NULL);
   value->type = type;
   return value;
 }
 
-
 Dart_CObject* ApiMessageReader::AllocateDartCObjectUnsupported() {
   return AllocateDartCObject(Dart_CObject_kUnsupported);
 }
 
-
 Dart_CObject* ApiMessageReader::AllocateDartCObjectNull() {
   return AllocateDartCObject(Dart_CObject_kNull);
 }
 
-
 Dart_CObject* ApiMessageReader::AllocateDartCObjectBool(bool val) {
   Dart_CObject* value = AllocateDartCObject(Dart_CObject_kBool);
   value->value.as_bool = val;
   return value;
 }
 
-
 Dart_CObject* ApiMessageReader::AllocateDartCObjectInt32(int32_t val) {
   Dart_CObject* value = AllocateDartCObject(Dart_CObject_kInt32);
   value->value.as_int32 = val;
   return value;
 }
 
-
 Dart_CObject* ApiMessageReader::AllocateDartCObjectInt64(int64_t val) {
   Dart_CObject* value = AllocateDartCObject(Dart_CObject_kInt64);
   value->value.as_int64 = val;
   return value;
 }
 
-
 _Dart_CObject* ApiMessageReader::singleton_uint32_typed_data_ = NULL;
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectBigint() {
   Dart_CObject* value = AllocateDartCObject(Dart_CObject_kBigint);
   value->value.as_bigint.neg = false;
   value->value.as_bigint.used = 0;
   if (singleton_uint32_typed_data_ == NULL) {
     singleton_uint32_typed_data_ =
         AllocateDartCObjectTypedData(Dart_TypedData_kUint32, 0);
   }
   value->value.as_bigint.digits = singleton_uint32_typed_data_;
   value->type = Dart_CObject_kBigint;
   return value;
 }
 
-
 Dart_CObject* ApiMessageReader::AllocateDartCObjectDouble(double val) {
   Dart_CObject* value = AllocateDartCObject(Dart_CObject_kDouble);
   value->value.as_double = val;
   return value;
 }
 
-
 Dart_CObject* ApiMessageReader::AllocateDartCObjectString(intptr_t length) {
   // Allocate a Dart_CObject structure followed by an array of chars
   // for the string content. The pointer to the string content is set
   // up to this area.
   Dart_CObject* value = reinterpret_cast<Dart_CObject*>(
       allocator(sizeof(Dart_CObject) + length + 1));
   ASSERT(value != NULL);
   value->value.as_string = reinterpret_cast<char*>(value) + sizeof(*value);
   value->type = Dart_CObject_kString;
   return value;
 }
 
-
 static int GetTypedDataSizeInBytes(Dart_TypedData_Type type) {
   switch (type) {
     case Dart_TypedData_kInt8:
     case Dart_TypedData_kUint8:
     case Dart_TypedData_kUint8Clamped:
       return 1;
     case Dart_TypedData_kInt16:
     case Dart_TypedData_kUint16:
       return 2;
     case Dart_TypedData_kInt32:
     case Dart_TypedData_kUint32:
     case Dart_TypedData_kFloat32:
       return 4;
     case Dart_TypedData_kInt64:
     case Dart_TypedData_kUint64:
     case Dart_TypedData_kFloat64:
       return 8;
     default:
       break;
   }
   UNREACHABLE();
   return -1;
 }
 
-
 Dart_CObject* ApiMessageReader::AllocateDartCObjectTypedData(
     Dart_TypedData_Type type,
     intptr_t length) {
   // Allocate a Dart_CObject structure followed by an array of bytes
   // for the byte array content. The pointer to the byte array content
   // is set up to this area.
   intptr_t length_in_bytes = GetTypedDataSizeInBytes(type) * length;
   Dart_CObject* value = reinterpret_cast<Dart_CObject*>(
       allocator(sizeof(Dart_CObject) + length_in_bytes));
   ASSERT(value != NULL);
   value->type = Dart_CObject_kTypedData;
   value->value.as_typed_data.type = type;
   value->value.as_typed_data.length = length_in_bytes;
   if (length > 0) {
     value->value.as_typed_data.values =
         reinterpret_cast<uint8_t*>(value) + sizeof(*value);
   } else {
     value->value.as_typed_data.values = NULL;
   }
   return value;
 }
 
-
 Dart_CObject* ApiMessageReader::AllocateDartCObjectArray(intptr_t length) {
   // Allocate a Dart_CObject structure followed by an array of
   // pointers to Dart_CObject structures. The pointer to the array
   // content is set up to this area.
   Dart_CObject* value = reinterpret_cast<Dart_CObject*>(
       allocator(sizeof(Dart_CObject) + length * sizeof(value)));
   ASSERT(value != NULL);
   value->type = Dart_CObject_kArray;
   value->value.as_array.length = length;
   if (length > 0) {
     value->value.as_array.values = reinterpret_cast<Dart_CObject**>(value + 1);
   } else {
     value->value.as_array.values = NULL;
   }
   return value;
 }
 
-
 Dart_CObject* ApiMessageReader::AllocateDartCObjectVmIsolateObj(intptr_t id) {
   RawObject* raw = VmIsolateSnapshotObject(id);
   intptr_t cid = raw->GetClassId();
   switch (cid) {
     case kOneByteStringCid: {
       RawOneByteString* raw_str = reinterpret_cast<RawOneByteString*>(raw);
       const char* str = reinterpret_cast<const char*>(raw_str->ptr()->data());
       ASSERT(str != NULL);
       Dart_CObject* object = NULL;
       for (intptr_t i = 0; i < vm_isolate_references_.length(); i++) {
@@ skipping 18 matching lines @@
         return GetCanonicalMintObject(Dart_CObject_kInt64, value64);
       }
     }
 
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
-
 Dart_CObject_Internal* ApiMessageReader::AllocateDartCObjectInternal(
     Dart_CObject_Internal::Type type) {
   Dart_CObject_Internal* value = reinterpret_cast<Dart_CObject_Internal*>(
       allocator(sizeof(Dart_CObject_Internal)));
   ASSERT(value != NULL);
   value->type = static_cast<Dart_CObject_Type>(type);
   return value;
 }
 
-
 Dart_CObject_Internal* ApiMessageReader::AllocateDartCObjectClass() {
   return AllocateDartCObjectInternal(Dart_CObject_Internal::kClass);
 }
 
-
 ApiMessageReader::BackRefNode* ApiMessageReader::AllocateBackRefNode(
     Dart_CObject* reference,
     DeserializeState state) {
   BackRefNode* value =
       reinterpret_cast<BackRefNode*>(allocator(sizeof(BackRefNode)));
   value->set_reference(reference);
   value->set_state(state);
   return value;
 }
 
-
 static Dart_TypedData_Type GetTypedDataTypeFromView(
     Dart_CObject_Internal* object,
     char* class_name) {
   struct {
     const char* name;
     Dart_TypedData_Type type;
   } view_class_names[] = {
       {"_Int8ArrayView", Dart_TypedData_kInt8},
       {"_Uint8ArrayView", Dart_TypedData_kUint8},
       {"_Uint8ClampedArrayView", Dart_TypedData_kUint8Clamped},
@@ skipping 13 matching lines @@
   while (view_class_names[i].name != NULL) {
     if (strncmp(view_class_names[i].name, class_name,
                 strlen(view_class_names[i].name)) == 0) {
       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 = 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) {
@@ skipping 72 matching lines @@
     }
     for (int i = 0; i < len; i++) {
       value->value.as_array.values[i] = ReadObjectRef();
     }
     return value;
   }
 
   return ReadInternalVMObject(class_id, object_id);
 }
 
-
 Dart_CObject* ApiMessageReader::ReadPredefinedSymbol(intptr_t object_id) {
   ASSERT(Symbols::IsPredefinedSymbolId(object_id));
   intptr_t symbol_id = object_id - kMaxPredefinedObjectIds;
   Dart_CObject* object;
   if (vm_symbol_references_ != NULL &&
       (object = vm_symbol_references_[symbol_id]) != NULL) {
     return object;
   }
 
   if (vm_symbol_references_ == NULL) {
     intptr_t size =
         (sizeof(*vm_symbol_references_) * Symbols::kMaxPredefinedId);
     vm_symbol_references_ = reinterpret_cast<Dart_CObject**>(allocator(size));
     memset(vm_symbol_references_, 0, size);
   }
 
   object = CreateDartCObjectString(Symbols::GetPredefinedSymbol(object_id));
   ASSERT(vm_symbol_references_[symbol_id] == NULL);
   vm_symbol_references_[symbol_id] = object;
   return object;
 }
 
-
 intptr_t ApiMessageReader::NextAvailableObjectId() const {
   return backward_references_.length() + kMaxPredefinedObjectIds;
 }
 
-
 Dart_CObject* ApiMessageReader::CreateDartCObjectString(RawObject* raw) {
   ASSERT(RawObject::IsOneByteStringClassId(raw->GetClassId()));
   RawOneByteString* raw_str = reinterpret_cast<RawOneByteString*>(raw);
   intptr_t len = Smi::Value(raw_str->ptr()->length_);
   Dart_CObject* object = AllocateDartCObjectString(len);
   char* p = object->value.as_string;
   memmove(p, raw_str->ptr()->data(), len);
   p[len] = '\0';
   return object;
 }
 
-
 Dart_CObject* ApiMessageReader::GetCanonicalMintObject(Dart_CObject_Type type,
                                                        int64_t value64) {
   Dart_CObject* object = NULL;
   for (intptr_t i = 0; i < vm_isolate_references_.length(); i++) {
     object = vm_isolate_references_.At(i);
     if (object->type == type) {
       if (value64 == object->value.as_int64) {
         return object;
       }
     }
   }
   if (type == Dart_CObject_kInt32) {
     object = AllocateDartCObjectInt32(static_cast<int32_t>(value64));
   } else {
     object = AllocateDartCObjectInt64(value64);
   }
   vm_isolate_references_.Add(object);
   return object;
 }
 
-
 Dart_CObject* ApiMessageReader::ReadObjectRef() {
   int64_t value64 = Read<int64_t>();
   if ((value64 & kSmiTagMask) == 0) {
     int64_t untagged_value = value64 >> kSmiTagShift;
     if ((kMinInt32 <= untagged_value) && (untagged_value <= kMaxInt32)) {
       return AllocateDartCObjectInt32(static_cast<int32_t>(untagged_value));
     } else {
       return AllocateDartCObjectInt64(untagged_value);
     }
   }
@@ skipping 34 matching lines @@
   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;
   }
   return ReadInternalVMObject(class_id, object_id);
 }
 
-
 Dart_CObject* ApiMessageReader::ReadVMIsolateObject(intptr_t value) {
   intptr_t object_id = GetVMIsolateObjectId(value);
   if (object_id == kNullObject) {
     return AllocateDartCObjectNull();
   }
   if (object_id == kTrueValue) {
     return AllocateDartCObjectBool(true);
   }
   if (object_id == kFalseValue) {
     return AllocateDartCObjectBool(false);
   }
   if (object_id == kDoubleObject) {
     return AllocateDartCObjectDouble(ReadDouble());
   }
   if (Symbols::IsPredefinedSymbolId(object_id)) {
     return ReadPredefinedSymbol(object_id);
   }
   // No other VM isolate objects are supported.
   return AllocateDartCObjectNull();
 }
 
-
 Dart_CObject* ApiMessageReader::ReadInternalVMObject(intptr_t class_id,
                                                      intptr_t object_id) {
   switch (class_id) {
     case kClassCid: {
       Read<bool>();  // Consume the is_in_fullsnapshot indicator.
       Dart_CObject_Internal* object = AllocateDartCObjectClass();
       AddBackRef(object_id, object, kIsDeserialized);
       object->internal.as_class.library_url = ReadObjectImpl();
       ASSERT(object->internal.as_class.library_url->type ==
              Dart_CObject_kString);
@@ skipping 139 matching lines @@
       AddBackRef(object_id, object, kIsDeserialized);
       return object;
     }
 
 #define READ_TYPED_DATA_HEADER(type)                                           \
   intptr_t len = ReadSmiValue();                                               \
   Dart_CObject* object =                                                       \
       AllocateDartCObjectTypedData(Dart_TypedData_k##type, len);               \
   AddBackRef(object_id, object, kIsDeserialized);
 
-
 #define READ_TYPED_DATA(type, ctype)                                           \
   {                                                                            \
     READ_TYPED_DATA_HEADER(type);                                              \
     if (len > 0) {                                                             \
       ctype* p = reinterpret_cast<ctype*>(object->value.as_typed_data.values); \
       for (intptr_t i = 0; i < len; i++) {                                     \
         p[i] = Read<ctype>();                                                  \
       }                                                                        \
     }                                                                          \
     return object;                                                             \
@@ skipping 91 matching lines @@
       return value;
     }
     default:
       // Everything else not supported.
       Dart_CObject* value = AllocateDartCObjectUnsupported();
       AddBackRef(object_id, value, kIsDeserialized);
       return value;
   }
 }
 
-
 Dart_CObject* ApiMessageReader::ReadIndexedObject(intptr_t object_id) {
   if (object_id == kDynamicType || object_id == kDoubleType ||
       object_id == kIntType || object_id == kBoolType ||
       object_id == kStringType) {
     // 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();
 }
 
-
 Dart_CObject* ApiMessageReader::ReadObject() {
   Dart_CObject* value = ReadObjectImpl();
   for (intptr_t i = 0; i < backward_references_.length(); i++) {
     if (!backward_references_[i]->is_deserialized()) {
       ReadObjectImpl();
       backward_references_[i]->set_state(kIsDeserialized);
     }
   }
   return value;
 }
 
-
 Dart_CObject* ApiMessageReader::ReadObjectImpl() {
   int64_t value64 = Read<int64_t>();
   if ((value64 & kSmiTagMask) == 0) {
     int64_t untagged_value = value64 >> kSmiTagShift;
     if ((kMinInt32 <= untagged_value) && (untagged_value <= kMaxInt32)) {
       return AllocateDartCObjectInt32(static_cast<int32_t>(untagged_value));
     } else {
       return AllocateDartCObjectInt64(untagged_value);
     }
   }
   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);
 
   intptr_t object_id = SerializedHeaderData::decode(value);
   if (object_id == kOmittedObjectId) {
     object_id = NextAvailableObjectId();
   }
   return ReadInlinedObject(object_id);
 }
 
-
 void ApiMessageReader::AddBackRef(intptr_t id,
                                   Dart_CObject* obj,
                                   DeserializeState state) {
   intptr_t index = (id - kMaxPredefinedObjectIds);
   ASSERT(index == backward_references_.length());
   BackRefNode* node = AllocateBackRefNode(obj, state);
   ASSERT(node != NULL);
   backward_references_.Add(node);
 }
 
-
 Dart_CObject* ApiMessageReader::GetBackRef(intptr_t id) {
   ASSERT(id >= kMaxPredefinedObjectIds);
   intptr_t index = (id - kMaxPredefinedObjectIds);
   if (index < backward_references_.length()) {
     return backward_references_[index]->reference();
   }
   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(kArrayCid);
   WriteTags(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++) {
     Write<RawObject*>(Integer::New(data[i]));
   }
 }
 
-
 void ApiMessageWriter::MarkCObject(Dart_CObject* object, intptr_t object_id) {
   // Mark the object as serialized by adding the object id to the
   // upper bits of the type field in the Dart_CObject structure. Add
   // an offset for making marking of object id 0 possible.
   ASSERT(!IsCObjectMarked(object));
   intptr_t mark_value = object_id + kDartCObjectMarkOffset;
   object->type = static_cast<Dart_CObject_Type>(
       ((mark_value) << kDartCObjectTypeBits) | object->type);
 }
 
-
 void ApiMessageWriter::UnmarkCObject(Dart_CObject* object) {
   ASSERT(IsCObjectMarked(object));
   object->type =
       static_cast<Dart_CObject_Type>(object->type & kDartCObjectTypeMask);
 }
 
-
 bool ApiMessageWriter::IsCObjectMarked(Dart_CObject* object) {
   return (object->type & kDartCObjectMarkMask) != 0;
 }
 
-
 intptr_t ApiMessageWriter::GetMarkedCObjectMark(Dart_CObject* object) {
   ASSERT(IsCObjectMarked(object));
   intptr_t mark_value =
       ((object->type & kDartCObjectMarkMask) >> kDartCObjectTypeBits);
   // An offset was added to object id for making marking object id 0 possible.
   return mark_value - kDartCObjectMarkOffset;
 }
 
-
 void ApiMessageWriter::UnmarkAllCObjects(Dart_CObject* object) {
   if (!IsCObjectMarked(object)) return;
   UnmarkCObject(object);
   if (object->type == Dart_CObject_kArray) {
     for (int i = 0; i < object->value.as_array.length; i++) {
       Dart_CObject* element = object->value.as_array.values[i];
       UnmarkAllCObjects(element);
     }
   }
 }
 
-
 void ApiMessageWriter::AddToForwardList(Dart_CObject* object) {
   if (forward_id_ >= forward_list_length_) {
     void* new_list = NULL;
     if (forward_list_length_ == 0) {
       forward_list_length_ = 4;
       intptr_t new_size = forward_list_length_ * sizeof(object);
       new_list = ::malloc(new_size);
     } else {
       forward_list_length_ *= 2;
       intptr_t new_size = (forward_list_length_ * sizeof(object));
       new_list = ::realloc(forward_list_, new_size);
     }
     ASSERT(new_list != NULL);
     forward_list_ = reinterpret_cast<Dart_CObject**>(new_list);
   }
   forward_list_[forward_id_] = object;
   forward_id_ += 1;
 }
 
-
 void ApiMessageWriter::WriteSmi(int64_t value) {
   ASSERT(Smi::IsValid(value));
   Write<RawObject*>(Smi::New(static_cast<intptr_t>(value)));
 }
 
-
 void ApiMessageWriter::WriteNullObject() {
   WriteVMIsolateObject(kNullObject);
 }
 
-
 void ApiMessageWriter::WriteMint(Dart_CObject* object, int64_t value) {
   ASSERT(!Smi::IsValid(value));
   // Write out the serialization header value for mint object.
   WriteInlinedHeader(object);
   // Write out the class and tags information.
   WriteIndexedObject(kMintCid);
   WriteTags(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::IsValid(value)) {
     WriteSmi(value);
   } else {
     WriteMint(object, value);
   }
 }
 
-
 void ApiMessageWriter::WriteInt64(Dart_CObject* object) {
   int64_t value = object->value.as_int64;
   if (Smi::IsValid(value)) {
     WriteSmi(value);
   } else {
     WriteMint(object, value);
   }
 }
 
-
 void ApiMessageWriter::WriteInlinedHeader(Dart_CObject* object) {
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(kMaxPredefinedObjectIds + object_id_);
   // Mark object with its object id.
   MarkCObject(object, object_id_);
   // Advance object id.
   object_id_++;
 }
 
-
 bool ApiMessageWriter::WriteCObject(Dart_CObject* object) {
   if (IsCObjectMarked(object)) {
     intptr_t object_id = GetMarkedCObjectMark(object);
     WriteIndexedObject(kMaxPredefinedObjectIds + object_id);
     return true;
   }
 
   Dart_CObject_Type type = object->type;
   if (type == Dart_CObject_kArray) {
     const intptr_t array_length = object->value.as_array.length;
@@ skipping 13 matching lines @@
     // Write out array elements.
     for (int i = 0; i < array_length; i++) {
       bool success = WriteCObjectRef(object->value.as_array.values[i]);
       if (!success) return false;
     }
     return true;
   }
   return WriteCObjectInlined(object, type);
 }
 
-
 bool ApiMessageWriter::WriteCObjectRef(Dart_CObject* object) {
   if (IsCObjectMarked(object)) {
     intptr_t object_id = GetMarkedCObjectMark(object);
     WriteIndexedObject(kMaxPredefinedObjectIds + object_id);
     return true;
   }
 
   Dart_CObject_Type type = object->type;
   if (type == Dart_CObject_kArray) {
     const intptr_t array_length = object->value.as_array.length;
     if (array_length < 0 || array_length > Array::kMaxElements) {
       return false;
     }
     // Write out the serialization header value for this object.
     WriteInlinedHeader(object);
     // Write out the class information.
     WriteIndexedObject(kArrayCid);
     WriteTags(0);
     // Write out the length information.
     WriteSmi(array_length);
     // Add object to forward list so that this object is serialized later.
     AddToForwardList(object);
     return true;
   }
   return WriteCObjectInlined(object, type);
 }
 
-
 bool 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);
   const intptr_t array_length = object->value.as_array.length;
   if (array_length < 0 || array_length > Array::kMaxElements) {
     return false;
   }
 
   // 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(kArrayCid);
   WriteTags(0);
   // Write out the length information.
   WriteSmi(array_length);
   // Write out the type arguments.
   WriteNullObject();
   // Write out array elements.
   for (int i = 0; i < array_length; i++) {
     bool success = WriteCObjectRef(object->value.as_array.values[i]);
     if (!success) return false;
   }
   return true;
 }
 
-
 bool 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) {
         WriteVMIsolateObject(kTrueValue);
       } else {
@@ skipping 127 matching lines @@
       // 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(kExternalTypedDataUint8ArrayCid);
       WriteTags(0);
       intptr_t length = object->value.as_external_typed_data.length;
-      if (length < 0 ||
-          length >
-              ExternalTypedData::MaxElements(kExternalTypedDataUint8ArrayCid)) {
+      if (length < 0 || length > ExternalTypedData::MaxElements(
+                                     kExternalTypedDataUint8ArrayCid)) {
         return false;
       }
       uint8_t* data = object->value.as_external_typed_data.data;
       void* peer = object->value.as_external_typed_data.peer;
       Dart_WeakPersistentHandleFinalizer callback =
           object->value.as_external_typed_data.callback;
       WriteSmi(length);
       WriteRawPointerValue(reinterpret_cast<intptr_t>(data));
       WriteRawPointerValue(reinterpret_cast<intptr_t>(peer));
       WriteRawPointerValue(reinterpret_cast<intptr_t>(callback));
@@ skipping 14 matching lines @@
       Write<uint64_t>(object->value.as_capability.id);
       break;
     }
     default:
       FATAL1("Unexpected Dart_CObject_Type %d\n", type);
   }
 
   return true;
 }
 
-
 bool ApiMessageWriter::WriteCMessage(Dart_CObject* object) {
   bool success = WriteCObject(object);
   if (!success) {
     UnmarkAllCObjects(object);
     return false;
   }
   // Write out all objects that were added to the forward list and have
   // 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++) {
     success = WriteForwardedCObject(forward_list_[i]);
     if (!success) {
       UnmarkAllCObjects(object);
       return false;
     }
   }
   UnmarkAllCObjects(object);
   return true;
 }
 
 }  // namespace dart