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

runtime/vm/clustered_snapshot.cc

 // Copyright (c) 2016, 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/clustered_snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 15 matching lines @@
 static RawObject* AllocateUninitialized(PageSpace* old_space, intptr_t size) {
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   uword address =
       old_space->TryAllocateDataBumpLocked(size, PageSpace::kForceGrowth);
   if (address == 0) {
     OUT_OF_MEMORY();
   }
   return reinterpret_cast<RawObject*>(address + kHeapObjectTag);
 }
 
-
 void Deserializer::InitializeHeader(RawObject* raw,
                                     intptr_t class_id,
                                     intptr_t size,
                                     bool is_vm_isolate,
                                     bool is_canonical) {
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   uint32_t tags = 0;
   tags = RawObject::ClassIdTag::update(class_id, tags);
   tags = RawObject::SizeTag::update(size, tags);
   tags = RawObject::VMHeapObjectTag::update(is_vm_isolate, tags);
   tags = RawObject::CanonicalObjectTag::update(is_canonical, tags);
   raw->ptr()->tags_ = tags;
 #if defined(HASH_IN_OBJECT_HEADER)
   raw->ptr()->hash_ = 0;
 #endif
 }
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ClassSerializationCluster : public SerializationCluster {
  public:
   explicit ClassSerializationCluster(intptr_t num_cids)
       : predefined_(kNumPredefinedCids), objects_(num_cids) {}
   virtual ~ClassSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawClass* cls = Class::RawCast(object);
     intptr_t class_id = cls->ptr()->id_;
@@ skipping 64 matching lines @@
     s->WriteTokenPosition(cls->ptr()->token_pos_);
     s->Write<uint16_t>(cls->ptr()->state_bits_);
   }
 
  private:
   GrowableArray<RawClass*> predefined_;
   GrowableArray<RawClass*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class ClassDeserializationCluster : public DeserializationCluster {
  public:
   ClassDeserializationCluster() {}
   virtual ~ClassDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     predefined_start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     ClassTable* table = d->isolate()->class_table();
@@ skipping 94 matching lines @@
       cls ^= refs.At(i);
       cls.RehashConstants(zone);
     }
   }
 
  private:
   intptr_t predefined_start_index_;
   intptr_t predefined_stop_index_;
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class UnresolvedClassSerializationCluster : public SerializationCluster {
  public:
   UnresolvedClassSerializationCluster() {}
   virtual ~UnresolvedClassSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawUnresolvedClass* cls = UnresolvedClass::RawCast(object);
     objects_.Add(cls);
 
@@ skipping 26 matching lines @@
       }
       s->WriteTokenPosition(cls->ptr()->token_pos_);
     }
   }
 
  private:
   GrowableArray<RawUnresolvedClass*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class UnresolvedClassDeserializationCluster : public DeserializationCluster {
  public:
   UnresolvedClassDeserializationCluster() {}
   virtual ~UnresolvedClassDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 15 matching lines @@
       RawObject** from = cls->from();
       RawObject** to = cls->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
       cls->ptr()->token_pos_ = d->ReadTokenPosition();
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class TypeArgumentsSerializationCluster : public SerializationCluster {
  public:
   TypeArgumentsSerializationCluster() {}
   virtual ~TypeArgumentsSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawTypeArguments* type_args = TypeArguments::RawCast(object);
     objects_.Add(type_args);
 
@@ skipping 30 matching lines @@
         s->WriteRef(type_args->ptr()->types()[j]);
       }
     }
   }
 
  private:
   GrowableArray<RawTypeArguments*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class TypeArgumentsDeserializationCluster : public DeserializationCluster {
  public:
   TypeArgumentsDeserializationCluster() {}
   virtual ~TypeArgumentsDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 20 matching lines @@
       type_args->ptr()->instantiations_ =
           reinterpret_cast<RawArray*>(d->ReadRef());
       for (intptr_t j = 0; j < length; j++) {
         type_args->ptr()->types()[j] =
             reinterpret_cast<RawAbstractType*>(d->ReadRef());
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class PatchClassSerializationCluster : public SerializationCluster {
  public:
   PatchClassSerializationCluster() {}
   virtual ~PatchClassSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawPatchClass* cls = PatchClass::RawCast(object);
     objects_.Add(cls);
 
@@ skipping 24 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawPatchClass*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class PatchClassDeserializationCluster : public DeserializationCluster {
  public:
   PatchClassDeserializationCluster() {}
   virtual ~PatchClassDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 12 matching lines @@
                                      PatchClass::InstanceSize(), is_vm_object);
       RawObject** from = cls->from();
       RawObject** to = cls->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class FunctionSerializationCluster : public SerializationCluster {
  public:
   FunctionSerializationCluster() {}
   virtual ~FunctionSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawFunction* func = Function::RawCast(object);
     objects_.Add(func);
 
@@ skipping 61 matching lines @@
 #endif
       }
     }
   }
 
  private:
   GrowableArray<RawFunction*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class FunctionDeserializationCluster : public DeserializationCluster {
  public:
   FunctionDeserializationCluster() {}
   virtual ~FunctionDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 90 matching lines @@
       for (intptr_t i = start_index_; i < stop_index_; i++) {
         func ^= refs.At(i);
         func.ClearICDataArray();
         func.ClearCode();
         func.set_was_compiled(false);
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ClosureDataSerializationCluster : public SerializationCluster {
  public:
   ClosureDataSerializationCluster() {}
   virtual ~ClosureDataSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawClosureData* data = ClosureData::RawCast(object);
     objects_.Add(data);
 
@@ skipping 26 matching lines @@
       s->WriteRef(data->ptr()->signature_type_);
       s->WriteRef(data->ptr()->closure_);
     }
   }
 
  private:
   GrowableArray<RawClosureData*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class ClosureDataDeserializationCluster : public DeserializationCluster {
  public:
   ClosureDataDeserializationCluster() {}
   virtual ~ClosureDataDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 17 matching lines @@
             static_cast<RawContextScope*>(d->ReadRef());
       }
       data->ptr()->parent_function_ = static_cast<RawFunction*>(d->ReadRef());
       data->ptr()->signature_type_ = static_cast<RawType*>(d->ReadRef());
       data->ptr()->closure_ = static_cast<RawInstance*>(d->ReadRef());
       data->ptr()->hash_ = Object::null();
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class SignatureDataSerializationCluster : public SerializationCluster {
  public:
   SignatureDataSerializationCluster() {}
   virtual ~SignatureDataSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawSignatureData* data = SignatureData::RawCast(object);
     objects_.Add(data);
 
@@ skipping 24 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawSignatureData*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class SignatureDataDeserializationCluster : public DeserializationCluster {
  public:
   SignatureDataDeserializationCluster() {}
   virtual ~SignatureDataDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 12 matching lines @@
           data, kSignatureDataCid, SignatureData::InstanceSize(), is_vm_object);
       RawObject** from = data->from();
       RawObject** to = data->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class RedirectionDataSerializationCluster : public SerializationCluster {
  public:
   RedirectionDataSerializationCluster() {}
   virtual ~RedirectionDataSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawRedirectionData* data = RedirectionData::RawCast(object);
     objects_.Add(data);
 
@@ skipping 24 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawRedirectionData*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class RedirectionDataDeserializationCluster : public DeserializationCluster {
  public:
   RedirectionDataDeserializationCluster() {}
   virtual ~RedirectionDataDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 14 matching lines @@
                                      is_vm_object);
       RawObject** from = data->from();
       RawObject** to = data->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class FieldSerializationCluster : public SerializationCluster {
  public:
   FieldSerializationCluster() {}
   virtual ~FieldSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawField* field = Field::RawCast(object);
     objects_.Add(field);
 
@@ skipping 89 matching lines @@
       }
       s->Write<uint8_t>(field->ptr()->kind_bits_);
     }
   }
 
  private:
   GrowableArray<RawField*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class FieldDeserializationCluster : public DeserializationCluster {
  public:
   FieldDeserializationCluster() {}
   virtual ~FieldDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 45 matching lines @@
       }
     } else {
       for (intptr_t i = start_index_; i < stop_index_; i++) {
         field ^= refs.At(i);
         field.InitializeGuardedListLengthInObjectOffset();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class LiteralTokenSerializationCluster : public SerializationCluster {
  public:
   LiteralTokenSerializationCluster() {}
   virtual ~LiteralTokenSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawLiteralToken* token = LiteralToken::RawCast(object);
     objects_.Add(token);
 
@@ skipping 25 matching lines @@
       }
       s->Write<int32_t>(token->ptr()->kind_);
     }
   }
 
  private:
   GrowableArray<RawLiteralToken*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class LiteralTokenDeserializationCluster : public DeserializationCluster {
  public:
   LiteralTokenDeserializationCluster() {}
   virtual ~LiteralTokenDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 13 matching lines @@
       RawObject** from = token->from();
       RawObject** to = token->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
       token->ptr()->kind_ = static_cast<Token::Kind>(d->Read<int32_t>());
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class TokenStreamSerializationCluster : public SerializationCluster {
  public:
   TokenStreamSerializationCluster() {}
   virtual ~TokenStreamSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawTokenStream* stream = TokenStream::RawCast(object);
     objects_.Add(stream);
 
@@ skipping 24 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawTokenStream*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class TokenStreamDeserializationCluster : public DeserializationCluster {
  public:
   TokenStreamDeserializationCluster() {}
   virtual ~TokenStreamDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 12 matching lines @@
                                      TokenStream::InstanceSize(), is_vm_object);
       RawObject** from = stream->from();
       RawObject** to = stream->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ScriptSerializationCluster : public SerializationCluster {
  public:
   ScriptSerializationCluster() {}
   virtual ~ScriptSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawScript* script = Script::RawCast(object);
     objects_.Add(script);
 
@@ skipping 29 matching lines @@
       s->Write<int32_t>(script->ptr()->col_offset_);
       s->Write<int8_t>(script->ptr()->kind_);
     }
   }
 
  private:
   GrowableArray<RawScript*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class ScriptDeserializationCluster : public DeserializationCluster {
  public:
   ScriptDeserializationCluster() {}
   virtual ~ScriptDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 21 matching lines @@
       }
 
       script->ptr()->line_offset_ = d->Read<int32_t>();
       script->ptr()->col_offset_ = d->Read<int32_t>();
       script->ptr()->kind_ = d->Read<int8_t>();
       script->ptr()->load_timestamp_ = 0;
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class LibrarySerializationCluster : public SerializationCluster {
  public:
   LibrarySerializationCluster() {}
   virtual ~LibrarySerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawLibrary* lib = Library::RawCast(object);
     objects_.Add(lib);
 
@@ skipping 31 matching lines @@
       s->Write<bool>(lib->ptr()->is_dart_scheme_);
       s->Write<bool>(lib->ptr()->debuggable_);
     }
   }
 
  private:
   GrowableArray<RawLibrary*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class LibraryDeserializationCluster : public DeserializationCluster {
  public:
   LibraryDeserializationCluster() {}
   virtual ~LibraryDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 25 matching lines @@
       lib->ptr()->num_imports_ = d->Read<uint16_t>();
       lib->ptr()->load_state_ = d->Read<int8_t>();
       lib->ptr()->corelib_imported_ = d->Read<bool>();
       lib->ptr()->is_dart_scheme_ = d->Read<bool>();
       lib->ptr()->debuggable_ = d->Read<bool>();
       lib->ptr()->is_in_fullsnapshot_ = true;
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class NamespaceSerializationCluster : public SerializationCluster {
  public:
   NamespaceSerializationCluster() {}
   virtual ~NamespaceSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawNamespace* ns = Namespace::RawCast(object);
     objects_.Add(ns);
 
@@ skipping 24 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawNamespace*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class NamespaceDeserializationCluster : public DeserializationCluster {
  public:
   NamespaceDeserializationCluster() {}
   virtual ~NamespaceDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 11 matching lines @@
                                      Namespace::InstanceSize(), is_vm_object);
       RawObject** from = ns->from();
       RawObject** to = ns->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class CodeSerializationCluster : public SerializationCluster {
  public:
   CodeSerializationCluster() {}
   virtual ~CodeSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawCode* code = Code::RawCast(object);
     objects_.Add(code);
 
@@ skipping 89 matching lines @@
 
       s->Write<int32_t>(code->ptr()->state_bits_);
     }
   }
 
  private:
   GrowableArray<RawCode*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class CodeDeserializationCluster : public DeserializationCluster {
  public:
   CodeDeserializationCluster() {}
   virtual ~CodeDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 74 matching lines @@
       code->ptr()->comments_ = Array::null();
 
       code->ptr()->compile_timestamp_ = 0;
 #endif  // !DART_PRECOMPILED_RUNTIME
 
       code->ptr()->state_bits_ = d->Read<int32_t>();
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ObjectPoolSerializationCluster : public SerializationCluster {
  public:
   ObjectPoolSerializationCluster() {}
   virtual ~ObjectPoolSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawObjectPool* pool = ObjectPool::RawCast(object);
     objects_.Add(pool);
 
@@ skipping 68 matching lines @@
         }
       }
     }
   }
 
  private:
   GrowableArray<RawObjectPool*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class ObjectPoolDeserializationCluster : public DeserializationCluster {
  public:
   ObjectPoolDeserializationCluster() {}
   virtual ~ObjectPoolDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 43 matching lines @@
             break;
           }
           default:
             UNREACHABLE();
         }
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 // PcDescriptor, StackMap, OneByteString, TwoByteString
 class RODataSerializationCluster : public SerializationCluster {
  public:
   explicit RODataSerializationCluster(intptr_t cid) : cid_(cid) {}
   virtual ~RODataSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     objects_.Add(object);
 
@@ skipping 33 matching lines @@
   void WriteFill(Serializer* s) {
     // No-op.
   }
 
  private:
   const intptr_t cid_;
   GrowableArray<RawObject*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class RODataDeserializationCluster : public DeserializationCluster {
  public:
   RODataDeserializationCluster() {}
   virtual ~RODataDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       int32_t rodata_offset = d->Read<int32_t>();
       d->AssignRef(d->GetObjectAt(rodata_offset));
     }
   }
 
   void ReadFill(Deserializer* d) {
     // No-op.
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ExceptionHandlersSerializationCluster : public SerializationCluster {
  public:
   ExceptionHandlersSerializationCluster() {}
   virtual ~ExceptionHandlersSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawExceptionHandlers* handlers = ExceptionHandlers::RawCast(object);
     objects_.Add(handlers);
 
@@ skipping 24 matching lines @@
       intptr_t length_in_bytes = length * sizeof(ExceptionHandlerInfo);
       s->WriteBytes(data, length_in_bytes);
     }
   }
 
  private:
   GrowableArray<RawExceptionHandlers*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class ExceptionHandlersDeserializationCluster : public DeserializationCluster {
  public:
   ExceptionHandlersDeserializationCluster() {}
   virtual ~ExceptionHandlersDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 65 matching lines @@
         s->WriteRef(context->ptr()->data()[j]);
       }
     }
   }
 
  private:
   GrowableArray<RawContext*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class ContextDeserializationCluster : public DeserializationCluster {
  public:
   ContextDeserializationCluster() {}
   virtual ~ContextDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 14 matching lines @@
           context, kContextCid, Context::InstanceSize(length), is_vm_object);
       context->ptr()->num_variables_ = length;
       context->ptr()->parent_ = reinterpret_cast<RawContext*>(d->ReadRef());
       for (intptr_t j = 0; j < length; j++) {
         context->ptr()->data()[j] = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ContextScopeSerializationCluster : public SerializationCluster {
  public:
   ContextScopeSerializationCluster() {}
   virtual ~ContextScopeSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawContextScope* scope = ContextScope::RawCast(object);
     objects_.Add(scope);
 
@@ skipping 30 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawContextScope*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class ContextScopeDeserializationCluster : public DeserializationCluster {
  public:
   ContextScopeDeserializationCluster() {}
   virtual ~ContextScopeDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 17 matching lines @@
       scope->ptr()->is_implicit_ = d->Read<bool>();
       RawObject** from = scope->from();
       RawObject** to = scope->to(length);
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class UnlinkedCallSerializationCluster : public SerializationCluster {
  public:
   UnlinkedCallSerializationCluster() {}
   virtual ~UnlinkedCallSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawUnlinkedCall* unlinked = UnlinkedCall::RawCast(object);
     objects_.Add(unlinked);
 
@@ skipping 24 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawUnlinkedCall*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class UnlinkedCallDeserializationCluster : public DeserializationCluster {
  public:
   UnlinkedCallDeserializationCluster() {}
   virtual ~UnlinkedCallDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 14 matching lines @@
                                      is_vm_object);
       RawObject** from = unlinked->from();
       RawObject** to = unlinked->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ICDataSerializationCluster : public SerializationCluster {
  public:
   ICDataSerializationCluster() {}
   virtual ~ICDataSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawICData* ic = ICData::RawCast(object);
     objects_.Add(ic);
 
@@ skipping 32 matching lines @@
       s->Write<int32_t>(ic->ptr()->tag_);
 #endif
     }
   }
 
  private:
   GrowableArray<RawICData*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class ICDataDeserializationCluster : public DeserializationCluster {
  public:
   ICDataDeserializationCluster() {}
   virtual ~ICDataDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 21 matching lines @@
       }
       NOT_IN_PRECOMPILED(ic->ptr()->deopt_id_ = d->Read<int32_t>());
       ic->ptr()->state_bits_ = d->Read<int32_t>();
 #if defined(TAG_IC_DATA)
       ic->ptr()->tag_ = d->Read<int32_t>();
 #endif
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class MegamorphicCacheSerializationCluster : public SerializationCluster {
  public:
   MegamorphicCacheSerializationCluster() {}
   virtual ~MegamorphicCacheSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawMegamorphicCache* cache = MegamorphicCache::RawCast(object);
     objects_.Add(cache);
 
@@ skipping 25 matching lines @@
       }
       s->Write<int32_t>(cache->ptr()->filled_entry_count_);
     }
   }
 
  private:
   GrowableArray<RawMegamorphicCache*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class MegamorphicCacheDeserializationCluster : public DeserializationCluster {
  public:
   MegamorphicCacheDeserializationCluster() {}
   virtual ~MegamorphicCacheDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 15 matching lines @@
       RawObject** from = cache->from();
       RawObject** to = cache->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
       cache->ptr()->filled_entry_count_ = d->Read<int32_t>();
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class SubtypeTestCacheSerializationCluster : public SerializationCluster {
  public:
   SubtypeTestCacheSerializationCluster() {}
   virtual ~SubtypeTestCacheSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawSubtypeTestCache* cache = SubtypeTestCache::RawCast(object);
     objects_.Add(cache);
     s->Push(cache->ptr()->cache_);
@@ skipping 15 matching lines @@
       RawSubtypeTestCache* cache = objects_[i];
       s->WriteRef(cache->ptr()->cache_);
     }
   }
 
  private:
   GrowableArray<RawSubtypeTestCache*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class SubtypeTestCacheDeserializationCluster : public DeserializationCluster {
  public:
   SubtypeTestCacheDeserializationCluster() {}
   virtual ~SubtypeTestCacheDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 10 matching lines @@
       RawSubtypeTestCache* cache =
           reinterpret_cast<RawSubtypeTestCache*>(d->Ref(id));
       Deserializer::InitializeHeader(cache, kSubtypeTestCacheCid,
                                      SubtypeTestCache::InstanceSize(),
                                      is_vm_object);
       cache->ptr()->cache_ = reinterpret_cast<RawArray*>(d->ReadRef());
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class LanguageErrorSerializationCluster : public SerializationCluster {
  public:
   LanguageErrorSerializationCluster() {}
   virtual ~LanguageErrorSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawLanguageError* error = LanguageError::RawCast(object);
     objects_.Add(error);
 
@@ skipping 27 matching lines @@
       s->Write<bool>(error->ptr()->report_after_token_);
       s->Write<int8_t>(error->ptr()->kind_);
     }
   }
 
  private:
   GrowableArray<RawLanguageError*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class LanguageErrorDeserializationCluster : public DeserializationCluster {
  public:
   LanguageErrorDeserializationCluster() {}
   virtual ~LanguageErrorDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 16 matching lines @@
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
       error->ptr()->token_pos_ = d->ReadTokenPosition();
       error->ptr()->report_after_token_ = d->Read<bool>();
       error->ptr()->kind_ = d->Read<int8_t>();
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class UnhandledExceptionSerializationCluster : public SerializationCluster {
  public:
   UnhandledExceptionSerializationCluster() {}
   virtual ~UnhandledExceptionSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawUnhandledException* exception = UnhandledException::RawCast(object);
     objects_.Add(exception);
 
@@ skipping 24 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawUnhandledException*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class UnhandledExceptionDeserializationCluster : public DeserializationCluster {
  public:
   UnhandledExceptionDeserializationCluster() {}
   virtual ~UnhandledExceptionDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 14 matching lines @@
                                      is_vm_object);
       RawObject** from = exception->from();
       RawObject** to = exception->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class InstanceSerializationCluster : public SerializationCluster {
  public:
   explicit InstanceSerializationCluster(intptr_t cid) : cid_(cid) {
     RawClass* cls = Isolate::Current()->class_table()->At(cid);
     next_field_offset_in_words_ = cls->ptr()->next_field_offset_in_words_;
     instance_size_in_words_ = cls->ptr()->instance_size_in_words_;
     ASSERT(next_field_offset_in_words_ > 0);
     ASSERT(instance_size_in_words_ > 0);
   }
@@ skipping 44 matching lines @@
   }
 
  private:
   const intptr_t cid_;
   intptr_t next_field_offset_in_words_;
   intptr_t instance_size_in_words_;
   GrowableArray<RawInstance*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class InstanceDeserializationCluster : public DeserializationCluster {
  public:
   explicit InstanceDeserializationCluster(intptr_t cid) : cid_(cid) {}
   virtual ~InstanceDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     next_field_offset_in_words_ = d->Read<int32_t>();
@@ skipping 33 matching lines @@
       ASSERT(offset == instance_size);
     }
   }
 
  private:
   const intptr_t cid_;
   intptr_t next_field_offset_in_words_;
   intptr_t instance_size_in_words_;
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class LibraryPrefixSerializationCluster : public SerializationCluster {
  public:
   LibraryPrefixSerializationCluster() {}
   virtual ~LibraryPrefixSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawLibraryPrefix* prefix = LibraryPrefix::RawCast(object);
     objects_.Add(prefix);
 
@@ skipping 27 matching lines @@
       s->Write<uint16_t>(prefix->ptr()->num_imports_);
       s->Write<bool>(prefix->ptr()->is_deferred_load_);
     }
   }
 
  private:
   GrowableArray<RawLibraryPrefix*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class LibraryPrefixDeserializationCluster : public DeserializationCluster {
  public:
   LibraryPrefixDeserializationCluster() {}
   virtual ~LibraryPrefixDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 23 matching lines @@
         *p = Object::null();
       }
 
       prefix->ptr()->num_imports_ = d->Read<uint16_t>();
       prefix->ptr()->is_deferred_load_ = d->Read<bool>();
       prefix->ptr()->is_loaded_ = !prefix->ptr()->is_deferred_load_;
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class TypeSerializationCluster : public SerializationCluster {
  public:
   TypeSerializationCluster() {}
   virtual ~TypeSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawType* type = Type::RawCast(object);
     if (type->IsCanonical()) {
       canonical_objects_.Add(type);
@@ skipping 58 matching lines @@
       s->Write<int8_t>(type->ptr()->type_state_);
     }
   }
 
  private:
   GrowableArray<RawType*> canonical_objects_;
   GrowableArray<RawType*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class TypeDeserializationCluster : public DeserializationCluster {
  public:
   TypeDeserializationCluster() {}
   virtual ~TypeDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     canonical_start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 38 matching lines @@
       type->ptr()->token_pos_ = d->ReadTokenPosition();
       type->ptr()->type_state_ = d->Read<int8_t>();
     }
   }
 
  private:
   intptr_t canonical_start_index_;
   intptr_t canonical_stop_index_;
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class TypeRefSerializationCluster : public SerializationCluster {
  public:
   TypeRefSerializationCluster() {}
   virtual ~TypeRefSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawTypeRef* type = TypeRef::RawCast(object);
     objects_.Add(type);
 
@@ skipping 24 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawTypeRef*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class TypeRefDeserializationCluster : public DeserializationCluster {
  public:
   TypeRefDeserializationCluster() {}
   virtual ~TypeRefDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 11 matching lines @@
                                      is_vm_object);
       RawObject** from = type->from();
       RawObject** to = type->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class TypeParameterSerializationCluster : public SerializationCluster {
  public:
   TypeParameterSerializationCluster() {}
   virtual ~TypeParameterSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawTypeParameter* type = TypeParameter::RawCast(object);
     objects_.Add(type);
     ASSERT(!type->IsCanonical());
@@ skipping 29 matching lines @@
       s->Write<int16_t>(type->ptr()->index_);
       s->Write<int8_t>(type->ptr()->type_state_);
     }
   }
 
  private:
   GrowableArray<RawTypeParameter*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class TypeParameterDeserializationCluster : public DeserializationCluster {
  public:
   TypeParameterDeserializationCluster() {}
   virtual ~TypeParameterDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 16 matching lines @@
         *p = d->ReadRef();
       }
       type->ptr()->parameterized_class_id_ = d->Read<int32_t>();
       type->ptr()->token_pos_ = d->ReadTokenPosition();
       type->ptr()->index_ = d->Read<int16_t>();
       type->ptr()->type_state_ = d->Read<int8_t>();
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class BoundedTypeSerializationCluster : public SerializationCluster {
  public:
   BoundedTypeSerializationCluster() {}
   virtual ~BoundedTypeSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawBoundedType* type = BoundedType::RawCast(object);
     objects_.Add(type);
 
@@ skipping 24 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawBoundedType*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class BoundedTypeDeserializationCluster : public DeserializationCluster {
  public:
   BoundedTypeDeserializationCluster() {}
   virtual ~BoundedTypeDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 12 matching lines @@
                                      BoundedType::InstanceSize(), is_vm_object);
       RawObject** from = type->from();
       RawObject** to = type->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ClosureSerializationCluster : public SerializationCluster {
  public:
   ClosureSerializationCluster() {}
   virtual ~ClosureSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawClosure* closure = Closure::RawCast(object);
     objects_.Add(closure);
 
@@ skipping 25 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawClosure*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class ClosureDeserializationCluster : public DeserializationCluster {
  public:
   ClosureDeserializationCluster() {}
   virtual ~ClosureDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 13 matching lines @@
                                      is_canonical);
       RawObject** from = closure->from();
       RawObject** to = closure->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class MintSerializationCluster : public SerializationCluster {
  public:
   MintSerializationCluster() {}
   virtual ~MintSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     if (!object->IsHeapObject()) {
       RawSmi* smi = Smi::RawCast(object);
       smis_.Add(smi);
@@ skipping 22 matching lines @@
   }
 
   void WriteFill(Serializer* s) {}
 
  private:
   GrowableArray<RawSmi*> smis_;
   GrowableArray<RawMint*> mints_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class MintDeserializationCluster : public DeserializationCluster {
  public:
   MintDeserializationCluster() {}
   virtual ~MintDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     PageSpace* old_space = d->heap()->old_space();
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     start_index_ = d->next_index();
@@ skipping 31 matching lines @@
       }
     }
     const Array& constants_array =
         Array::Handle(zone, Array::MakeFixedLength(new_constants));
     const Class& mint_cls =
         Class::Handle(zone, Isolate::Current()->object_store()->mint_class());
     mint_cls.set_constants(constants_array);
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class BigintSerializationCluster : public SerializationCluster {
  public:
   BigintSerializationCluster() {}
   virtual ~BigintSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawBigint* bigint = Bigint::RawCast(object);
     objects_.Add(bigint);
 
@@ skipping 25 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawBigint*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class BigintDeserializationCluster : public DeserializationCluster {
  public:
   BigintDeserializationCluster() {}
   virtual ~BigintDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 12 matching lines @@
                                      is_vm_object, is_canonical);
       RawObject** from = bigint->from();
       RawObject** to = bigint->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class DoubleSerializationCluster : public SerializationCluster {
  public:
   DoubleSerializationCluster() {}
   virtual ~DoubleSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawDouble* dbl = Double::RawCast(object);
     objects_.Add(dbl);
   }
@@ skipping 15 matching lines @@
       s->Write<bool>(dbl->IsCanonical());
       s->Write<double>(dbl->ptr()->value_);
     }
   }
 
  private:
   GrowableArray<RawDouble*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class DoubleDeserializationCluster : public DeserializationCluster {
  public:
   DoubleDeserializationCluster() {}
   virtual ~DoubleDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
       d->AssignRef(AllocateUninitialized(old_space, Double::InstanceSize()));
     }
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawDouble* dbl = reinterpret_cast<RawDouble*>(d->Ref(id));
       bool is_canonical = d->Read<bool>();
       Deserializer::InitializeHeader(dbl, kDoubleCid, Double::InstanceSize(),
                                      is_vm_object, is_canonical);
       dbl->ptr()->value_ = d->Read<double>();
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class GrowableObjectArraySerializationCluster : public SerializationCluster {
  public:
   GrowableObjectArraySerializationCluster() {}
   virtual ~GrowableObjectArraySerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawGrowableObjectArray* array = GrowableObjectArray::RawCast(object);
     objects_.Add(array);
 
@@ skipping 25 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawGrowableObjectArray*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class GrowableObjectArrayDeserializationCluster
     : public DeserializationCluster {
  public:
   GrowableObjectArrayDeserializationCluster() {}
   virtual ~GrowableObjectArrayDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
@@ skipping 16 matching lines @@
                                      is_vm_object, is_canonical);
       RawObject** from = list->from();
       RawObject** to = list->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class TypedDataSerializationCluster : public SerializationCluster {
  public:
   explicit TypedDataSerializationCluster(intptr_t cid) : cid_(cid) {}
   virtual ~TypedDataSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawTypedData* data = TypedData::RawCast(object);
     objects_.Add(data);
   }
@@ skipping 22 matching lines @@
       s->WriteBytes(cdata, length * element_size);
     }
   }
 
  private:
   const intptr_t cid_;
   GrowableArray<RawTypedData*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class TypedDataDeserializationCluster : public DeserializationCluster {
  public:
   explicit TypedDataDeserializationCluster(intptr_t cid) : cid_(cid) {}
   virtual ~TypedDataDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     intptr_t element_size = TypedData::ElementSizeInBytes(cid_);
@@ skipping 20 matching lines @@
       data->ptr()->length_ = Smi::New(length);
       uint8_t* cdata = reinterpret_cast<uint8_t*>(data->ptr()->data());
       d->ReadBytes(cdata, length_in_bytes);
     }
   }
 
  private:
   const intptr_t cid_;
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ExternalTypedDataSerializationCluster : public SerializationCluster {
  public:
   explicit ExternalTypedDataSerializationCluster(intptr_t cid) : cid_(cid) {}
   virtual ~ExternalTypedDataSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawExternalTypedData* data = ExternalTypedData::RawCast(object);
     objects_.Add(data);
     ASSERT(!data->IsCanonical());
@@ skipping 20 matching lines @@
       s->WriteBytes(cdata, length * element_size);
     }
   }
 
  private:
   const intptr_t cid_;
   GrowableArray<RawExternalTypedData*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class ExternalTypedDataDeserializationCluster : public DeserializationCluster {
  public:
   explicit ExternalTypedDataDeserializationCluster(intptr_t cid) : cid_(cid) {}
   virtual ~ExternalTypedDataDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 17 matching lines @@
       data->ptr()->data_ = const_cast<uint8_t*>(d->CurrentBufferAddress());
       d->Advance(length * element_size);
       // No finalizer / external size 0.
     }
   }
 
  private:
   const intptr_t cid_;
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class StackTraceSerializationCluster : public SerializationCluster {
  public:
   StackTraceSerializationCluster() {}
   virtual ~StackTraceSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawStackTrace* trace = StackTrace::RawCast(object);
     objects_.Add(trace);
 
@@ skipping 24 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawStackTrace*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class StackTraceDeserializationCluster : public DeserializationCluster {
  public:
   StackTraceDeserializationCluster() {}
   virtual ~StackTraceDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 12 matching lines @@
                                      StackTrace::InstanceSize(), is_vm_object);
       RawObject** from = trace->from();
       RawObject** to = trace->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class RegExpSerializationCluster : public SerializationCluster {
  public:
   RegExpSerializationCluster() {}
   virtual ~RegExpSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawRegExp* regexp = RegExp::RawCast(object);
     objects_.Add(regexp);
 
@@ skipping 27 matching lines @@
       s->Write<int32_t>(regexp->ptr()->num_registers_);
       s->Write<int8_t>(regexp->ptr()->type_flags_);
     }
   }
 
  private:
   GrowableArray<RawRegExp*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class RegExpDeserializationCluster : public DeserializationCluster {
  public:
   RegExpDeserializationCluster() {}
   virtual ~RegExpDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 14 matching lines @@
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
 
       regexp->ptr()->num_registers_ = d->Read<int32_t>();
       regexp->ptr()->type_flags_ = d->Read<int8_t>();
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class WeakPropertySerializationCluster : public SerializationCluster {
  public:
   WeakPropertySerializationCluster() {}
   virtual ~WeakPropertySerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawWeakProperty* property = WeakProperty::RawCast(object);
     objects_.Add(property);
 
@@ skipping 24 matching lines @@
         s->WriteRef(*p);
       }
     }
   }
 
  private:
   GrowableArray<RawWeakProperty*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class WeakPropertyDeserializationCluster : public DeserializationCluster {
  public:
   WeakPropertyDeserializationCluster() {}
   virtual ~WeakPropertyDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 14 matching lines @@
                                      is_vm_object);
       RawObject** from = property->from();
       RawObject** to = property->to();
       for (RawObject** p = from; p <= to; p++) {
         *p = d->ReadRef();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class LinkedHashMapSerializationCluster : public SerializationCluster {
  public:
   LinkedHashMapSerializationCluster() {}
   virtual ~LinkedHashMapSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawLinkedHashMap* map = LinkedHashMap::RawCast(object);
     objects_.Add(map);
 
@@ skipping 48 matching lines @@
         }
       }
     }
   }
 
  private:
   GrowableArray<RawLinkedHashMap*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class LinkedHashMapDeserializationCluster : public DeserializationCluster {
  public:
   LinkedHashMapDeserializationCluster() {}
   virtual ~LinkedHashMapDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 38 matching lines @@
 
       map->ptr()->index_ = TypedData::null();
       map->ptr()->hash_mask_ = Smi::New(0);
       map->ptr()->data_ = data;
       map->ptr()->used_data_ = Smi::New(used_data);
       map->ptr()->deleted_keys_ = Smi::New(0);
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ArraySerializationCluster : public SerializationCluster {
  public:
   explicit ArraySerializationCluster(intptr_t cid) : cid_(cid) {}
   virtual ~ArraySerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawArray* array = Array::RawCast(object);
     objects_.Add(array);
 
@@ skipping 29 matching lines @@
       }
     }
   }
 
  private:
   intptr_t cid_;
   GrowableArray<RawArray*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class ArrayDeserializationCluster : public DeserializationCluster {
  public:
   explicit ArrayDeserializationCluster(intptr_t cid) : cid_(cid) {}
   virtual ~ArrayDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 19 matching lines @@
       for (intptr_t j = 0; j < length; j++) {
         array->ptr()->data()[j] = d->ReadRef();
       }
     }
   }
 
  private:
   const intptr_t cid_;
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class OneByteStringSerializationCluster : public SerializationCluster {
  public:
   OneByteStringSerializationCluster() {}
   virtual ~OneByteStringSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawOneByteString* str = reinterpret_cast<RawOneByteString*>(object);
     objects_.Add(str);
   }
@@ skipping 21 matching lines @@
       s->Write<int32_t>(hash);
       s->WriteBytes(str->ptr()->data(), length);
     }
   }
 
  private:
   GrowableArray<RawOneByteString*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class OneByteStringDeserializationCluster : public DeserializationCluster {
  public:
   OneByteStringDeserializationCluster() {}
   virtual ~OneByteStringDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 16 matching lines @@
                                      is_vm_object, is_canonical);
       str->ptr()->length_ = Smi::New(length);
       String::SetCachedHash(str, d->Read<int32_t>());
       for (intptr_t j = 0; j < length; j++) {
         str->ptr()->data()[j] = d->Read<uint8_t>();
       }
     }
   }
 };
 
-
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class TwoByteStringSerializationCluster : public SerializationCluster {
  public:
   TwoByteStringSerializationCluster() {}
   virtual ~TwoByteStringSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawTwoByteString* str = reinterpret_cast<RawTwoByteString*>(object);
     objects_.Add(str);
   }
@@ skipping 21 matching lines @@
       s->Write<int32_t>(hash);
       s->WriteBytes(reinterpret_cast<uint8_t*>(str->ptr()->data()), length * 2);
     }
   }
 
  private:
   GrowableArray<RawTwoByteString*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
-
 class TwoByteStringDeserializationCluster : public DeserializationCluster {
  public:
   TwoByteStringDeserializationCluster() {}
   virtual ~TwoByteStringDeserializationCluster() {}
 
   void ReadAlloc(Deserializer* d) {
     start_index_ = d->next_index();
     PageSpace* old_space = d->heap()->old_space();
     intptr_t count = d->Read<int32_t>();
     for (intptr_t i = 0; i < count; i++) {
@@ skipping 15 matching lines @@
                                      TwoByteString::InstanceSize(length),
                                      is_vm_object, is_canonical);
       str->ptr()->length_ = Smi::New(length);
       String::SetCachedHash(str, d->Read<int32_t>());
       uint8_t* cdata = reinterpret_cast<uint8_t*>(str->ptr()->data());
       d->ReadBytes(cdata, length * 2);
     }
   }
 };
 
-
 Serializer::Serializer(Thread* thread,
                        Snapshot::Kind kind,
                        uint8_t** buffer,
                        ReAlloc alloc,
                        intptr_t initial_size,
                        ImageWriter* image_writer)
     : StackResource(thread),
       heap_(thread->isolate()->heap()),
       zone_(thread->zone()),
       kind_(kind),
@@ skipping 11 matching lines @@
       parent_pairs_()
 #endif
 {
   num_cids_ = thread->isolate()->class_table()->NumCids();
   clusters_by_cid_ = new SerializationCluster*[num_cids_];
   for (intptr_t i = 0; i < num_cids_; i++) {
     clusters_by_cid_[i] = NULL;
   }
 }
 
-
 Serializer::~Serializer() {
   delete[] clusters_by_cid_;
 }
 
-
 SerializationCluster* Serializer::NewClusterForClass(intptr_t cid) {
 #if defined(DART_PRECOMPILED_RUNTIME)
   UNREACHABLE();
   return NULL;
 #else
   Zone* Z = zone_;
   if ((cid >= kNumPredefinedCids) || (cid == kInstanceCid) ||
       RawObject::IsTypedDataViewClassId(cid)) {
     Push(isolate()->class_table()->At(cid));
     return new (Z) InstanceSerializationCluster(cid);
@@ skipping 111 matching lines @@
     default:
       break;
   }
 
   FATAL2("No cluster defined for cid %" Pd ", kind %s", cid,
          Snapshot::KindToCString(kind_));
   return NULL;
 #endif  // !DART_PRECOMPILED_RUNTIME
 }
 
-
 void Serializer::Push(RawObject* object) {
   if (!object->IsHeapObject()) {
     RawSmi* smi = Smi::RawCast(object);
     if (smi_ids_.Lookup(smi) == NULL) {
       SmiObjectIdPair pair;
       pair.smi_ = smi;
       pair.id_ = 1;
       smi_ids_.Insert(pair);
       stack_.Add(object);
       num_written_objects_++;
@@ skipping 18 matching lines @@
     stack_.Add(object);
     num_written_objects_++;
 
 #if defined(SNAPSHOT_BACKTRACE)
     parent_pairs_.Add(&Object::Handle(object));
     parent_pairs_.Add(&Object::Handle(current_parent_));
 #endif
   }
 }
 
-
 void Serializer::Trace(RawObject* object) {
   intptr_t cid;
   if (!object->IsHeapObject()) {
     // Smis are merged into the Mint cluster because Smis for the writer might
     // become Mints for the reader and vice versa.
     cid = kMintCid;
   } else {
     cid = object->GetClassId();
   }
 
   SerializationCluster* cluster = clusters_by_cid_[cid];
   if (cluster == NULL) {
     cluster = NewClusterForClass(cid);
     clusters_by_cid_[cid] = cluster;
   }
   ASSERT(cluster != NULL);
 
 #if defined(SNAPSHOT_BACKTRACE)
   current_parent_ = object;
 #endif
 
   cluster->Trace(this, object);
 
 #if defined(SNAPSHOT_BACKTRACE)
   current_parent_ = Object::null();
 #endif
 }
 
-
 void Serializer::UnexpectedObject(RawObject* raw_object, const char* message) {
   Object& object = Object::Handle(raw_object);
   OS::PrintErr("Unexpected object (%s): %s\n", message, object.ToCString());
 #if defined(SNAPSHOT_BACKTRACE)
   while (!object.IsNull()) {
     object = ParentOf(object);
     OS::PrintErr("referenced by %s\n", object.ToCString());
   }
 #endif
   OS::Abort();
 }
 
-
 #if defined(SNAPSHOT_BACKTRACE)
 RawObject* Serializer::ParentOf(const Object& object) {
   for (intptr_t i = 0; i < parent_pairs_.length(); i += 2) {
     if (parent_pairs_[i]->raw() == object.raw()) {
       return parent_pairs_[i + 1]->raw();
     }
   }
   return Object::null();
 }
 #endif  // SNAPSHOT_BACKTRACE
 
-
 void Serializer::WriteVersionAndFeatures() {
   const char* expected_version = Version::SnapshotString();
   ASSERT(expected_version != NULL);
   const intptr_t version_len = strlen(expected_version);
   WriteBytes(reinterpret_cast<const uint8_t*>(expected_version), version_len);
 
   const char* expected_features =
       Dart::FeaturesString(Isolate::Current(), kind_);
   ASSERT(expected_features != NULL);
   const intptr_t features_len = strlen(expected_features);
   WriteBytes(reinterpret_cast<const uint8_t*>(expected_features),
              features_len + 1);
   free(const_cast<char*>(expected_features));
 }
 
-
 #if defined(DEBUG)
 static const int32_t kSectionMarker = 0xABAB;
 #endif
 
 void Serializer::Serialize() {
   while (stack_.length() > 0) {
     Trace(stack_.RemoveLast());
   }
 
   intptr_t num_clusters = 0;
@@ skipping 32 matching lines @@
     SerializationCluster* cluster = clusters_by_cid_[cid];
     if (cluster != NULL) {
       cluster->WriteFill(this);
 #if defined(DEBUG)
       Write<int32_t>(kSectionMarker);
 #endif
     }
   }
 }
 
