clang-format runtime/vm

runtime/vm/raw_object_snapshot.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/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, remove_script_timestamps_for_test);
 
 #define OFFSET_OF_FROM(obj)                                                    \
   obj.raw()->from() - reinterpret_cast<RawObject**>(obj.raw()->ptr())
 
 // TODO(18854): Need to assert No GC can happen here, even though
 // allocations may happen.
 #define READ_OBJECT_FIELDS(object, from, to, as_reference)                     \
   intptr_t num_flds = (to) - (from);                                           \
   intptr_t from_offset = OFFSET_OF_FROM(object);                               \
   for (intptr_t i = 0; i <= num_flds; i++) {                                   \
     (*reader->PassiveObjectHandle()) =                                         \
         reader->ReadObjectImpl(as_reference, object_id, (i + from_offset));    \
-    object.StorePointer(((from) + i),                                          \
-                        reader->PassiveObjectHandle()->raw());                 \
+    object.StorePointer(((from) + i), reader->PassiveObjectHandle()->raw());   \
   }
 
 RawClass* Class::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind,
                           bool as_reference) {
   ASSERT(reader != NULL);
 
   Class& cls = Class::ZoneHandle(reader->zone(), Class::null());
@@ skipping 18 matching lines @@
       cls.set_next_field_offset_in_words(reader->Read<int32_t>());
     }
     cls.set_type_arguments_field_offset_in_words(reader->Read<int32_t>());
     cls.set_num_type_arguments(reader->Read<int16_t>());
     cls.set_num_own_type_arguments(reader->Read<int16_t>());
     cls.set_num_native_fields(reader->Read<uint16_t>());
     cls.set_token_pos(TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
     cls.set_state_bits(reader->Read<uint16_t>());
 
     // Set all the object fields.
-    READ_OBJECT_FIELDS(cls,
-                       cls.raw()->from(),
-                       cls.raw()->to_snapshot(kind),
+    READ_OBJECT_FIELDS(cls, cls.raw()->from(), cls.raw()->to_snapshot(kind),
                        kAsReference);
     cls.StorePointer(&cls.raw_ptr()->dependent_code_, Array::null());
     ASSERT(!cls.IsInFullSnapshot());
   } else {
     cls ^= reader->ReadClassId(object_id);
     ASSERT((kind == Snapshot::kMessage) || cls.IsInFullSnapshot());
   }
   return cls.raw();
 }
 
@@ skipping 55 matching lines @@
 
 
 RawUnresolvedClass* UnresolvedClass::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind,
                                               bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate unresolved class object.
-  UnresolvedClass& unresolved_class = UnresolvedClass::ZoneHandle(
-      reader->zone(), UnresolvedClass::New());
+  UnresolvedClass& unresolved_class =
+      UnresolvedClass::ZoneHandle(reader->zone(), UnresolvedClass::New());
   reader->AddBackRef(object_id, &unresolved_class, kIsDeserialized);
 
   // Set all non object fields.
   unresolved_class.set_token_pos(
       TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(unresolved_class,
-                     unresolved_class.raw()->from(),
-                     unresolved_class.raw()->to(),
-                     kAsReference);
+  READ_OBJECT_FIELDS(unresolved_class, unresolved_class.raw()->from(),
+                     unresolved_class.raw()->to(), kAsReference);
 
   return unresolved_class.raw();
 }
 
 
 void RawUnresolvedClass::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind,
                                  bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 38 matching lines @@
                         Snapshot::Kind kind,
                         bool as_reference) {
   ASSERT(reader != NULL);
 
   // Determine if the type class of this type is in the full snapshot.
   bool typeclass_is_in_fullsnapshot = reader->Read<bool>();
 
   // Allocate type object.
   Type& type = Type::ZoneHandle(reader->zone(), Type::New());
   bool is_canonical = RawObject::IsCanonical(tags);
-  bool defer_canonicalization = is_canonical &&
+  bool defer_canonicalization =
+      is_canonical &&
       ((kind == Snapshot::kMessage) ||
        (!Snapshot::IsFull(kind) && typeclass_is_in_fullsnapshot));
   reader->AddBackRef(object_id, &type, kIsDeserialized, defer_canonicalization);
 
   // Set all non object fields.
   type.set_token_pos(TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
   type.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(type, type.raw()->from(), type.raw()->to(), kAsReference);
@@ skipping 63 matching lines @@
 
 
 RawTypeRef* TypeRef::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind,
                               bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate type ref object.
-  TypeRef& type_ref = TypeRef::ZoneHandle(
-      reader->zone(), TypeRef::New());
+  TypeRef& type_ref = TypeRef::ZoneHandle(reader->zone(), TypeRef::New());
   reader->AddBackRef(object_id, &type_ref, kIsDeserialized);
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(type_ref,
-                     type_ref.raw()->from(), type_ref.raw()->to(),
+  READ_OBJECT_FIELDS(type_ref, type_ref.raw()->from(), type_ref.raw()->to(),
                      kAsReference);
 
   return type_ref.raw();
 }
 
 
 void RawTypeRef::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind,
                          bool as_reference) {
@@ skipping 13 matching lines @@
 
 
 RawTypeParameter* TypeParameter::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate type parameter object.
-  TypeParameter& type_parameter = TypeParameter::ZoneHandle(
-      reader->zone(), TypeParameter::New());
+  TypeParameter& type_parameter =
+      TypeParameter::ZoneHandle(reader->zone(), TypeParameter::New());
   reader->AddBackRef(object_id, &type_parameter, kIsDeserialized);
 
   // Set all non object fields.
   type_parameter.set_token_pos(
       TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
   type_parameter.set_index(reader->Read<int16_t>());
   type_parameter.set_parent_level(reader->Read<uint8_t>());
   type_parameter.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(type_parameter,
-                     type_parameter.raw()->from(), type_parameter.raw()->to(),
-                     kAsReference);
+  READ_OBJECT_FIELDS(type_parameter, type_parameter.raw()->from(),
+                     type_parameter.raw()->to(), kAsReference);
 
   // Read in the parameterized class.
   (*reader->ClassHandle()) =
       Class::RawCast(reader->ReadObjectImpl(kAsReference));
   type_parameter.set_parameterized_class(*reader->ClassHandle());
 
   return type_parameter.raw();
 }
 
 
@@ skipping 31 matching lines @@
 
 
 RawBoundedType* BoundedType::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind,
                                       bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate bounded type object.
-  BoundedType& bounded_type = BoundedType::ZoneHandle(
-      reader->zone(), BoundedType::New());
+  BoundedType& bounded_type =
+      BoundedType::ZoneHandle(reader->zone(), BoundedType::New());
   reader->AddBackRef(object_id, &bounded_type, kIsDeserialized);
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(bounded_type,
-                     bounded_type.raw()->from(), bounded_type.raw()->to(),
-                     kAsReference);
+  READ_OBJECT_FIELDS(bounded_type, bounded_type.raw()->from(),
+                     bounded_type.raw()->to(), kAsReference);
 
   return bounded_type.raw();
 }
 
 
 void RawBoundedType::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind,
                              bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 36 matching lines @@
                                           bool as_reference) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
 
   TypeArguments& type_arguments = TypeArguments::ZoneHandle(
       reader->zone(), TypeArguments::New(len, HEAP_SPACE(kind)));
   bool is_canonical = RawObject::IsCanonical(tags);
   bool defer_canonicalization = is_canonical && (!Snapshot::IsFull(kind));
