clang-format runtime/vm

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) {
-}
+      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) {
-}
+      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
@@ skipping 10 matching lines @@
 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)));
+        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);
   }
@@ skipping 62 matching lines @@
   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));
+  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:
@@ skipping 13 matching lines @@
       return 8;
     default:
       break;
   }
   UNREACHABLE();
   return -1;
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectTypedData(
-    Dart_TypedData_Type type, intptr_t length) {
+    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));
+  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)));
+  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;
 }
@@ skipping 33 matching lines @@
 
     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)));
+  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 },
-    { "_Int16ArrayView", Dart_TypedData_kInt16 },
-    { "_Uint16ArrayView", Dart_TypedData_kUint16 },
-    { "_Int32ArrayView", Dart_TypedData_kInt32 },
-    { "_Uint32ArrayView", Dart_TypedData_kUint32 },
-    { "_Int64ArrayView", Dart_TypedData_kInt64 },
-    { "_Uint64ArrayView", Dart_TypedData_kUint64 },
-    { "_ByteDataView", Dart_TypedData_kUint8 },
-    { "_Float32ArrayView", Dart_TypedData_kFloat32 },
-    { "_Float64ArrayView", Dart_TypedData_kFloat64 },
-    { NULL, Dart_TypedData_kInvalid },
+      {"_Int8ArrayView", Dart_TypedData_kInt8},
+      {"_Uint8ArrayView", Dart_TypedData_kUint8},
+      {"_Uint8ClampedArrayView", Dart_TypedData_kUint8Clamped},
+      {"_Int16ArrayView", Dart_TypedData_kInt16},
+      {"_Uint16ArrayView", Dart_TypedData_kUint16},
+      {"_Int32ArrayView", Dart_TypedData_kInt32},
+      {"_Uint32ArrayView", Dart_TypedData_kUint32},
+      {"_Int64ArrayView", Dart_TypedData_kInt64},
+      {"_Uint64ArrayView", Dart_TypedData_kUint64},
+      {"_ByteDataView", Dart_TypedData_kUint8},
+      {"_Float32ArrayView", Dart_TypedData_kFloat32},
+      {"_Float64ArrayView", Dart_TypedData_kFloat64},
+      {NULL, Dart_TypedData_kInvalid},
   };
 
   int i = 0;
   while (view_class_names[i].name != NULL) {
-    if (strncmp(view_class_names[i].name,
-                class_name,
+    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) {
@@ skipping 10 matching lines @@
         reinterpret_cast<Dart_CObject_Internal*>(GetBackRef(object_id));
     if (object == NULL) {
       object =
           AllocateDartCObjectInternal(Dart_CObject_Internal::kUninitialized);
       AddBackRef(object_id, object, kIsDeserialized);
       // Read class of object.
       object->cls = reinterpret_cast<Dart_CObject_Internal*>(ReadObjectImpl());
       ASSERT(object->cls->type ==
              static_cast<Dart_CObject_Type>(Dart_CObject_Internal::kClass));
     }
-    ASSERT(object->type ==
-           static_cast<Dart_CObject_Type>(
-               Dart_CObject_Internal::kUninitialized));
+    ASSERT(object->type == static_cast<Dart_CObject_Type>(
+                               Dart_CObject_Internal::kUninitialized));
 
     char* library_uri =
         object->cls->internal.as_class.library_url->value.as_string;
     char* class_name =
         object->cls->internal.as_class.class_name->value.as_string;
 
     // Handle typed data views.
     if (strcmp("dart:typed_data", library_uri) == 0) {
       Dart_TypedData_Type type = GetTypedDataTypeFromView(object, class_name);
       if (type != Dart_TypedData_kInvalid) {
         object->type =
             static_cast<Dart_CObject_Type>(Dart_CObject_Internal::kView);
         Dart_CObject_Internal* cls =
             reinterpret_cast<Dart_CObject_Internal*>(ReadObjectImpl());
         ASSERT(cls == object->cls);
         object->internal.as_view.buffer = ReadObjectImpl();
         object->internal.as_view.offset_in_bytes = ReadSmiValue();
         object->internal.as_view.length = ReadSmiValue();
 
         // The buffer is fully read now as typed data objects are
         // serialized in-line.
         Dart_CObject* buffer = object->internal.as_view.buffer;
         ASSERT(buffer->type == Dart_CObject_kTypedData);
 
         // Now turn the view into a byte array.
         object->type = Dart_CObject_kTypedData;
         object->value.as_typed_data.type = type;
         object->value.as_typed_data.length =
-            object->internal.as_view.length *
-            GetTypedDataSizeInBytes(type);
+            object->internal.as_view.length * GetTypedDataSizeInBytes(type);
         object->value.as_typed_data.values =
             buffer->value.as_typed_data.values +
             object->internal.as_view.offset_in_bytes;
       } else {
         // TODO(sgjesse): Handle other instances. Currently this will
         // skew the reading as the fields of the instance is not read.
       }
     } else {
       // TODO(sgjesse): Handle other instances. Currently this will
       // skew the reading as the fields of the instance is not read.
@@ skipping 33 matching lines @@
   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));
+    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;
 }
 
 
@@ skipping 178 matching lines @@
       AddBackRef(object_id, object, kIsDeserialized);
       Dart_CObject* neg_obj = ReadObjectImpl();
       ASSERT(neg_obj->type == Dart_CObject_kBool);
       const bool neg = neg_obj->value.as_bool;
       Dart_CObject* used_obj = ReadObjectImpl();
       ASSERT(used_obj->type == Dart_CObject_kInt32);
       const intptr_t used = used_obj->value.as_int32;
       Dart_CObject* digits = ReadObjectImpl();
       ASSERT(digits->type == Dart_CObject_kTypedData);
       ASSERT(digits->value.as_typed_data.type == Dart_TypedData_kUint32);
-      ASSERT(digits->value.as_typed_data.length >= 4*used);
+      ASSERT(digits->value.as_typed_data.length >= 4 * used);
       // Update the bigint object.
       object->value.as_bigint.neg = neg;
       object->value.as_bigint.used = used;
       object->value.as_bigint.digits = digits;
       return object;
     }
     case kDoubleCid: {
       // Doubles are handled specially when being sent as part of message
       // snapshots.
       UNREACHABLE();
     }
     case kOneByteStringCid: {
       intptr_t len = ReadSmiValue();
-      uint8_t *latin1 =
+      uint8_t* latin1 =
           reinterpret_cast<uint8_t*>(allocator(len * sizeof(uint8_t)));
       intptr_t utf8_len = 0;
       for (intptr_t i = 0; i < len; i++) {
         latin1[i] = Read<uint8_t>();
         utf8_len += Utf8::Length(latin1[i]);
       }
       Dart_CObject* object = AllocateDartCObjectString(utf8_len);
       AddBackRef(object_id, object, kIsDeserialized);
       char* p = object->value.as_string;
       for (intptr_t i = 0; i < len; i++) {
         p += Utf8::Encode(latin1[i], p);
       }
       *p = '\0';
       ASSERT(p == (object->value.as_string + utf8_len));
       return object;
     }
     case kTwoByteStringCid: {
       intptr_t len = ReadSmiValue();
-      uint16_t *utf16 = reinterpret_cast<uint16_t*>(
-          allocator(len * sizeof(uint16_t)));
+      uint16_t* utf16 =
+          reinterpret_cast<uint16_t*>(allocator(len * sizeof(uint16_t)));
       intptr_t utf8_len = 0;
       // Read all the UTF-16 code units.
       for (intptr_t i = 0; i < len; i++) {
         utf16[i] = Read<uint16_t>();
       }
       // Calculate the UTF-8 length and check if the string can be
       // UTF-8 encoded.
       bool valid = true;
       intptr_t i = 0;
       while (i < len && valid) {
@@ skipping 26 matching lines @@
     }
     case kCapabilityCid: {
       int64_t id = Read<int64_t>();
       Dart_CObject* object = AllocateDartCObject(Dart_CObject_kCapability);
       object->value.as_capability.id = id;
       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);                          \
+  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>();                                                \
-        }                                                                      \
+  {                                                                            \
+    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;                                                           \
     }                                                                          \