-
 void Serializer::AddVMIsolateBaseObjects() {
   // These objects are always allocated by Object::InitOnce, so they are not
   // written into the snapshot.
 
   AddBaseObject(Object::null());
   AddBaseObject(Object::sentinel().raw());
   AddBaseObject(Object::transition_sentinel().raw());
   AddBaseObject(Object::empty_type_arguments().raw());
   AddBaseObject(Object::empty_array().raw());
   AddBaseObject(Object::zero_array().raw());
@@ skipping 27 matching lines @@
   AddBaseObject(table->At(kDynamicCid));
   AddBaseObject(table->At(kVoidCid));
 
   if (!Snapshot::IncludesCode(kind_)) {
     for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
       AddBaseObject(StubCode::EntryAt(i)->code());
     }
   }
 }
 
-
 intptr_t Serializer::WriteVMSnapshot(const Array& symbols,
                                      const Array& scripts) {
   NoSafepointScope no_safepoint;
 
   AddVMIsolateBaseObjects();
 
   // Push roots.
   Push(symbols.raw());
   Push(scripts.raw());
   if (Snapshot::IncludesCode(kind_)) {
@@ skipping 18 matching lines @@
 #endif
 
   // Note we are not clearing the object id table. The full ref table
   // of the vm isolate snapshot serves as the base objects for the
   // regular isolate snapshot.
 
   // Return the number of objects, -1 accounts for unused ref 0.
   return next_ref_index_ - 1;
 }
 
-
 void Serializer::WriteIsolateSnapshot(intptr_t num_base_objects,
                                       ObjectStore* object_store) {
   NoSafepointScope no_safepoint;
 
   if (num_base_objects == 0) {
     // Units tests not writing a new vm isolate.
     const Array& base_objects = Object::vm_isolate_snapshot_object_table();
     for (intptr_t i = 1; i < base_objects.Length(); i++) {
       AddBaseObject(base_objects.At(i));
     }
@@ skipping 17 matching lines @@
     WriteRef(*p);
   }
 
 #if defined(DEBUG)
   Write<int32_t>(kSectionMarker);
 #endif
 
   heap_->ResetObjectIdTable();
 }
 
-
 Deserializer::Deserializer(Thread* thread,
                            Snapshot::Kind kind,
                            const uint8_t* buffer,
                            intptr_t size,
                            const uint8_t* instructions_buffer,
                            const uint8_t* data_buffer)
     : StackResource(thread),
       heap_(thread->isolate()->heap()),
       zone_(thread->zone()),
       kind_(kind),
       stream_(buffer, size),
       image_reader_(NULL),
       refs_(NULL),
       next_ref_index_(1),
       clusters_(NULL) {
   if (Snapshot::IncludesCode(kind)) {
     ASSERT(instructions_buffer != NULL);
     ASSERT(data_buffer != NULL);
     image_reader_ = new (zone_) ImageReader(instructions_buffer, data_buffer);
   }
 }
 
-
 Deserializer::~Deserializer() {
   delete[] clusters_;
 }
 
-
 DeserializationCluster* Deserializer::ReadCluster() {
   intptr_t cid = ReadCid();
 
   Zone* Z = zone_;
   if ((cid >= kNumPredefinedCids) || (cid == kInstanceCid) ||
       RawObject::IsTypedDataViewClassId(cid)) {
     return new (Z) InstanceDeserializationCluster(cid);
   }
   if (RawObject::IsExternalTypedDataClassId(cid)) {
     return new (Z) ExternalTypedDataDeserializationCluster(cid);
@@ skipping 103 matching lines @@
         return new (Z) TwoByteStringDeserializationCluster();
       }
     }
     default:
       break;
   }
   FATAL1("No cluster defined for cid %" Pd, cid);
   return NULL;
 }
 
