Refactor snapshot writer's forward list into a reusable class.

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 VM_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 469 matching lines @@
     data[Snapshot::kSnapshotFlagIndex] = kind;
   }
 
  private:
   WriteStream stream_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BaseWriter);
 };
 
 
+class ForwardList {
+ public:
+  explicit ForwardList(intptr_t first_object_id)
+      : first_object_id_(first_object_id),

[siva, 2014/07/11 19:57:48]

normally we initialize all the fields in the list, so
           nodes_(),

[koda, 2014/07/11 21:06:39]

Done.

+        first_unprocessed_object_id_(first_object_id) {}
+
+  class Node : public ZoneAllocated {
+   public:
+    Node(RawObject* raw, uword tags, SerializeState state)
+        : raw_(raw), tags_(tags), state_(state) {}
+    RawObject* raw() const { return raw_; }
+    uword tags() const { return tags_; }
+    bool is_serialized() const { return state_ == kIsSerialized; }
+
+   private:
+    // Private to ensure the invariant of first_unprocessed_object_id_.
+    void set_state(SerializeState value) { state_ = value; }
+
+    RawObject* raw_;
+    uword tags_;
+    SerializeState state_;
+
+    friend class ForwardList;
+    DISALLOW_COPY_AND_ASSIGN(Node);
+  };
+
+  Node* NodeForObjectId(intptr_t object_id) const {
+    return nodes_[object_id - first_object_id_];
+  }
+
+  // Returns the id for the added object.
+  intptr_t MarkAndAddObject(RawObject* raw, SerializeState state);
+
+  // Exhaustively processes all unserialized objects in this list. 'writer' may
+  // concurrently add more objects.
+  void SerializeAll(ObjectVisitor* writer);
+
+  // Restores the tags of all objects in this list.
+  void UnmarkAll() const;
+
+ private:
+  intptr_t first_object_id() const { return first_object_id_; }
+  intptr_t next_object_id() const { return nodes_.length() + first_object_id_; }
+
+  const intptr_t first_object_id_;
+  GrowableArray<Node*> nodes_;
+  intptr_t first_unprocessed_object_id_;

[siva, 2014/07/11 19:57:49]

DISALLOW_COPY_AND_ASSSIGN(ForwardList);

[koda, 2014/07/11 21:06:39]

Done.

+};
+
+
 class SnapshotWriter : public BaseWriter {
  protected:
   SnapshotWriter(Snapshot::Kind kind,
                  uint8_t** buffer,
                  ReAlloc alloc,
                  intptr_t initial_size);
 
  public:
   // Snapshot kind.
   Snapshot::Kind kind() const { return kind_; }
 
   // Serialize an object into the buffer.
   void WriteObject(RawObject* raw);
 
   uword GetObjectTags(RawObject* raw);
 
   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 ThrowException(Exceptions::ExceptionType type, const char* msg);
 
  protected:
-  class ForwardObjectNode : public ZoneAllocated {
-   public:
-    ForwardObjectNode(RawObject* raw, uword tags, SerializeState state)
-        : raw_(raw), tags_(tags), state_(state) {}
-    RawObject* raw() const { return raw_; }
-    uword tags() const { return tags_; }
-    bool is_serialized() const { return state_ == kIsSerialized; }
-    void set_state(SerializeState value) { state_ = value; }
-
-   private:
-    RawObject* raw_;
-    uword tags_;
-    SerializeState state_;
-
-    DISALLOW_COPY_AND_ASSIGN(ForwardObjectNode);
-  };
-
-  intptr_t MarkObject(RawObject* raw, SerializeState state);
-  void UnmarkAll();
+  void UnmarkAll() {
+    forward_list_.UnmarkAll();
+  }
 
   bool CheckAndWritePredefinedObject(RawObject* raw);
   void HandleVMIsolateObject(RawObject* raw);
 
   void WriteObjectRef(RawObject* raw);
   void WriteClassId(RawClass* cls);
   void WriteObjectImpl(RawObject* raw);
   void WriteInlinedObject(RawObject* raw);
   void WriteForwardedObjects();
   void ArrayWriteTo(intptr_t object_id,
                     intptr_t array_kind,
                     intptr_t tags,
                     RawSmi* length,
                     RawTypeArguments* type_arguments,
                     RawObject* data[]);
   void CheckIfSerializable(RawClass* cls);
   void SetWriteException(Exceptions::ExceptionType type, const char* msg);
   void WriteInstance(intptr_t object_id,
                      RawObject* raw,
                      RawClass* cls,
                      intptr_t tags);
   void WriteInstanceRef(RawObject* raw, RawClass* cls);
 
   ObjectStore* object_store() const { return object_store_; }
 
  private:
   Snapshot::Kind kind_;
   ObjectStore* object_store_;  // Object store for common classes.
   ClassTable* class_table_;  // Class table for the class index to class lookup.
-  GrowableArray<ForwardObjectNode*> forward_list_;
+  ForwardList forward_list_;
   Exceptions::ExceptionType exception_type_;  // Exception type.
   const char* exception_msg_;  // Message associated with exception.
 
   friend class RawArray;
   friend class RawClass;
   friend class RawClosureData;
   friend class RawGrowableObjectArray;
   friend class RawImmutableArray;
   friend class RawJSRegExp;
   friend class RawLibrary;
   friend class RawLiteralToken;
+  friend class RawMirrorReference;
   friend class RawReceivePort;
   friend class RawScript;
   friend class RawStacktrace;
   friend class RawTokenStream;
   friend class RawTypeArguments;
-  friend class RawMirrorReference;
+  friend class RawUserTag;
   friend class SnapshotWriterVisitor;
-  friend class RawUserTag;
+  friend class WriteInlinedObjectVisitor;
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriter);
 };
 
 
 class FullSnapshotWriter : public SnapshotWriter {
  public:
   static const intptr_t kInitialSize = 64 * KB;
   FullSnapshotWriter(uint8_t** buffer, ReAlloc alloc)
       : SnapshotWriter(Snapshot::kFull, buffer, alloc, kInitialSize) {
     ASSERT(buffer != NULL);
@@ skipping 63 matching lines @@
  private:
   SnapshotWriter* writer_;
   bool as_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_