+    return object;                                                             \
+  }
 
     case kTypedDataInt8ArrayCid:
     case kExternalTypedDataInt8ArrayCid: {
       READ_TYPED_DATA_HEADER(Int8);
       if (len > 0) {
         uint8_t* p =
             reinterpret_cast<uint8_t*>(object->value.as_typed_data.values);
         ReadBytes(p, len);
       }
       return object;
@@ skipping 82 matching lines @@
     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 ||
+  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();
 }
 
@@ skipping 52 matching lines @@
 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) {
+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));
 
@@ skipping 13 matching lines @@
   // 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);
+  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));
@@ skipping 92 matching lines @@
 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;
-    if (array_length < 0 ||
-        array_length > Array::kMaxElements) {
+    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 and tags information.
     WriteIndexedObject(kArrayCid);
     WriteTags(0);
     // Write out the length information.
     WriteSmi(array_length);
@@ skipping 13 matching lines @@
 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) {
+    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) {
+  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.
@@ skipping 68 matching lines @@
       WriteInlinedHeader(object);
       // Write out the class and tags information.
       WriteIndexedObject(type == Utf8::kLatin1 ? kOneByteStringCid
                                                : kTwoByteStringCid);
       WriteTags(0);
       // Write string length and content.
       WriteSmi(len);
       if (type == Utf8::kLatin1) {
         uint8_t* latin1_str =
             reinterpret_cast<uint8_t*>(::malloc(len * sizeof(uint8_t)));
-        bool success = Utf8::DecodeToLatin1(utf8_str,
-                                            utf8_len,
-                                            latin1_str,
-                                            len);
+        bool success =
+            Utf8::DecodeToLatin1(utf8_str, utf8_len, latin1_str, len);
         ASSERT(success);
         for (intptr_t i = 0; i < len; i++) {
           Write<uint8_t>(latin1_str[i]);
         }
         ::free(latin1_str);
       } else {
         uint16_t* utf16_str =
             reinterpret_cast<uint16_t*>(::malloc(len * sizeof(uint16_t)));
         bool success = Utf8::DecodeToUTF16(utf8_str, utf8_len, utf16_str, len);
         ASSERT(success);
@@ skipping 18 matching lines @@
           break;
         case Dart_TypedData_kUint32:
           class_id = kTypedDataUint32ArrayCid;
           break;
         default:
           class_id = kTypedDataUint8ArrayCid;
           UNIMPLEMENTED();
       }
 
       intptr_t len = object->value.as_typed_data.length;
-      if (len < 0 ||
-          len > TypedData::MaxElements(class_id)) {
+      if (len < 0 || len > TypedData::MaxElements(class_id)) {
         return false;
       }
 
       WriteIndexedObject(class_id);
       WriteTags(0);
       WriteSmi(len);
       switch (class_id) {
         case kTypedDataInt8ArrayCid:
         case kTypedDataUint8ArrayCid: {
           uint8_t* bytes = object->value.as_typed_data.values;
@@ skipping 21 matching lines @@
       // 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)) {
+          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 28 matching lines @@
     if (!success) {
       UnmarkAllCObjects(object);
       return false;
     }
   }
   UnmarkAllCObjects(object);
   return true;
 }
 
 }  // namespace dart