1. Do not mark an object by storing the object id used during serialization in the object header.

runtime/vm/snapshot_test.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 "platform/globals.h"
 
 #include "include/dart_tools_api.h"
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
@@ skipping 237 matching lines @@
   // Read object back from the snapshot into a C structure.
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   CheckEncodeDecodeMessage(root);
   return root;
 }
 
 
 void CheckMint(int64_t value) {
+  ApiNativeScope scope;
   StackZone zone(Thread::Current());
 
   Mint& mint = Mint::Handle();
   mint ^= Integer::New(value);
-  ApiNativeScope scope;
   Dart_CObject* mint_cobject = SerializeAndDeserializeMint(mint);
   // On 64-bit platforms mints always require 64-bits as the smi range
   // here covers most of the 64-bit range. On 32-bit platforms the smi
   // range covers most of the 32-bit range and values outside that
   // range are also represented as mints.
 #if defined(ARCH_IS_64_BIT)
   EXPECT_EQ(Dart_CObject_kInt64, mint_cobject->type);
   EXPECT_EQ(value, mint_cobject->value.as_int64);
 #else
   if (kMinInt32 < value && value < kMaxInt32) {
@@ skipping 196 matching lines @@
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   // Bigint not supported.
   EXPECT_NOTNULL(root);
   CheckEncodeDecodeMessage(root);
   return root;
 }
 
 
 void CheckBigint(const char* bigint_value) {
+  ApiNativeScope scope;
   StackZone zone(Thread::Current());
   Bigint& bigint = Bigint::Handle();
   bigint ^= Bigint::NewFromCString(bigint_value);
-  ApiNativeScope scope;
   Dart_CObject* bigint_cobject = SerializeAndDeserializeBigint(bigint);
   EXPECT_EQ(Dart_CObject_kBigint, bigint_cobject->type);
   char* hex_value = TestCase::BigintToHexValue(bigint_cobject);
   EXPECT_STREQ(bigint_value, hex_value);
   free(hex_value);
 }
 
 
 TEST_CASE(SerializeBigint2) {
   CheckBigint("0x0");
@@ skipping 331 matching lines @@
   EXPECT(root->value.as_typed_data.values == NULL);
   CheckEncodeDecodeMessage(root);
 }
 
 
 class TestSnapshotWriter : public SnapshotWriter {
  public:
   static const intptr_t kInitialSize = 64 * KB;
   TestSnapshotWriter(uint8_t** buffer, ReAlloc alloc)
       : SnapshotWriter(Snapshot::kScript,
+                       Thread::Current(),
                        buffer,
                        alloc,
                        kInitialSize,
                        &forward_list_,
                        NULL, /* test_writer */
                        true, /* can_send_any_object */
                        false, /* snapshot_code */
                        true /* vm_isolate_is_symbolic */),
-        forward_list_(kMaxPredefinedObjectIds) {
+        forward_list_(thread(), kMaxPredefinedObjectIds) {
     ASSERT(buffer != NULL);
     ASSERT(alloc != NULL);
   }
   ~TestSnapshotWriter() { }
 
   // Writes just a script object
   void WriteScript(const Script& script) {
     WriteObject(script.raw());
-    UnmarkAll();
   }
 
  private:
   ForwardList forward_list_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSnapshotWriter);
 };
 
 
 static void GenerateSourceAndCheck(const Script& script) {
@@ skipping 2134 matching lines @@
   StackZone zone(Thread::Current());
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteInlinedObjectHeader(kOmittedObjectId);
   // For performance, we'd like single-byte headers when ids are omitted.
   // If this starts failing, consider renumbering the snapshot ids.
   EXPECT_EQ(1, writer.BytesWritten());
 }
 
 }  // namespace dart