-
 RawApiError* Deserializer::VerifyVersionAndFeatures(Isolate* isolate) {
   // If the version string doesn't match, return an error.
   // Note: New things are allocated only if we're going to return an error.
 
   const char* expected_version = Version::SnapshotString();
   ASSERT(expected_version != NULL);
   const intptr_t version_len = strlen(expected_version);
   if (PendingBytes() < version_len) {
     const intptr_t kMessageBufferSize = 128;
     char message_buffer[kMessageBufferSize];
@@ skipping 46 matching lines @@
     // This can also fail while bringing up the VM isolate, so make sure to
     // allocate the error message in old space.
     const String& msg = String::Handle(String::New(message_buffer, Heap::kOld));
     return ApiError::New(msg, Heap::kOld);
   }
   free(const_cast<char*>(expected_features));
   Advance(expected_len + 1);
   return ApiError::null();
 }
 
-
 void Deserializer::Prepare() {
   num_base_objects_ = Read<int32_t>();
   num_objects_ = Read<int32_t>();
   num_clusters_ = Read<int32_t>();
 
   clusters_ = new DeserializationCluster*[num_clusters_];
   refs_ = Array::New(num_objects_ + 1, Heap::kOld);
 }
 
-
 void Deserializer::Deserialize() {
   if (num_base_objects_ != (next_ref_index_ - 1)) {
     FATAL2("Snapshot expects %" Pd
            " base objects, but deserializer provided %" Pd,
            num_base_objects_, next_ref_index_ - 1);
   }
 
   {
     NOT_IN_PRODUCT(TimelineDurationScope tds(
         thread(), Timeline::GetIsolateStream(), "ReadAlloc"));
@@ skipping 28 matching lines @@
   HeapLocker(Thread* thread, PageSpace* page_space)
       : StackResource(thread), page_space_(page_space) {
     page_space_->AcquireDataLock();
   }
   ~HeapLocker() { page_space_->ReleaseDataLock(); }
 
  private:
   PageSpace* page_space_;
 };
 
-
 void Deserializer::AddVMIsolateBaseObjects() {
   // These objects are always allocated by Object::InitOnce, so they are not
   // written into the snapshot.
 
   AddBaseObject(Object::null());
   AddBaseObject(Object::sentinel().raw());
   AddBaseObject(Object::transition_sentinel().raw());
   AddBaseObject(Object::empty_type_arguments().raw());
   AddBaseObject(Object::empty_array().raw());
   AddBaseObject(Object::zero_array().raw());
@@ skipping 27 matching lines @@
   AddBaseObject(table->At(kDynamicCid));
   AddBaseObject(table->At(kVoidCid));
 
   if (!Snapshot::IncludesCode(kind_)) {
     for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
       AddBaseObject(StubCode::EntryAt(i)->code());
     }
   }
 }
 
