Support serializing ObjectPool as reference.

runtime/vm/snapshot.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 47 matching lines @@
 }
 
 
 static bool IsSplitClassId(intptr_t class_id) {
   // Return whether this class is serialized in two steps: first a reference,
   // with sufficient information to allocate a correctly sized object, and then
   // later inline with complete contents.
   return class_id >= kNumPredefinedCids ||
          class_id == kArrayCid ||
          class_id == kImmutableArrayCid ||
+         class_id == kObjectPoolCid ||
          RawObject::IsImplicitFieldClassId(class_id);
 }
 
 
 static intptr_t ClassIdFromObjectId(intptr_t object_id) {
   ASSERT(object_id > kClassIdsOffset);
   intptr_t class_id = (object_id - kClassIdsOffset);
   return class_id;
 }
 
@@ skipping 399 matching lines @@
     // Read the length and allocate an object based on the len.
     intptr_t len = ReadSmiValue();
     Array& array = Array::ZoneHandle(
         zone(),
         (kind_ == Snapshot::kFull) ?
         NewImmutableArray(len) : ImmutableArray::New(len, HEAP_SPACE(kind_)));
     AddBackRef(object_id, &array, kIsNotDeserialized);
 
     return array.raw();
   }
+  if (class_id == kObjectPoolCid) {
+    // Read the length and allocate an object based on the len.
+    intptr_t len = Read<intptr_t>();
+    ObjectPool& pool = ObjectPool::ZoneHandle(
+        zone(),
+        (kind_ == Snapshot::kFull) ?
+        NewObjectPool(len) : ObjectPool::New(len));

[siva, 2015/10/01 21:05:09]

ObjectPool should only be serialized in a Full snapshot right?

Maybe:

ASSERT(kind_ == Snapshot::kFull);

and just use NewObjectPool(len)

[rmacnak, 2015/10/01 21:32:48]

Done.

+    AddBackRef(object_id, &pool, kIsNotDeserialized);
+
+    return pool.raw();
+  }
 
   // For all other internal VM classes we read the object inline.
   switch (class_id) {
 #define SNAPSHOT_READ(clazz)                                                   \
     case clazz::kClassId: {                                                    \
       pobj_ = clazz::ReadFrom(this, object_id, tags, kind_);                   \
       break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
@@ skipping 1758 matching lines @@
 
     // Write out the class information.
     WriteIndexedObject(class_id);
     WriteTags(tags);
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
+  if (class_id == kObjectPoolCid) {
+    intptr_t tags = GetObjectTags(raw);
+
+    // Object is being referenced, add it to the forward ref list and mark
+    // it so that future references to this object in the snapshot will use
+    // this object id. Mark it as not having been serialized yet so that we
+    // will serialize the object when we go through the forward list.
+    forward_list_->MarkAndAddObject(raw, kIsNotSerialized);
+
+    RawObjectPool* rawpool = reinterpret_cast<RawObjectPool*>(raw);
+
+    // Write out the serialization header value for this object.
+    WriteInlinedObjectHeader(kOmittedObjectId);
+
+    // Write out the class information.
+    WriteVMIsolateObject(kObjectPoolCid);
+    WriteTags(tags);
+
+    // Write out the length field.
+    Write<intptr_t>(rawpool->ptr()->length_);
+
+    return;
+  }
   // Add object to the forward ref list and mark it so that future references
   // to this object in the snapshot will use this object id. Mark it as having
   // been serialized so that we do not serialize the object when we go through
   // the forward list.
   forward_list_->MarkAndAddObject(raw, kIsSerialized);
   switch (class_id) {
 #define SNAPSHOT_WRITE(clazz)                                                  \
     case clazz::kClassId: {                                                    \
       Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                \
       raw_obj->WriteTo(this, kOmittedObjectId, kind_);                         \
@@ skipping 516 matching lines @@
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart