clang-format runtime/vm

runtime/vm/snapshot.h

 // 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.
 
 #ifndef RUNTIME_VM_SNAPSHOT_H_
 #define RUNTIME_VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 91 matching lines @@
 // - Smi: the Smi value is written as is (last bit is not tagged).
 // - VM object (from VM isolate): (object id in vm isolate | 0x3)
 //   This valus is serialized as a negative number.
 //   (note VM objects are never serialized they are expected to be found
 //    using ths unique ID assigned to them).
 // - Reference to object that has already been written: (object id | 0x3)
 //   This valus is serialized as a positive number.
 // - Object that is seen for the first time (inlined in the stream):
 //   (a unique id for this object | 0x1)
 enum SerializedHeaderType {
-  kInlined  = 0x1,
+  kInlined = 0x1,
   kObjectId = 0x3,
 };
 static const int8_t kHeaderTagBits = 2;
 static const int8_t kObjectIdBits = (kBitsPerInt32 - (kHeaderTagBits + 1));
 static const intptr_t kMaxObjectId = (kMaxUint32 >> (kHeaderTagBits + 1));
 static const bool kAsReference = true;
 static const bool kAsInlinedObject = false;
 static const intptr_t kInvalidPatchIndex = -1;
 
 
-class SerializedHeaderTag :
-    public BitField<intptr_t, enum SerializedHeaderType, 0, kHeaderTagBits> {};
+class SerializedHeaderTag
+    : public BitField<intptr_t, enum SerializedHeaderType, 0, kHeaderTagBits> {
+};
 
 
-class SerializedHeaderData :
-    public BitField<intptr_t, intptr_t, kHeaderTagBits, kObjectIdBits> {};
+class SerializedHeaderData
+    : public BitField<intptr_t, intptr_t, kHeaderTagBits, kObjectIdBits> {};
 
 
 enum DeserializeState {
   kIsDeserialized = 0,
   kIsNotDeserialized = 1,
 };
 
 
 enum SerializeState {
   kIsSerialized = 0,
@@ skipping 46 matching lines @@
   }
   static bool IncludesCode(Kind kind) {
     return (kind == kAppWithJIT) || (kind == kAppNoJIT);
   }
 
   uint8_t* Addr() { return reinterpret_cast<uint8_t*>(this); }
 
   static intptr_t length_offset() {
     return OFFSET_OF(Snapshot, unaligned_length_);
   }
-  static intptr_t kind_offset() {
-    return OFFSET_OF(Snapshot, unaligned_kind_);
-  }
+  static intptr_t kind_offset() { return OFFSET_OF(Snapshot, unaligned_kind_); }
 
  private:
   // Prevent Snapshot from ever being allocated directly.
   Snapshot();
 
   // The following fields are potentially unaligned.
   int64_t unaligned_length_;  // Stream length.