-
 void Deserializer::ReadVMSnapshot() {
   Array& symbol_table = Array::Handle(zone_);
   Array& refs = Array::Handle(zone_);
   Prepare();
 
   {
     NoSafepointScope no_safepoint;
     HeapLocker hl(thread(), heap_->old_space());
 
     AddVMIsolateBaseObjects();
@@ skipping 77 matching lines @@
         thread(), Timeline::GetIsolateStream(), "PostLoad"));
     for (intptr_t i = 0; i < num_clusters_; i++) {
       clusters_[i]->PostLoad(refs, kind_, zone_);
     }
   }
 
   // Setup native resolver for bootstrap impl.
   Bootstrap::SetupNativeResolver();
 }
 
-
 // An object visitor which will iterate over all the token stream objects in the
 // heap and either count them or collect them into an array. This is used during
 // full snapshot generation of the VM isolate to write out all token streams so
 // they will be shared across all isolates.
 class SnapshotTokenStreamVisitor : public ObjectVisitor {
  public:
   explicit SnapshotTokenStreamVisitor(Thread* thread)
       : objHandle_(Object::Handle(thread->zone())),
         count_(0),
         token_streams_(NULL) {}
@@ skipping 14 matching lines @@
   }
 
   intptr_t count() const { return count_; }
 
  private:
   Object& objHandle_;
   intptr_t count_;
   const Array* token_streams_;
 };
 