-  reader->AddBackRef(object_id,
-                     &type_arguments,
-                     kIsDeserialized,
+  reader->AddBackRef(object_id, &type_arguments, kIsDeserialized,
                      defer_canonicalization);
 
   // Set the instantiations field, which is only read from a full snapshot.
   type_arguments.set_instantiations(Object::zero_array());
 
   // Now set all the type fields.
-  intptr_t offset = type_arguments.TypeAddr(0) -
+  intptr_t offset =
+      type_arguments.TypeAddr(0) -
       reinterpret_cast<RawAbstractType**>(type_arguments.raw()->ptr());
   for (intptr_t i = 0; i < len; i++) {
     *reader->TypeHandle() ^=
         reader->ReadObjectImpl(kAsReference, object_id, (i + offset));
     type_arguments.SetTypeAt(i, *reader->TypeHandle());
   }
 
   // Set the canonical bit.
   if (!defer_canonicalization && is_canonical) {
     type_arguments.SetCanonical();
@@ skipping 29 matching lines @@
 
 RawPatchClass* PatchClass::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind,
                                     bool as_reference) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kScript);
 
   // Allocate function object.
-  PatchClass& cls = PatchClass::ZoneHandle(reader->zone(),
-                                           PatchClass::New());
+  PatchClass& cls = PatchClass::ZoneHandle(reader->zone(), PatchClass::New());
   reader->AddBackRef(object_id, &cls, kIsDeserialized);
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(cls, cls.raw()->from(), cls.raw()->to(), kAsReference);
 
   return cls.raw();
 }
 
 
 void RawPatchClass::WriteTo(SnapshotWriter* writer,
@@ skipping 28 matching lines @@
 void RawClosure::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind,
                          bool as_reference) {
   ASSERT(writer != NULL);
   ASSERT((kind == Snapshot::kMessage) || (kind == Snapshot::kScript));
 
   // Check if closure is serializable, throw an exception otherwise.
   RawFunction* func = writer->IsSerializableClosure(this);
   if (func != Function::null()) {
-    writer->WriteStaticImplicitClosure(object_id,
-                                       func,
+    writer->WriteStaticImplicitClosure(object_id, func,
                                        writer->GetObjectTags(this));
     return;
   }
 
   UNREACHABLE();
 }
 
 
 RawClosureData* ClosureData::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind,
                                       bool as_reference) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kScript);
 
   // Allocate closure data object.
-  ClosureData& data = ClosureData::ZoneHandle(reader->zone(),
-                                              ClosureData::New());
+  ClosureData& data =
+      ClosureData::ZoneHandle(reader->zone(), ClosureData::New());
   reader->AddBackRef(object_id, &data, kIsDeserialized);
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(data,
-                     data.raw()->from(), data.raw()->to(),
+  READ_OBJECT_FIELDS(data, data.raw()->from(), data.raw()->to(),
                      kAsInlinedObject);
 
   return data.raw();
 }
 
 
 void RawClosureData::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind,
                              bool as_reference) {
@@ skipping 30 matching lines @@
 
 RawRedirectionData* RedirectionData::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind,
                                               bool as_reference) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kScript);
 
   // Allocate redirection data object.