-  int64_t unaligned_kind_;  // Kind of snapshot.
+  int64_t unaligned_kind_;    // Kind of snapshot.
 
   // Variable length data follows here.
 
   DISALLOW_COPY_AND_ASSIGN(Snapshot);
 };
 
 
 class InstructionsSnapshot : ValueObject {
  public:
   explicit InstructionsSnapshot(const void* raw_memory)
-    : raw_memory_(raw_memory) {
+      : raw_memory_(raw_memory) {
     ASSERT(Utils::IsAligned(raw_memory, OS::kMaxPreferredCodeAlignment));
   }
 
   void* instructions_start() {
-    return reinterpret_cast<void*>(
-        reinterpret_cast<uword>(raw_memory_) + kHeaderSize);
+    return reinterpret_cast<void*>(reinterpret_cast<uword>(raw_memory_) +
+                                   kHeaderSize);
   }
 
   uword instructions_size() {
     uword snapshot_size = *reinterpret_cast<const uword*>(raw_memory_);
     return snapshot_size - kHeaderSize;
   }
 
   static const intptr_t kHeaderSize = OS::kMaxPreferredCodeAlignment;
 
  private:
   const void* raw_memory_;  // The symbol kInstructionsSnapshot.
 
   DISALLOW_COPY_AND_ASSIGN(InstructionsSnapshot);
 };
 
 
 class DataSnapshot : ValueObject {
  public:
-  explicit DataSnapshot(const void* raw_memory)
-    : raw_memory_(raw_memory) {
+  explicit DataSnapshot(const void* raw_memory) : raw_memory_(raw_memory) {
     ASSERT(Utils::IsAligned(raw_memory, 2 * kWordSize));  // kObjectAlignment
   }
 
   void* data_start() {
-    return reinterpret_cast<void*>(
-        reinterpret_cast<uword>(raw_memory_) + kHeaderSize);
+    return reinterpret_cast<void*>(reinterpret_cast<uword>(raw_memory_) +
+                                   kHeaderSize);
   }
 
   uword data_size() {
     uword snapshot_size = *reinterpret_cast<const uword*>(raw_memory_);
     return snapshot_size - kHeaderSize;
   }
 
   // Header: data length and padding for alignment. We use the same alignment
   // as for code for now.
   static const intptr_t kHeaderSize = OS::kMaxPreferredCodeAlignment;
@@ skipping 19 matching lines @@
     int64_t value = Read<int64_t>();
     return static_cast<intptr_t>(value);
   }
 
   classid_t ReadClassIDValue() {
     uint32_t value = Read<uint32_t>();
     return static_cast<classid_t>(value);
   }
   COMPILE_ASSERT(sizeof(uint32_t) >= sizeof(classid_t));
 
-  void ReadBytes(uint8_t* addr, intptr_t len) {
-    stream_.ReadBytes(addr, len);
-  }
+  void ReadBytes(uint8_t* addr, intptr_t len) { stream_.ReadBytes(addr, len); }
 
   double ReadDouble() {
     double result;
     stream_.ReadBytes(reinterpret_cast<uint8_t*>(&result), sizeof(result));
     return result;
   }
 
   intptr_t ReadTags() {
     const intptr_t tags = static_cast<intptr_t>(Read<int8_t>()) & 0xff;
     return tags;
   }
 
   const uint8_t* CurrentBufferAddress() const {
     return stream_.AddressOfCurrentPosition();
   }
 
-  void Advance(intptr_t value) {
-    stream_.Advance(value);
-  }
+  void Advance(intptr_t value) { stream_.Advance(value); }
 
-  intptr_t PendingBytes() const {
-    return stream_.PendingBytes();
-  }
+  intptr_t PendingBytes() const { return stream_.PendingBytes(); }
 
   RawSmi* ReadAsSmi();
   intptr_t ReadSmiValue();
 
   // Negative header value indicates VM isolate object id.
   bool IsVMIsolateObject(intptr_t header_value) { return (header_value < 0); }
   intptr_t GetVMIsolateObjectId(intptr_t header_val) {
     ASSERT(IsVMIsolateObject(header_val));
     intptr_t value = -header_val;  // Header is negative for VM isolate objects.
     ASSERT(SerializedHeaderTag::decode(value) == kObjectId);
@@ skipping 43 matching lines @@
   DeserializeState state_;
   bool defer_canonicalization_;
   ZoneGrowableArray<intptr_t>* patch_records_;
 };
 
 
 class InstructionsReader : public ZoneAllocated {
  public:
   InstructionsReader(const uint8_t* instructions_buffer,
                      const uint8_t* data_buffer)
-    : instructions_buffer_(instructions_buffer),
-      data_buffer_(data_buffer) {
+      : instructions_buffer_(instructions_buffer), data_buffer_(data_buffer) {
     ASSERT(instructions_buffer != NULL);
     ASSERT(data_buffer != NULL);
     ASSERT(Utils::IsAligned(reinterpret_cast<uword>(instructions_buffer),
                             OS::PreferredCodeAlignment()));
   }
 
   uword GetInstructionsAt(int32_t offset);
   RawObject* GetObjectAt(int32_t offset);
 
  private:
@@ skipping 45 matching lines @@
   RawApiError* VerifyVersionAndFeatures();
 
   RawObject* NewInteger(int64_t value);
 
  protected:
   SnapshotReader(const uint8_t* buffer,
                  intptr_t size,
                  Snapshot::Kind kind,
                  ZoneGrowableArray<BackRefNode>* backward_references,
                  Thread* thread);
-  ~SnapshotReader() { }
+  ~SnapshotReader() {}
 
   ZoneGrowableArray<BackRefNode>* GetBackwardReferenceTable() const {
     return backward_references_;
   }
   void ResetBackwardReferenceTable() { backward_references_ = NULL; }
   PageSpace* old_space() const { return old_space_; }
 
  private:
   RawClass* ReadClassId(intptr_t object_id);
   RawFunction* ReadFunctionId(intptr_t object_id);
   RawObject* ReadStaticImplicitClosure(intptr_t object_id, intptr_t cls_header);
 
   // Implementation to read an object.
   RawObject* ReadObjectImpl(bool as_reference,
                             intptr_t patch_object_id = kInvalidPatchIndex,
                             intptr_t patch_offset = 0);
   RawObject* ReadObjectImpl(intptr_t header,
                             bool as_reference,
                             intptr_t patch_object_id,
                             intptr_t patch_offset);
 
   // Read a Dart Instance object.
-  RawObject* ReadInstance(intptr_t object_id,
-                          intptr_t tags,
-                          bool as_reference);
+  RawObject* ReadInstance(intptr_t object_id, intptr_t tags, bool as_reference);
 
   // Read a VM isolate object that was serialized as an Id.
   RawObject* ReadVMIsolateObject(intptr_t object_id);
 
   // Read an object that was serialized as an Id (singleton in object store,
   // or an object that was already serialized before).
   RawObject* ReadIndexedObject(intptr_t object_id,
                                intptr_t patch_object_id,
                                intptr_t patch_offset);
 
@@ skipping 15 matching lines @@
                      intptr_t tags);
 
   intptr_t NextAvailableObjectId() const;
 
   void SetReadException(const char* msg);
 
   RawObject* VmIsolateSnapshotObject(intptr_t index) const;
 
   bool is_vm_isolate() const;
 
-  Snapshot::Kind kind_;  // Indicates type of snapshot(full, script, message).
-  Thread* thread_;  // Current thread.
-  Zone* zone_;  // Zone for allocations while reading snapshot.
-  Heap* heap_;  // Heap of the current isolate.
+  Snapshot::Kind kind_;   // Indicates type of snapshot(full, script, message).
+  Thread* thread_;        // Current thread.
+  Zone* zone_;            // Zone for allocations while reading snapshot.
+  Heap* heap_;            // Heap of the current isolate.
   PageSpace* old_space_;  // Old space of the current isolate.
-  Class& cls_;  // Temporary Class handle.
-  Object& obj_;  // Temporary Object handle.
-  PassiveObject& pobj_;  // Temporary PassiveObject handle.
-  Array& array_;  // Temporary Array handle.
-  Field& field_;  // Temporary Field handle.
-  String& str_;  // Temporary String handle.
-  Library& library_;  // Temporary library handle.
-  AbstractType& type_;  // Temporary type handle.
+  Class& cls_;            // Temporary Class handle.
+  Object& obj_;           // Temporary Object handle.
+  PassiveObject& pobj_;   // Temporary PassiveObject handle.
+  Array& array_;          // Temporary Array handle.
+  Field& field_;          // Temporary Field handle.
+  String& str_;           // Temporary String handle.
+  Library& library_;      // Temporary library handle.
+  AbstractType& type_;    // Temporary type handle.
   TypeArguments& type_arguments_;  // Temporary type argument handle.
-  GrowableObjectArray& tokens_;  // Temporary tokens handle.
-  TokenStream& stream_;  // Temporary token stream handle.
-  ExternalTypedData& data_;  // Temporary stream data handle.
-  TypedData& typed_data_;  // Temporary typed data handle.
-  Function& function_;  // Temporary function handle.
-  UnhandledException& error_;  // Error handle.
+  GrowableObjectArray& tokens_;    // Temporary tokens handle.
+  TokenStream& stream_;            // Temporary token stream handle.
+  ExternalTypedData& data_;        // Temporary stream data handle.
+  TypedData& typed_data_;          // Temporary typed data handle.
+  Function& function_;             // Temporary function handle.
+  UnhandledException& error_;      // Error handle.
   intptr_t max_vm_isolate_object_id_;
   ZoneGrowableArray<BackRefNode>* backward_references_;
 
   friend class ApiError;
   friend class Array;
   friend class Bigint;
   friend class BoundedType;
   friend class Class;
   friend class Closure;
   friend class ClosureData;
@@ skipping 25 matching lines @@
   friend class TypeRef;
   friend class UnhandledException;
   friend class UnresolvedClass;
   friend class WeakProperty;
   DISALLOW_COPY_AND_ASSIGN(SnapshotReader);
 };
 
 
 class ScriptSnapshotReader : public SnapshotReader {
  public:
-  ScriptSnapshotReader(const uint8_t* buffer,
-                       intptr_t size,
-                       Thread* thread);
+  ScriptSnapshotReader(const uint8_t* buffer, intptr_t size, Thread* thread);
   ~ScriptSnapshotReader();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScriptSnapshotReader);
 };
 
 
 class MessageSnapshotReader : public SnapshotReader {
  public:
-  MessageSnapshotReader(const uint8_t* buffer,
-                        intptr_t size,
-                        Thread* thread);
+  MessageSnapshotReader(const uint8_t* buffer, intptr_t size, Thread* thread);
   ~MessageSnapshotReader();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MessageSnapshotReader);
 };
 
 
 class BaseWriter : public StackResource {
  public:
   // Size of the snapshot.
   intptr_t BytesWritten() const { return stream_.bytes_written(); }
 
   // Writes raw data to the stream (basic type).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   void Write(T value) {
     WriteStream::Raw<sizeof(T), T>::Write(&stream_, value);
   }
 
-  void WriteRawPointerValue(intptr_t value) {
-    Write<int64_t>(value);
-  }
+  void WriteRawPointerValue(intptr_t value) { Write<int64_t>(value); }
 
-  void WriteClassIDValue(classid_t value) {
-    Write<uint32_t>(value);
-  }
+  void WriteClassIDValue(classid_t value) { Write<uint32_t>(value); }
   COMPILE_ASSERT(sizeof(uint32_t) >= sizeof(classid_t));
 
   // Write an object that is serialized as an Id (singleton in object store,
   // or an object that was already serialized before).
   void WriteIndexedObject(intptr_t object_id) {
     ASSERT(object_id <= kMaxObjectId);
     intptr_t value = 0;
     value = SerializedHeaderTag::update(kObjectId, value);
     value = SerializedHeaderData::update(object_id, value);
     Write<int32_t>(value);
@@ skipping 25 matching lines @@
   // Write out a buffer of bytes.
   void WriteBytes(const uint8_t* addr, intptr_t len) {
     stream_.WriteBytes(addr, len);
   }
 
   void WriteDouble(double value) {
     stream_.WriteBytes(reinterpret_cast<const uint8_t*>(&value), sizeof(value));
   }
 
  protected:
-  BaseWriter(uint8_t** buffer,
-             ReAlloc alloc,
-             intptr_t initial_size)
-      : StackResource(Thread::Current()),
-        stream_(buffer, alloc, initial_size) {
+  BaseWriter(uint8_t** buffer, ReAlloc alloc, intptr_t initial_size)
+      : StackResource(Thread::Current()), stream_(buffer, alloc, initial_size) {
     ASSERT(buffer != NULL);
     ASSERT(alloc != NULL);
   }
-  ~BaseWriter() { }
+  ~BaseWriter() {}
 
   void ReserveHeader() {
     // Make room for recording snapshot buffer size.
     stream_.set_current(stream_.buffer() + Snapshot::kHeaderSize);
   }
 
   void FillHeader(Snapshot::Kind kind) {
     int64_t* data = reinterpret_cast<int64_t*>(stream_.buffer());
     data[Snapshot::kLengthIndex] = stream_.bytes_written();
     data[Snapshot::kSnapshotFlagIndex] = kind;
@@ skipping 57 matching lines @@
   GrowableArray<Node*> nodes_;
   intptr_t first_unprocessed_object_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardList);
 };
 
 
 class InstructionsWriter : public ZoneAllocated {
  public:
   InstructionsWriter()
-    : next_offset_(InstructionsSnapshot::kHeaderSize),
-      next_object_offset_(DataSnapshot::kHeaderSize),
-      instructions_(),
-      objects_() {
-  }
-  virtual ~InstructionsWriter() { }
+      : next_offset_(InstructionsSnapshot::kHeaderSize),
+        next_object_offset_(DataSnapshot::kHeaderSize),
+        instructions_(),
+        objects_() {}
+  virtual ~InstructionsWriter() {}
 
   int32_t GetOffsetFor(RawInstructions* instructions, RawCode* code);
 
   int32_t GetObjectOffsetFor(RawObject* raw_object);
 
   virtual void Write(uint8_t* vmisolate_buffer,
                      intptr_t vmisolate_length,
                      uint8_t* isolate_buffer,
                      intptr_t isolate_length) = 0;
   virtual intptr_t text_size() = 0;
   virtual intptr_t data_size() = 0;
 
  protected:
   struct InstructionsData {
     explicit InstructionsData(RawInstructions* insns,
                               RawCode* code,
                               intptr_t offset)
-        : raw_insns_(insns), raw_code_(code), offset_(offset) { }
+        : raw_insns_(insns), raw_code_(code), offset_(offset) {}
 
     union {
       RawInstructions* raw_insns_;
       const Instructions* insns_;
     };
     union {
       RawCode* raw_code_;
       const Code* code_;
     };
     intptr_t offset_;
   };
 
   struct ObjectData {
-    explicit ObjectData(RawObject* raw_obj)
-        : raw_obj_(raw_obj) { }
+    explicit ObjectData(RawObject* raw_obj) : raw_obj_(raw_obj) {}
 
     union {
       RawObject* raw_obj_;
       const Object* obj_;
     };
   };
 
   intptr_t next_offset_;
   intptr_t next_object_offset_;
   GrowableArray<InstructionsData> instructions_;
   GrowableArray<ObjectData> objects_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InstructionsWriter);
 };
 
 
 class AssemblyInstructionsWriter : public InstructionsWriter {
  public:
   AssemblyInstructionsWriter(uint8_t** assembly_buffer,
                              ReAlloc alloc,
                              intptr_t initial_size)
-    : InstructionsWriter(),
-      assembly_stream_(assembly_buffer, alloc, initial_size),
-      text_size_(0),
-      data_size_(0) {
-  }
+      : InstructionsWriter(),
+        assembly_stream_(assembly_buffer, alloc, initial_size),
+        text_size_(0),
+        data_size_(0) {}
 
   virtual void Write(uint8_t* vmisolate_buffer,
                      intptr_t vmisolate_length,
                      uint8_t* isolate_buffer,
                      intptr_t isolate_length);
   virtual intptr_t text_size() { return text_size_; }
   virtual intptr_t data_size() { return data_size_; }
 
   intptr_t AssemblySize() const { return assembly_stream_.bytes_written(); }
 
  private:
   void WriteWordLiteralText(uword value) {
-    // Padding is helpful for comparing the .S with --disassemble.
+// Padding is helpful for comparing the .S with --disassemble.
 #if defined(ARCH_IS_64_BIT)
     assembly_stream_.Print(".quad 0x%0.16" Px "\n", value);
 #else
     assembly_stream_.Print(".long 0x%0.8" Px "\n", value);
 #endif
     text_size_ += sizeof(value);
   }
 
   void WriteWordLiteralData(uword value) {
-    // Padding is helpful for comparing the .S with --disassemble.
+// Padding is helpful for comparing the .S with --disassemble.
 #if defined(ARCH_IS_64_BIT)
     assembly_stream_.Print(".quad 0x%0.16" Px "\n", value);
 #else
     assembly_stream_.Print(".long 0x%0.8" Px "\n", value);
 #endif
     data_size_ += sizeof(value);
   }
 
   WriteStream assembly_stream_;
   intptr_t text_size_;
   intptr_t data_size_;
 
   DISALLOW_COPY_AND_ASSIGN(AssemblyInstructionsWriter);
 };
 
 
 class BlobInstructionsWriter : public InstructionsWriter {
  public:
   BlobInstructionsWriter(uint8_t** instructions_blob_buffer,
                          uint8_t** rodata_blob_buffer,
                          ReAlloc alloc,
                          intptr_t initial_size)
-    : InstructionsWriter(),
-      instructions_blob_stream_(instructions_blob_buffer, alloc, initial_size),
-      rodata_blob_stream_(rodata_blob_buffer, alloc, initial_size) {
-  }
+      : InstructionsWriter(),
+        instructions_blob_stream_(instructions_blob_buffer,
+                                  alloc,
+                                  initial_size),
+        rodata_blob_stream_(rodata_blob_buffer, alloc, initial_size) {}
 
   virtual void Write(uint8_t* vmisolate_buffer,
                      intptr_t vmisolate_length,
                      uint8_t* isolate_buffer,
                      intptr_t isolate_length);
   virtual intptr_t text_size() { return InstructionsBlobSize(); }
   virtual intptr_t data_size() { return RodataBlobSize(); }
 
   intptr_t InstructionsBlobSize() const {
     return instructions_blob_stream_.bytes_written();
@@ skipping 26 matching lines @@
   Thread* thread() const { return thread_; }
   Zone* zone() const { return thread_->zone(); }
   Isolate* isolate() const { return thread_->isolate(); }
   Heap* heap() const { return isolate()->heap(); }
 
   // Serialize an object into the buffer.
   void WriteObject(RawObject* raw);
 
   uword GetObjectTags(RawObject* raw);
 
-  Exceptions::ExceptionType exception_type() const {
-    return exception_type_;
-  }
+  Exceptions::ExceptionType exception_type() const { return exception_type_; }
   void set_exception_type(Exceptions::ExceptionType type) {
     exception_type_ = type;
   }
   const char* exception_msg() const { return exception_msg_; }
-  void set_exception_msg(const char* msg) {
-    exception_msg_ = msg;
-  }
+  void set_exception_msg(const char* msg) { exception_msg_ = msg; }
   bool can_send_any_object() const { return can_send_any_object_; }
   void ThrowException(Exceptions::ExceptionType type, const char* msg);
 
   // Write a version string for the snapshot.
   void WriteVersionAndFeatures();
 
   void WriteFunctionId(RawFunction* func, bool owner_is_class);
 
   RawFunction* IsSerializableClosure(RawClosure* closure);
 
@@ skipping 33 matching lines @@
   ObjectStore* object_store() const { return object_store_; }
 
  private:
   Thread* thread_;
   Snapshot::Kind kind_;
   ObjectStore* object_store_;  // Object store for common classes.
   ClassTable* class_table_;  // Class table for the class index to class lookup.
   ForwardList* forward_list_;
   Exceptions::ExceptionType exception_type_;  // Exception type.
   const char* exception_msg_;  // Message associated with exception.
-  bool can_send_any_object_;  // True if any Dart instance can be sent.
+  bool can_send_any_object_;   // True if any Dart instance can be sent.
 
   friend class RawArray;
   friend class RawClass;
   friend class RawClosureData;
   friend class RawCode;
   friend class RawContextScope;
   friend class RawExceptionHandlers;
   friend class RawField;
   friend class RawFunction;
   friend class RawGrowableObjectArray;
@@ skipping 18 matching lines @@
   friend class SnapshotWriterVisitor;
   friend class WriteInlinedObjectVisitor;
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriter);
 };
 
 
 class ScriptSnapshotWriter : public SnapshotWriter {
  public:
   static const intptr_t kInitialSize = 64 * KB;
   ScriptSnapshotWriter(uint8_t** buffer, ReAlloc alloc);
-  ~ScriptSnapshotWriter() { }
+  ~ScriptSnapshotWriter() {}
 
   // Writes a partial snapshot of the script.
   void WriteScriptSnapshot(const Library& lib);
 
  private:
   ForwardList forward_list_;
 
   DISALLOW_COPY_AND_ASSIGN(ScriptSnapshotWriter);
 };
 
 
 class MessageWriter : public SnapshotWriter {
  public:
   static const intptr_t kInitialSize = 512;
   MessageWriter(uint8_t** buffer, ReAlloc alloc, bool can_send_any_object);
-  ~MessageWriter() { }
+  ~MessageWriter() {}
 
   void WriteMessage(const Object& obj);
 
  private:
   ForwardList forward_list_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageWriter);
 };
 
 
@@ skipping 11 matching lines @@
  private:
   SnapshotWriter* writer_;
   bool as_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_SNAPSHOT_H_