-
 FullSnapshotWriter::FullSnapshotWriter(Snapshot::Kind kind,
                                        uint8_t** vm_snapshot_data_buffer,
                                        uint8_t** isolate_snapshot_data_buffer,
                                        ReAlloc alloc,
                                        ImageWriter* vm_image_writer,
                                        ImageWriter* isolate_image_writer)
     : thread_(Thread::Current()),
       kind_(kind),
       vm_snapshot_data_buffer_(vm_snapshot_data_buffer),
       isolate_snapshot_data_buffer_(isolate_snapshot_data_buffer),
@@ skipping 68 matching lines @@
 FullSnapshotWriter::~FullSnapshotWriter() {
   // We may run Dart code afterwards, restore the symbol table if needed.
   if (!saved_symbol_table_.IsNull()) {
     isolate()->object_store()->set_symbol_table(saved_symbol_table_);
     saved_symbol_table_ = Array::null();
   }
   new_vm_symbol_table_ = Array::null();
   token_streams_ = Array::null();
 }
 
-
 intptr_t FullSnapshotWriter::WriteVMSnapshot() {
   NOT_IN_PRODUCT(TimelineDurationScope tds(
       thread(), Timeline::GetIsolateStream(), "WriteVMSnapshot"));
 
   ASSERT(vm_snapshot_data_buffer_ != NULL);
   Serializer serializer(thread(), kind_, vm_snapshot_data_buffer_, alloc_,
                         kInitialSize, vm_image_writer_);
 
   serializer.ReserveHeader();
   serializer.WriteVersionAndFeatures();
@@ skipping 11 matching lines @@
     mapped_data_size_ += vm_image_writer_->data_size();
     mapped_instructions_size_ += vm_image_writer_->text_size();
     vm_image_writer_->ResetOffsets();
   }
 
   // The clustered part + the direct mapped data part.
   vm_isolate_snapshot_size_ = serializer.bytes_written();
   return num_objects;
 }
 
-
 void FullSnapshotWriter::WriteIsolateSnapshot(intptr_t num_base_objects) {
   NOT_IN_PRODUCT(TimelineDurationScope tds(
       thread(), Timeline::GetIsolateStream(), "WriteIsolateSnapshot"));
 
   Serializer serializer(thread(), kind_, isolate_snapshot_data_buffer_, alloc_,
                         kInitialSize, isolate_image_writer_);
   ObjectStore* object_store = isolate()->object_store();
   ASSERT(object_store != NULL);
 
   serializer.ReserveHeader();
   serializer.WriteVersionAndFeatures();
   // Isolate snapshot roots are:
   // - the object store
   serializer.WriteIsolateSnapshot(num_base_objects, object_store);
   serializer.FillHeader(serializer.kind());
   clustered_isolate_size_ = serializer.bytes_written();
 
   if (Snapshot::IncludesCode(kind_)) {
     isolate_image_writer_->Write(serializer.stream(), false);
     mapped_data_size_ += isolate_image_writer_->data_size();
     mapped_instructions_size_ += isolate_image_writer_->text_size();
     isolate_image_writer_->ResetOffsets();
   }
 
   // The clustered part + the direct mapped data part.
   isolate_snapshot_size_ = serializer.bytes_written();
 }
 
-
 void FullSnapshotWriter::WriteFullSnapshot() {
   intptr_t num_base_objects;
   if (vm_snapshot_data_buffer() != NULL) {
     num_base_objects = WriteVMSnapshot();
     ASSERT(num_base_objects != 0);
   } else {
     num_base_objects = 0;
   }
 
   WriteIsolateSnapshot(num_base_objects);
 
   if (FLAG_print_snapshot_sizes) {
     OS::Print("VMIsolate(CodeSize): %" Pd "\n", clustered_vm_size_);
     OS::Print("Isolate(CodeSize): %" Pd "\n", clustered_isolate_size_);
     OS::Print("ReadOnlyData(CodeSize): %" Pd "\n", mapped_data_size_);
     OS::Print("Instructions(CodeSize): %" Pd "\n", mapped_instructions_size_);
     OS::Print("Total(CodeSize): %" Pd "\n",
               clustered_vm_size_ + clustered_isolate_size_ + mapped_data_size_ +
                   mapped_instructions_size_);
   }
 }
 
-
 static const uint8_t* DataBuffer(const Snapshot* snapshot) {
   if (Snapshot::IncludesCode(snapshot->kind())) {
     uword offset =
         Utils::RoundUp(snapshot->length(), OS::kMaxPreferredCodeAlignment);
     return snapshot->Addr() + offset;
   }
   return NULL;
 }
 
-
 FullSnapshotReader::FullSnapshotReader(const Snapshot* snapshot,
                                        const uint8_t* instructions_buffer,
                                        Thread* thread)
     : kind_(snapshot->kind()),
       thread_(thread),
       buffer_(snapshot->content()),
       size_(snapshot->length()),
       instructions_buffer_(instructions_buffer),
       data_buffer_(DataBuffer(snapshot)) {
   thread->isolate()->set_compilation_allowed(kind_ != Snapshot::kFullAOT);
 }
 
-
 RawApiError* FullSnapshotReader::ReadVMSnapshot() {
   Deserializer deserializer(thread_, kind_, buffer_, size_,
                             instructions_buffer_, data_buffer_);
 
   RawApiError* error = deserializer.VerifyVersionAndFeatures(/*isolate=*/NULL);
   if (error != ApiError::null()) {
     return error;
   }
 
   if (Snapshot::IncludesCode(kind_)) {
     ASSERT(instructions_buffer_ != NULL);
     thread_->isolate()->SetupImagePage(instructions_buffer_,
                                        /* is_executable */ true);
     ASSERT(data_buffer_ != NULL);
     thread_->isolate()->SetupImagePage(data_buffer_,
                                        /* is_executable */ false);
   }
 
   deserializer.ReadVMSnapshot();
 
   return ApiError::null();
 }
 
-
 RawApiError* FullSnapshotReader::ReadIsolateSnapshot() {
   Deserializer deserializer(thread_, kind_, buffer_, size_,
                             instructions_buffer_, data_buffer_);
 
   RawApiError* error =
       deserializer.VerifyVersionAndFeatures(thread_->isolate());
   if (error != ApiError::null()) {
     return error;
   }
 
   if (Snapshot::IncludesCode(kind_)) {
     ASSERT(instructions_buffer_ != NULL);
     thread_->isolate()->SetupImagePage(instructions_buffer_,
                                        /* is_executable */ true);
     ASSERT(data_buffer_ != NULL);
     thread_->isolate()->SetupImagePage(data_buffer_,
                                        /* is_executable */ false);
   }
 
   deserializer.ReadIsolateSnapshot(thread_->isolate()->object_store());
 
   return ApiError::null();
 }
 
 }  // namespace dart