-  RedirectionData& data = RedirectionData::ZoneHandle(reader->zone(),
-                                                      RedirectionData::New());
+  RedirectionData& data =
+      RedirectionData::ZoneHandle(reader->zone(), RedirectionData::New());
   reader->AddBackRef(object_id, &data, kIsDeserialized);
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(data,
-                     data.raw()->from(), data.raw()->to(),
-                     kAsReference);
+  READ_OBJECT_FIELDS(data, data.raw()->from(), data.raw()->to(), kAsReference);
 
   return data.raw();
 }
 
 
 void RawRedirectionData::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind,
                                  bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 16 matching lines @@
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kScript);
 
   bool is_in_fullsnapshot = reader->Read<bool>();
   if (!is_in_fullsnapshot) {
     // Allocate function object.
-    Function& func = Function::ZoneHandle(reader->zone(),
-                                          Function::New());
+    Function& func = Function::ZoneHandle(reader->zone(), Function::New());
     reader->AddBackRef(object_id, &func, kIsDeserialized);
 
     // Set all the non object fields. Read the token positions now but
     // don't set them until after setting the kind.
     const int32_t token_pos = reader->Read<int32_t>();
     const int32_t end_token_pos = reader->Read<uint32_t>();
     func.set_num_fixed_parameters(reader->Read<int16_t>());
     func.set_num_optional_parameters(reader->Read<int16_t>());
     func.set_kind_tag(reader->Read<uint32_t>());
     func.set_token_pos(TokenPosition::SnapshotDecode(token_pos));
     func.set_end_token_pos(TokenPosition::SnapshotDecode(end_token_pos));
     func.set_usage_counter(reader->Read<int32_t>());
     func.set_deoptimization_counter(reader->Read<int8_t>());
     func.set_optimized_instruction_count(reader->Read<uint16_t>());
     func.set_optimized_call_site_count(reader->Read<uint16_t>());
     func.set_kernel_function(NULL);
     func.set_was_compiled(false);
 
     // Set all the object fields.
-    READ_OBJECT_FIELDS(func,
-                       func.raw()->from(), func.raw()->to_snapshot(),
+    READ_OBJECT_FIELDS(func, func.raw()->from(), func.raw()->to_snapshot(),
                        kAsReference);
     // Initialize all fields that are not part of the snapshot.
     bool is_optimized = func.usage_counter() != 0;
     if (is_optimized) {
       // Read the ic data array as the function is an optimized one.
       (*reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsReference);
       func.set_ic_data_array(*reader->ArrayHandle());
     } else {
       func.ClearICDataArray();
     }
@@ skipping 10 matching lines @@
                           Snapshot::Kind kind,
                           bool as_reference) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kScript);
   bool is_in_fullsnapshot = false;
   bool owner_is_class = false;
   if ((kind == Snapshot::kScript) && !Function::IsSignatureFunction(this)) {
     intptr_t tags = writer->GetObjectTags(ptr()->owner_);
     intptr_t cid = ClassIdTag::decode(tags);
     owner_is_class = (cid == kClassCid);
-    is_in_fullsnapshot = owner_is_class ?
-        Class::IsInFullSnapshot(reinterpret_cast<RawClass*>(ptr()->owner_)) :
-        PatchClass::IsInFullSnapshot(
-            reinterpret_cast<RawPatchClass*>(ptr()->owner_));
+    is_in_fullsnapshot =
+        owner_is_class ? Class::IsInFullSnapshot(
+                             reinterpret_cast<RawClass*>(ptr()->owner_))
+                       : PatchClass::IsInFullSnapshot(
+                             reinterpret_cast<RawPatchClass*>(ptr()->owner_));
   }
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kFunctionCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the boolean is_in_fullsnapshot first as this will
   // help the reader decide how the rest of the information needs
   // to be interpreted.
   writer->Write<bool>(is_in_fullsnapshot);
 
   if (!is_in_fullsnapshot) {
     bool is_optimized = Code::IsOptimized(ptr()->code_);
 
-    // Write out all the non object fields.
+// Write out all the non object fields.
 #if !defined(DART_PRECOMPILED_RUNTIME)
     writer->Write<int32_t>(ptr()->token_pos_.SnapshotEncode());
     writer->Write<int32_t>(ptr()->end_token_pos_.SnapshotEncode());
 #endif
     writer->Write<int16_t>(ptr()->num_fixed_parameters_);
     writer->Write<int16_t>(ptr()->num_optional_parameters_);
     writer->Write<uint32_t>(ptr()->kind_tag_);
 #if !defined(DART_PRECOMPILED_RUNTIME)
     if (is_optimized) {
       writer->Write<int32_t>(FLAG_optimization_counter_threshold);
@@ skipping 24 matching lines @@
                           Snapshot::Kind kind,
                           bool as_reference) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kScript);
 
   // Allocate field object.
   Field& field = Field::ZoneHandle(reader->zone(), Field::New());
   reader->AddBackRef(object_id, &field, kIsDeserialized);
 
   // Set all non object fields.
-  field.set_token_pos(
-      TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
+  field.set_token_pos(TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
   field.set_guarded_cid(reader->Read<int32_t>());
   field.set_is_nullable(reader->Read<int32_t>());
   field.set_kind_bits(reader->Read<uint8_t>());
   field.set_kernel_field(NULL);
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(field,
-                     field.raw()->from(),
-                     field.raw()->to_snapshot(kind),
+  READ_OBJECT_FIELDS(field, field.raw()->from(), field.raw()->to_snapshot(kind),
                      kAsReference);
   field.StorePointer(&field.raw_ptr()->dependent_code_, Array::null());
 
   if (!FLAG_use_field_guards) {
     field.set_guarded_cid(kDynamicCid);
     field.set_is_nullable(true);
     field.set_guarded_list_length(Field::kNoFixedLength);
     field.set_guarded_list_length_in_object_offset(Field::kUnknownLengthOffset);
   } else {
     field.InitializeGuardedListLengthInObjectOffset();
@@ skipping 50 matching lines @@
 
 RawLiteralToken* LiteralToken::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind,
                                         bool as_reference) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
   // Create the literal token object.
-  LiteralToken& literal_token = LiteralToken::ZoneHandle(reader->zone(),
-                                                         LiteralToken::New());
+  LiteralToken& literal_token =
+      LiteralToken::ZoneHandle(reader->zone(), LiteralToken::New());
   reader->AddBackRef(object_id, &literal_token, kIsDeserialized);
 
   // Read the token attributes.
   Token::Kind token_kind = static_cast<Token::Kind>(reader->Read<int32_t>());
   literal_token.set_kind(token_kind);
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(literal_token,
-                     literal_token.raw()->from(), literal_token.raw()->to(),
-                     kAsReference);
+  READ_OBJECT_FIELDS(literal_token, literal_token.raw()->from(),
+                     literal_token.raw()->to(), kAsReference);
 
   return literal_token.raw();
 }
 
 
 void RawLiteralToken::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind,
                               bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 20 matching lines @@
                                       intptr_t tags,
                                       Snapshot::Kind kind,
                                       bool as_reference) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kScript);
 
   // Read the length so that we can determine number of tokens to read.
   intptr_t len = reader->ReadSmiValue();
 
   // Create the token stream object.
-  TokenStream& token_stream = TokenStream::ZoneHandle(reader->zone(),
-                                                      TokenStream::New(len));
+  TokenStream& token_stream =
+      TokenStream::ZoneHandle(reader->zone(), TokenStream::New(len));
   reader->AddBackRef(object_id, &token_stream, kIsDeserialized);
 
   // Read the stream of tokens into the TokenStream object for script
   // snapshots as we made a copy of token stream.
   if (kind == Snapshot::kScript) {
     NoSafepointScope no_safepoint;
     RawExternalTypedData* stream = token_stream.GetStream();
     reader->ReadBytes(stream->ptr()->data_, len);
   }
 
@@ skipping 44 matching lines @@
   ASSERT(kind == Snapshot::kScript);
 
   // Allocate script object.
   Script& script = Script::ZoneHandle(reader->zone(), Script::New());
   reader->AddBackRef(object_id, &script, kIsDeserialized);
 
   script.StoreNonPointer(&script.raw_ptr()->line_offset_,
                          reader->Read<int32_t>());
   script.StoreNonPointer(&script.raw_ptr()->col_offset_,
                          reader->Read<int32_t>());
-  script.StoreNonPointer(&script.raw_ptr()->kind_,
-                         reader->Read<int8_t>());
+  script.StoreNonPointer(&script.raw_ptr()->kind_, reader->Read<int8_t>());
 
   *reader->StringHandle() ^= String::null();
   script.set_source(*reader->StringHandle());
   *reader->StreamHandle() ^= TokenStream::null();
   script.set_tokens(*reader->StreamHandle());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (script.raw()->to_snapshot(kind) - script.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
     (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     script.StorePointer((script.raw()->from() + i),
                         reader->PassiveObjectHandle()->raw());
   }
 
-  script.set_load_timestamp(FLAG_remove_script_timestamps_for_test
-                            ? 0 : OS::GetCurrentTimeMillis());
+  script.set_load_timestamp(
+      FLAG_remove_script_timestamps_for_test ? 0 : OS::GetCurrentTimeMillis());
 
   return script.raw();
 }
 
 
 void RawScript::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind,
                         bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 127 matching lines @@
 
 RawLibraryPrefix* LibraryPrefix::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kScript);
 
   // Allocate library prefix object.
-  LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(reader->zone(),
-                                                    LibraryPrefix::New());
+  LibraryPrefix& prefix =
+      LibraryPrefix::ZoneHandle(reader->zone(), LibraryPrefix::New());
   reader->AddBackRef(object_id, &prefix, kIsDeserialized);
 
   // Set all non object fields.
   prefix.StoreNonPointer(&prefix.raw_ptr()->num_imports_,
                          reader->Read<int16_t>());
   prefix.StoreNonPointer(&prefix.raw_ptr()->is_deferred_load_,
                          reader->Read<bool>());
   prefix.StoreNonPointer(&prefix.raw_ptr()->is_loaded_,
                          !prefix.raw_ptr()->is_deferred_load_);
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(prefix,
-                     prefix.raw()->from(),
-                     prefix.raw()->to_snapshot(kind),
-                     kAsReference);
-  prefix.StorePointer(&prefix.raw_ptr()->dependent_code_,
-                      Array::null());
+  READ_OBJECT_FIELDS(prefix, prefix.raw()->from(),
+                     prefix.raw()->to_snapshot(kind), kAsReference);
+  prefix.StorePointer(&prefix.raw_ptr()->dependent_code_, Array::null());
 
   return prefix.raw();
 }
 
 
 void RawLibraryPrefix::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 360 matching lines @@
   ICData& result = ICData::ZoneHandle(reader->zone(), ICData::New());
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   NOT_IN_PRECOMPILED(result.set_deopt_id(reader->Read<int32_t>()));
   result.set_state_bits(reader->Read<uint32_t>());
 #if defined(TAG_IC_DATA)
   result.set_tag(reader->Read<int16_t>());
 #endif
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(result,
-                     result.raw()->from(),
-                     result.raw()->to_snapshot(kind),
-                     kAsReference);
+  READ_OBJECT_FIELDS(result, result.raw()->from(),
+                     result.raw()->to_snapshot(kind), kAsReference);
 
   return result.raw();
 }
 
 
 void RawICData::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind,
                         bool as_reference) {
   ASSERT(kind == Snapshot::kScript);
@@ skipping 75 matching lines @@
 
 
 RawApiError* ApiError::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate ApiError object.
-  ApiError& api_error =
-      ApiError::ZoneHandle(reader->zone(), ApiError::New());
+  ApiError& api_error = ApiError::ZoneHandle(reader->zone(), ApiError::New());
   reader->AddBackRef(object_id, &api_error, kIsDeserialized);
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(api_error,
-                     api_error.raw()->from(), api_error.raw()->to(),
+  READ_OBJECT_FIELDS(api_error, api_error.raw()->from(), api_error.raw()->to(),
                      kAsReference);
 
   return api_error.raw();
 }
 
 
 void RawApiError::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind,
                           bool as_reference) {
@@ skipping 24 matching lines @@
       LanguageError::ZoneHandle(reader->zone(), LanguageError::New());
   reader->AddBackRef(object_id, &language_error, kIsDeserialized);
 
   // Set all non object fields.
   language_error.set_token_pos(
       TokenPosition::SnapshotDecode(reader->Read<int32_t>()));
   language_error.set_report_after_token(reader->Read<bool>());
   language_error.set_kind(reader->Read<uint8_t>());
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(language_error,
-                     language_error.raw()->from(), language_error.raw()->to(),
-                     kAsReference);
+  READ_OBJECT_FIELDS(language_error, language_error.raw()->from(),
+                     language_error.raw()->to(), kAsReference);
 
   return language_error.raw();
 }
 
 
 void RawLanguageError::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 14 matching lines @@
   SnapshotWriterVisitor visitor(writer, kAsReference);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawUnhandledException* UnhandledException::ReadFrom(SnapshotReader* reader,
                                                     intptr_t object_id,
                                                     intptr_t tags,
                                                     Snapshot::Kind kind,
                                                     bool as_reference) {
-  UnhandledException& result = UnhandledException::ZoneHandle(
-      reader->zone(), UnhandledException::New());
+  UnhandledException& result =
+      UnhandledException::ZoneHandle(reader->zone(), UnhandledException::New());
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(result,
-                     result.raw()->from(), result.raw()->to(),
+  READ_OBJECT_FIELDS(result, result.raw()->from(), result.raw()->to(),
                      kAsReference);
 
   return result.raw();
 }
 
 
 void RawUnhandledException::WriteTo(SnapshotWriter* writer,
                                     intptr_t object_id,
                                     Snapshot::Kind kind,
                                     bool as_reference) {
@@ skipping 30 matching lines @@
 RawInstance* Instance::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
   ASSERT(reader != NULL);
 
   // Create an Instance object or get canonical one if it is a canonical
   // constant.
   Instance& obj = Instance::ZoneHandle(reader->zone(), Instance::null());
-  obj ^= Object::Allocate(kInstanceCid,
-                          Instance::InstanceSize(),
+  obj ^= Object::Allocate(kInstanceCid, Instance::InstanceSize(),
                           HEAP_SPACE(kind));
   if (RawObject::IsCanonical(tags)) {
     obj = obj.CheckAndCanonicalize(reader->thread(), NULL);
   }
   reader->AddBackRef(object_id, &obj, kIsDeserialized);
 
   return obj.raw();
 }
 
 
@@ skipping 18 matching lines @@
                            Snapshot::Kind kind,
                            bool as_reference) {
   ASSERT(reader != NULL);
 
   // Read the 64 bit value for the object.
   int64_t value = reader->Read<int64_t>();
 
   // Check if the value could potentially fit in a Smi in our current
   // architecture, if so return the object as a Smi.
   if (Smi::IsValid(value)) {
-    Smi& smi = Smi::ZoneHandle(reader->zone(),
-                               Smi::New(static_cast<intptr_t>(value)));
+    Smi& smi =
+        Smi::ZoneHandle(reader->zone(), Smi::New(static_cast<intptr_t>(value)));
     reader->AddBackRef(object_id, &smi, kIsDeserialized);
     return smi.raw();
   }
 
   // Create a Mint object or get canonical one if it is a canonical constant.
   Mint& mint = Mint::ZoneHandle(reader->zone(), Mint::null());
   // When reading a script snapshot we need to canonicalize only those object
   // references that are objects from the core library (loaded from a
   // full snapshot). Objects that are only in the script need not be
   // canonicalized as they are already canonical.
@@ skipping 130 matching lines @@
 
 
 void RawString::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind,
                         bool as_reference) {
   UNREACHABLE();  // String is an abstract class.
 }
 
 
-template<typename StringType, typename CharacterType, typename CallbackType>
+template <typename StringType, typename CharacterType, typename CallbackType>
 void String::ReadFromImpl(SnapshotReader* reader,
                           String* str_obj,
                           intptr_t len,
                           intptr_t tags,
                           CallbackType new_symbol,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   if (RawObject::IsCanonical(tags)) {
     // Set up canonical string object.
     ASSERT(reader != NULL);
@@ skipping 22 matching lines @@
 RawOneByteString* OneByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   // Read the length so that we can determine instance size to allocate.
   ASSERT(reader != NULL);
   intptr_t len = reader->ReadSmiValue();
   String& str_obj = String::ZoneHandle(reader->zone(), String::null());
 
-  String::ReadFromImpl<OneByteString, uint8_t>(
-      reader, &str_obj, len, tags, Symbols::FromLatin1, kind);
+  String::ReadFromImpl<OneByteString, uint8_t>(reader, &str_obj, len, tags,
+                                               Symbols::FromLatin1, kind);
   reader->AddBackRef(object_id, &str_obj, kIsDeserialized);
   return raw(str_obj);
 }
 
 
 RawTwoByteString* TwoByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   // Read the length so that we can determine instance size to allocate.
   ASSERT(reader != NULL);
   intptr_t len = reader->ReadSmiValue();
   String& str_obj = String::ZoneHandle(reader->zone(), String::null());
 
-  String::ReadFromImpl<TwoByteString, uint16_t>(
-      reader, &str_obj, len, tags, Symbols::FromUTF16, kind);
+  String::ReadFromImpl<TwoByteString, uint16_t>(reader, &str_obj, len, tags,
+                                                Symbols::FromUTF16, kind);
   reader->AddBackRef(object_id, &str_obj, kIsDeserialized);
   return raw(str_obj);
 }
 
 
-template<typename T>
+template <typename T>
 static void StringWriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind,
                           intptr_t class_id,
                           intptr_t tags,
                           RawSmi* length,
                           T* data) {
   ASSERT(writer != NULL);
   intptr_t len = Smi::Value(length);
 
@@ skipping 17 matching lines @@
       }
     }
   }
 }
 
 
 void RawOneByteString::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
-  StringWriteTo(writer,
-                object_id,
-                kind,
-                kOneByteStringCid,
-                writer->GetObjectTags(this),
-                ptr()->length_,
-                ptr()->data());
+  StringWriteTo(writer, object_id, kind, kOneByteStringCid,
+                writer->GetObjectTags(this), ptr()->length_, ptr()->data());
 }
 
 
 void RawTwoByteString::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind,
                                bool as_reference) {
-  StringWriteTo(writer,
-                object_id,
-                kind,
-                kTwoByteStringCid,
-                writer->GetObjectTags(this),
-                ptr()->length_,
-                ptr()->data());
+  StringWriteTo(writer, object_id, kind, kTwoByteStringCid,
+                writer->GetObjectTags(this), ptr()->length_, ptr()->data());
 }
 
 
 RawExternalOneByteString* ExternalOneByteString::ReadFrom(
     SnapshotReader* reader,
     intptr_t object_id,
     intptr_t tags,
     Snapshot::Kind kind,
     bool as_reference) {
   UNREACHABLE();
@@ skipping 10 matching lines @@
   UNREACHABLE();
   return ExternalTwoByteString::null();
 }
 
 
 void RawExternalOneByteString::WriteTo(SnapshotWriter* writer,
                                        intptr_t object_id,
                                        Snapshot::Kind kind,
                                        bool as_reference) {
   // Serialize as a non-external one byte string.
-  StringWriteTo(writer,
-                object_id,
-                kind,
-                kOneByteStringCid,
-                writer->GetObjectTags(this),
-                ptr()->length_,
+  StringWriteTo(writer, object_id, kind, kOneByteStringCid,
+                writer->GetObjectTags(this), ptr()->length_,
                 ptr()->external_data_->data());
 }
 
 
 void RawExternalTwoByteString::WriteTo(SnapshotWriter* writer,
                                        intptr_t object_id,
                                        Snapshot::Kind kind,
                                        bool as_reference) {
   // Serialize as a non-external two byte string.
-  StringWriteTo(writer,
-                object_id,
-                kind,
-                kTwoByteStringCid,
-                writer->GetObjectTags(this),
-                ptr()->length_,
+  StringWriteTo(writer, object_id, kind, kTwoByteStringCid,
+                writer->GetObjectTags(this), ptr()->length_,
                 ptr()->external_data_->data());
 }
 
 
 RawBool* Bool::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind,
                         bool as_reference) {
   UNREACHABLE();
@@ skipping 20 matching lines @@
   intptr_t len = reader->ReadSmiValue();
   Array* array = NULL;
   DeserializeState state;
   if (!as_reference) {
     array = reinterpret_cast<Array*>(reader->GetBackRef(object_id));
     state = kIsDeserialized;
   } else {
     state = kIsNotDeserialized;
   }
   if (array == NULL) {
-    array = &(Array::ZoneHandle(reader->zone(),
-                                Array::New(len, HEAP_SPACE(kind))));
+    array =
+        &(Array::ZoneHandle(reader->zone(), Array::New(len, HEAP_SPACE(kind))));
     reader->AddBackRef(object_id, array, state);
   }
   if (!as_reference) {
     // Read all the individual elements for inlined objects.
     ASSERT(!RawObject::IsCanonical(tags));
     reader->ArrayReadFrom(object_id, *array, len, tags);
   }
   return array->raw();
 }
 
 
 RawImmutableArray* ImmutableArray::ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind,
                                             bool as_reference) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
   Array* array = NULL;
   DeserializeState state;
   if (!as_reference) {
     array = reinterpret_cast<Array*>(reader->GetBackRef(object_id));
     state = kIsDeserialized;
   } else {
     state = kIsNotDeserialized;
   }
   if (array == NULL) {
-    array = &(Array::ZoneHandle(
-        reader->zone(),
-        ImmutableArray::New(len, HEAP_SPACE(kind))));
+    array = &(Array::ZoneHandle(reader->zone(),
+                                ImmutableArray::New(len, HEAP_SPACE(kind))));
     reader->AddBackRef(object_id, array, state);
   }
   if (!as_reference) {
     // Read all the individual elements for inlined objects.
     reader->ArrayReadFrom(object_id, *array, len, tags);
     if (RawObject::IsCanonical(tags)) {
       *array ^= array->CheckAndCanonicalize(reader->thread(), NULL);
     }
   }
   return raw(*array);
 }
 
 
 void RawArray::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind,
                        bool as_reference) {
   ASSERT(!this->IsCanonical());
-  writer->ArrayWriteTo(object_id,
-                       kArrayCid,
-                       writer->GetObjectTags(this),
-                       ptr()->length_,
-                       ptr()->type_arguments_,
-                       ptr()->data(),
+  writer->ArrayWriteTo(object_id, kArrayCid, writer->GetObjectTags(this),
+                       ptr()->length_, ptr()->type_arguments_, ptr()->data(),
                        as_reference);
 }
 
 
 void RawImmutableArray::WriteTo(SnapshotWriter* writer,
                                 intptr_t object_id,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
-  writer->ArrayWriteTo(object_id,
-                       kImmutableArrayCid,
-                       writer->GetObjectTags(this),
-                       ptr()->length_,
-                       ptr()->type_arguments_,
-                       ptr()->data(),
-                       as_reference);
+  writer->ArrayWriteTo(object_id, kImmutableArrayCid,
+                       writer->GetObjectTags(this), ptr()->length_,
+                       ptr()->type_arguments_, ptr()->data(), as_reference);
 }
 
 
 RawGrowableObjectArray* GrowableObjectArray::ReadFrom(SnapshotReader* reader,
                                                       intptr_t object_id,
                                                       intptr_t tags,
                                                       Snapshot::Kind kind,
                                                       bool as_reference) {
   ASSERT(reader != NULL);
 
@@ skipping 46 matching lines @@
 }
 
 
 RawLinkedHashMap* LinkedHashMap::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind,
                                           bool as_reference) {
   ASSERT(reader != NULL);
 
-  LinkedHashMap& map = LinkedHashMap::ZoneHandle(
-      reader->zone(), LinkedHashMap::null());
+  LinkedHashMap& map =
+      LinkedHashMap::ZoneHandle(reader->zone(), LinkedHashMap::null());
   if (kind == Snapshot::kScript) {
     // The immutable maps that seed map literals are not yet VM-internal, so
     // we don't reach this.
     UNREACHABLE();
   } else {
     // Since the map might contain itself as a key or value, allocate first.
     map = LinkedHashMap::NewUninitialized(HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &map, kIsDeserialized);
 
   // Read the type arguments.
   const intptr_t typeargs_offset =
       GrowableObjectArray::type_arguments_offset() / kWordSize;
   *reader->TypeArgumentsHandle() ^=
       reader->ReadObjectImpl(kAsInlinedObject, object_id, typeargs_offset);
   map.SetTypeArguments(*reader->TypeArgumentsHandle());
 
   // Read the number of key/value pairs.
   intptr_t len = reader->ReadSmiValue();
   intptr_t used_data = (len << 1);
   map.SetUsedData(used_data);
 
   // Allocate the data array.
-  intptr_t data_size = Utils::Maximum(
-      Utils::RoundUpToPowerOfTwo(used_data),
-      static_cast<uintptr_t>(LinkedHashMap::kInitialIndexSize));
+  intptr_t data_size =
+      Utils::Maximum(Utils::RoundUpToPowerOfTwo(used_data),
+                     static_cast<uintptr_t>(LinkedHashMap::kInitialIndexSize));
   Array& data = Array::ZoneHandle(reader->zone(),
                                   Array::New(data_size, HEAP_SPACE(kind)));
   map.SetData(data);
   map.SetDeletedKeys(0);
 
   // The index and hashMask is regenerated by the maps themselves on demand.
   // Thus, the index will probably be allocated in new space (unless it's huge).
   // TODO(koda): Eagerly rehash here when no keys have user-defined '==', and
   // in particular, if/when (const) maps are needed in the VM isolate snapshot.
   ASSERT(reader->isolate() != Dart::vm_isolate());
@@ skipping 66 matching lines @@
                                   Snapshot::Kind kind,
                                   bool as_reference) {
   ASSERT(reader != NULL);
   // Read the values.
   float value0 = reader->Read<float>();
   float value1 = reader->Read<float>();
   float value2 = reader->Read<float>();
   float value3 = reader->Read<float>();
 
   // Create a Float32x4 object.
-  Float32x4& simd = Float32x4::ZoneHandle(reader->zone(),
-                                          Float32x4::null());
+  Float32x4& simd = Float32x4::ZoneHandle(reader->zone(), Float32x4::null());
   simd = Float32x4::New(value0, value1, value2, value3, HEAP_SPACE(kind));
   reader->AddBackRef(object_id, &simd, kIsDeserialized);
   return simd.raw();
 }
 
 
 void RawFloat32x4::WriteTo(SnapshotWriter* writer,
                            intptr_t object_id,
                            Snapshot::Kind kind,
                            bool as_reference) {
@@ skipping 59 matching lines @@
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind,
                                   bool as_reference) {
   ASSERT(reader != NULL);
   // Read the values.
   double value0 = reader->Read<double>();
   double value1 = reader->Read<double>();
 
   // Create a Float64x2 object.
-  Float64x2& simd = Float64x2::ZoneHandle(reader->zone(),
-                                          Float64x2::null());
+  Float64x2& simd = Float64x2::ZoneHandle(reader->zone(), Float64x2::null());
   simd = Float64x2::New(value0, value1, HEAP_SPACE(kind));
   reader->AddBackRef(object_id, &simd, kIsDeserialized);
   return simd.raw();
 }
 
 
 void RawFloat64x2::WriteTo(SnapshotWriter* writer,
                            intptr_t object_id,
                            Snapshot::Kind kind,
                            bool as_reference) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kFloat64x2Cid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the float values.
   writer->Write<double>(ptr()->value_[0]);
   writer->Write<double>(ptr()->value_[1]);
 }
 
 
 #define TYPED_DATA_READ(setter, type)                                          \
   for (intptr_t i = 0; i < length_in_bytes; i += element_size) {               \
     result.Set##setter(i, reader->Read<type>());                               \
-  }                                                                            \
+  }
 
 
 RawTypedData* TypedData::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind,
                                   bool as_reference) {
   ASSERT(reader != NULL);
 
   intptr_t cid = RawObject::ClassIdTag::decode(tags);
@@ skipping 58 matching lines @@
 
 RawExternalTypedData* ExternalTypedData::ReadFrom(SnapshotReader* reader,
                                                   intptr_t object_id,
                                                   intptr_t tags,
                                                   Snapshot::Kind kind,
                                                   bool as_reference) {
   ASSERT(!Snapshot::IsFull(kind));
   intptr_t cid = RawObject::ClassIdTag::decode(tags);
   intptr_t length = reader->ReadSmiValue();
   uint8_t* data = reinterpret_cast<uint8_t*>(reader->ReadRawPointerValue());
-  ExternalTypedData& obj = ExternalTypedData::ZoneHandle(
-      ExternalTypedData::New(cid, data, length));
+  ExternalTypedData& obj =
+      ExternalTypedData::ZoneHandle(ExternalTypedData::New(cid, data, length));
   reader->AddBackRef(object_id, &obj, kIsDeserialized);
   void* peer = reinterpret_cast<void*>(reader->ReadRawPointerValue());
   Dart_WeakPersistentHandleFinalizer callback =
       reinterpret_cast<Dart_WeakPersistentHandleFinalizer>(
           reader->ReadRawPointerValue());
   intptr_t external_size = obj.LengthInBytes();
   obj.AddFinalizer(peer, callback, external_size);
   return obj.raw();
 }
 
 
 #define TYPED_DATA_WRITE(type)                                                 \
   {                                                                            \
     type* data = reinterpret_cast<type*>(ptr()->data());                       \
     for (intptr_t i = 0; i < len; i++) {                                       \
       writer->Write(data[i]);                                                  \
     }                                                                          \
-  }                                                                            \
+  }
 
 
 void RawTypedData::WriteTo(SnapshotWriter* writer,
                            intptr_t object_id,
                            Snapshot::Kind kind,
                            bool as_reference) {
   ASSERT(writer != NULL);
   intptr_t cid = this->GetClassId();
   intptr_t len = Smi::Value(ptr()->length_);
 
@@ skipping 45 matching lines @@
   }
 }
 
 
 #define TYPED_EXT_DATA_WRITE(type)                                             \
   {                                                                            \
     type* data = reinterpret_cast<type*>(ptr()->data_);                        \
     for (intptr_t i = 0; i < len; i++) {                                       \
       writer->Write(data[i]);                                                  \
     }                                                                          \
-  }                                                                            \
+  }
 
 
 #define EXT_TYPED_DATA_WRITE(cid, type)                                        \
   writer->WriteIndexedObject(cid);                                             \
   writer->WriteTags(writer->GetObjectTags(this));                              \
   writer->Write<RawObject*>(ptr()->length_);                                   \
-  TYPED_EXT_DATA_WRITE(type)                                                   \
+  TYPED_EXT_DATA_WRITE(type)
 
 
 void RawExternalTypedData::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind,
                                    bool as_reference) {
   ASSERT(writer != NULL);
   intptr_t cid = this->GetClassId();
   intptr_t len = Smi::Value(ptr()->length_);
 
@@ skipping 42 matching lines @@
 #undef EXT_TYPED_DATA_WRITE
 
 
 RawCapability* Capability::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind,
                                     bool as_reference) {
   uint64_t id = reader->Read<uint64_t>();
 
-  Capability& result = Capability::ZoneHandle(reader->zone(),
-                                              Capability::New(id));
+  Capability& result =
+      Capability::ZoneHandle(reader->zone(), Capability::New(id));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
   return result.raw();
 }
 
 
 void RawCapability::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind,
                             bool as_reference) {
   // Write out the serialization header value for this object.
@@ skipping 36 matching lines @@
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind,
                                 bool as_reference) {
   ASSERT(kind == Snapshot::kMessage);
 
   uint64_t id = reader->Read<uint64_t>();
   uint64_t origin_id = reader->Read<uint64_t>();
 
   SendPort& result =
-      SendPort::ZoneHandle(reader->zone(),
-                           SendPort::New(id, origin_id));
+      SendPort::ZoneHandle(reader->zone(), SendPort::New(id, origin_id));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
   return result.raw();
 }
 
 
 void RawSendPort::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind,
                           bool as_reference) {
   // Write out the serialization header value for this object.
@@ skipping 40 matching lines @@
   RegExp& regex = RegExp::ZoneHandle(reader->zone(), RegExp::New());
   reader->AddBackRef(object_id, &regex, kIsDeserialized);
 
   // Read and Set all the other fields.
   regex.StoreSmi(&regex.raw_ptr()->num_bracket_expressions_,
                  reader->ReadAsSmi());
   *reader->StringHandle() ^= reader->ReadObjectImpl(kAsInlinedObject);
   regex.set_pattern(*reader->StringHandle());
   regex.StoreNonPointer(&regex.raw_ptr()->num_registers_,
                         reader->Read<int32_t>());
-  regex.StoreNonPointer(&regex.raw_ptr()->type_flags_,
-                        reader->Read<int8_t>());
+  regex.StoreNonPointer(&regex.raw_ptr()->type_flags_, reader->Read<int8_t>());
 
   // TODO(18854): Need to implement a way of recreating the irrexp functions.
   const Function& no_function = Function::Handle(reader->zone());
   regex.set_function(kOneByteStringCid, no_function);
   regex.set_function(kTwoByteStringCid, no_function);
   regex.set_function(kExternalOneByteStringCid, no_function);
   regex.set_function(kExternalTwoByteStringCid, no_function);
 
   const TypedData& no_bytecode = TypedData::Handle(reader->zone());
   regex.set_bytecode(true, no_bytecode);
@@ skipping 25 matching lines @@
 
 
 RawWeakProperty* WeakProperty::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind,
                                         bool as_reference) {
   ASSERT(reader != NULL);
 
   // Allocate the weak property object.
-  WeakProperty& weak_property = WeakProperty::ZoneHandle(reader->zone(),
-                                                         WeakProperty::New());
+  WeakProperty& weak_property =
+      WeakProperty::ZoneHandle(reader->zone(), WeakProperty::New());
   reader->AddBackRef(object_id, &weak_property, kIsDeserialized);
 
   // Set all the object fields.
-  READ_OBJECT_FIELDS(weak_property,
-                     weak_property.raw()->from(), weak_property.raw()->to(),
-                     kAsReference);
+  READ_OBJECT_FIELDS(weak_property, weak_property.raw()->from(),
+                     weak_property.raw()->to(), kAsReference);
 
   return weak_property.raw();
 }
 
 
 void RawWeakProperty::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind,
                               bool as_reference) {
   ASSERT(writer != NULL);
@@ skipping 54 matching lines @@
     // We do not allow objects with native fields in an isolate message.
     writer->SetWriteException(Exceptions::kArgument,
                               "Illegal argument in isolate message"
                               " : (object is a UserTag)");
   } else {
     UNREACHABLE();
   }
 }
 
 }  // namespace dart