- Ensure that HandleScope is initialized with a thread. (Remove

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 134 matching lines @@
 
 static void ExpectEncodeFail(Dart_CObject* root) {
   uint8_t* buffer = NULL;
   ApiMessageWriter writer(&buffer, &malloc_allocator);
   const bool result = writer.WriteCMessage(root);
   EXPECT_EQ(false, result);
 }
 
 
 TEST_CASE(SerializeNull) {
-  StackZone zone(Thread::Current());
+  StackZone zone(thread);
 
   // Write snapshot with object content.
   const Object& null_object = Object::Handle();
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(null_object);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(null_object, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kNull, root->type);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeSmi1) {
-  StackZone zone(Thread::Current());
+  StackZone zone(thread);
 
   // Write snapshot with object content.
   const Smi& smi = Smi::Handle(Smi::New(124));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(smi);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(smi, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kInt32, root->type);
   EXPECT_EQ(smi.Value(), root->value.as_int32);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeSmi2) {
-  StackZone zone(Thread::Current());
+  StackZone zone(thread);
 
   // Write snapshot with object content.
   const Smi& smi = Smi::Handle(Smi::New(-1));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(smi);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(smi, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kInt32, root->type);
   EXPECT_EQ(smi.Value(), root->value.as_int32);
   CheckEncodeDecodeMessage(root);
 }
 
 
 Dart_CObject* SerializeAndDeserializeMint(const Mint& mint) {
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(mint);
   intptr_t buffer_len = writer.BytesWritten();
 
   {
     // Switch to a regular zone, where VM handle allocation is allowed.
-    StackZone zone(Thread::Current());
+    Thread* thread = Thread::Current();
+    StackZone zone(thread);
     // Read object back from the snapshot.
-    MessageSnapshotReader reader(buffer,
-                                 buffer_len,
-                                 Isolate::Current(),
-                                 Thread::Current()->zone());
+    MessageSnapshotReader reader(buffer, buffer_len, thread);
     const Object& serialized_object = Object::Handle(reader.ReadObject());
     EXPECT(serialized_object.IsMint());
   }
 
   // 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;
@@ skipping 40 matching lines @@
   // Max positive mint - 1.
   CheckMint(kMaxInt64 - 1);
   // Min negative mint.
   CheckMint(kMinInt64);
   // Min negative mint + 1.
   CheckMint(kMinInt64 + 1);
 }
 
 
 TEST_CASE(SerializeDouble) {
-  StackZone zone(Thread::Current());
+  StackZone zone(thread);
 
   // Write snapshot with object content.
   const Double& dbl = Double::Handle(Double::New(101.29));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(dbl);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(dbl, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kDouble, root->type);
   EXPECT_EQ(dbl.value(), root->value.as_double);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeTrue) {
-  StackZone zone(Thread::Current());
+  StackZone zone(thread);
 
   // Write snapshot with true object.
   const Bool& bl = Bool::True();
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(bl);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   fprintf(stderr, "%s / %s\n", bl.ToCString(), serialized_object.ToCString());
 
   EXPECT(Equals(bl, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kBool, root->type);
   EXPECT_EQ(true, root->value.as_bool);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeFalse) {
-  StackZone zone(Thread::Current());
+  StackZone zone(thread);
 
   // Write snapshot with false object.
   const Bool& bl = Bool::False();
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(bl);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(bl, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kBool, root->type);
   EXPECT_EQ(false, root->value.as_bool);
   CheckEncodeDecodeMessage(root);
 }
 
 
 static uword allocator(intptr_t size) {
   return reinterpret_cast<uword>(malloc(size));
 }
 
 
 TEST_CASE(SerializeCapability) {
-  StackZone zone(Thread::Current());
-
   // Write snapshot with object content.
   const Capability& capability = Capability::Handle(Capability::New(12345));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(capability);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   Capability& obj = Capability::Handle();
   obj ^= reader.ReadObject();
 
   EXPECT_STREQ(12345, obj.Id());
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kCapability, root->type);
   int64_t id = root->value.as_capability.id;
   EXPECT_EQ(12345, id);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeBigint) {
-  StackZone zone(Thread::Current());
-
   // Write snapshot with object content.
   const char* cstr = "0x270FFFFFFFFFFFFFD8F0";
   const String& str = String::Handle(String::New(cstr));
   Bigint& bigint = Bigint::Handle();
   bigint ^= Integer::NewCanonical(str);
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(bigint);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   Bigint& obj = Bigint::Handle();
   obj ^= reader.ReadObject();
 
   EXPECT_STREQ(bigint.ToHexCString(allocator), obj.ToHexCString(allocator));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kBigint, root->type);
   char* hex_value = TestCase::BigintToHexValue(root);
   EXPECT_STREQ(cstr, hex_value);
   free(hex_value);
   CheckEncodeDecodeMessage(root);
 }
 
 
 Dart_CObject* SerializeAndDeserializeBigint(const Bigint& bigint) {
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(bigint);
   intptr_t buffer_len = writer.BytesWritten();
 
   {
     // Switch to a regular zone, where VM handle allocation is allowed.
-    StackZone zone(Thread::Current());
+    Thread* thread = Thread::Current();
+    StackZone zone(thread);
     // Read object back from the snapshot.
-    MessageSnapshotReader reader(buffer,
-                                 buffer_len,
-                                 Isolate::Current(),
-                                 Thread::Current()->zone());
+    MessageSnapshotReader reader(buffer, buffer_len, thread);
     Bigint& serialized_bigint = Bigint::Handle();
     serialized_bigint ^= reader.ReadObject();
     const char* str1 = bigint.ToHexCString(allocator);
     const char* str2 = serialized_bigint.ToHexCString(allocator);
     EXPECT_STREQ(str1, str2);
     free(const_cast<char*>(str1));
     free(const_cast<char*>(str2));
   }
 
   // Read object back from the snapshot into a C structure.
@@ skipping 42 matching lines @@
   writer.WriteObject(Object::library_class());
   writer.WriteObject(Object::code_class());
   writer.WriteObject(Object::instructions_class());
   writer.WriteObject(Object::pc_descriptors_class());
   writer.WriteObject(Object::exception_handlers_class());
   writer.WriteObject(Object::context_class());
   writer.WriteObject(Object::context_scope_class());
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                                 buffer_len,
-                                 Isolate::Current(),
-                                 Thread::Current()->zone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   EXPECT(Object::class_class() == reader.ReadObject());
   EXPECT(Object::type_arguments_class() == reader.ReadObject());
   EXPECT(Object::function_class() == reader.ReadObject());
   EXPECT(Object::field_class() == reader.ReadObject());
   EXPECT(Object::token_stream_class() == reader.ReadObject());
   EXPECT(Object::script_class() == reader.ReadObject());
   EXPECT(Object::library_class() == reader.ReadObject());
   EXPECT(Object::code_class() == reader.ReadObject());
   EXPECT(Object::instructions_class() == reader.ReadObject());
   EXPECT(Object::pc_descriptors_class() == reader.ReadObject());
   EXPECT(Object::exception_handlers_class() == reader.ReadObject());
   EXPECT(Object::context_class() == reader.ReadObject());
   EXPECT(Object::context_scope_class() == reader.ReadObject());
 
   free(buffer);
 }
 
 
 static void TestString(const char* cstr) {
-  StackZone zone(Thread::Current());
+  Thread* thread = Thread::Current();
   EXPECT(Utf8::IsValid(reinterpret_cast<const uint8_t*>(cstr), strlen(cstr)));
   // Write snapshot with object content.
   String& str = String::Handle(String::New(cstr));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(str);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   String& serialized_str = String::Handle();
   serialized_str ^= reader.ReadObject();
   EXPECT(str.Equals(serialized_str));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kString, root->type);
   EXPECT_STREQ(cstr, root->value.as_string);
@@ skipping 10 matching lines @@
                      "\xDF\xBF"       // U+07FF
                      "\xE0\xA0\x80"   // U+0800
                      "\xEF\xBF\xBF";  // U+FFFF
 
   TestString(data);
   // TODO(sgjesse): Add tests with non-BMP characters.
 }
 
 
 TEST_CASE(SerializeArray) {
-  StackZone zone(Thread::Current());
-
   // Write snapshot with object content.
   const int kArrayLength = 10;
   Array& array = Array::Handle(Array::New(kArrayLength));
   Smi& smi = Smi::Handle();
   for (int i = 0; i < kArrayLength; i++) {
     smi ^= Smi::New(i);
     array.SetAt(i, smi);
   }
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(array);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   Array& serialized_array = Array::Handle();
   serialized_array ^= reader.ReadObject();
   EXPECT(array.CanonicalizeEquals(serialized_array));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kArray, root->type);
   EXPECT_EQ(kArrayLength, root->value.as_array.length);
@@ skipping 52 matching lines @@
 TEST_CASE(FailSerializeLargeExternalTypedData) {
   Dart_CObject root;
   root.type = Dart_CObject_kExternalTypedData;
   root.value.as_typed_data.length =
       ExternalTypedData::MaxElements(kExternalTypedDataUint8ArrayCid) + 1;
   ExpectEncodeFail(&root);
 }
 
 
 TEST_CASE(SerializeEmptyArray) {
-  StackZone zone(Thread::Current());
-
   // Write snapshot with object content.
   const int kArrayLength = 0;
   Array& array = Array::Handle(Array::New(kArrayLength));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(array);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   Array& serialized_array = Array::Handle();
   serialized_array ^= reader.ReadObject();
   EXPECT(array.CanonicalizeEquals(serialized_array));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kArray, root->type);
   EXPECT_EQ(kArrayLength, root->value.as_array.length);
   EXPECT(root->value.as_array.values == NULL);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeByteArray) {
-  StackZone zone(Thread::Current());
-
   // Write snapshot with object content.
   const int kTypedDataLength = 256;
   TypedData& typed_data = TypedData::Handle(
       TypedData::New(kTypedDataUint8ArrayCid, kTypedDataLength));
   for (int i = 0; i < kTypedDataLength; i++) {
     typed_data.SetUint8(i, i);
   }
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(typed_data);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   TypedData& serialized_typed_data = TypedData::Handle();
   serialized_typed_data ^= reader.ReadObject();
   EXPECT(serialized_typed_data.IsTypedData());
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kTypedData, root->type);
   EXPECT_EQ(kTypedDataLength, root->value.as_typed_data.length);
   for (int i = 0; i < kTypedDataLength; i++) {
     EXPECT(root->value.as_typed_data.values[i] == i);
   }
   CheckEncodeDecodeMessage(root);
 }
 
 
-#define TEST_TYPED_ARRAY(darttype, ctype)                                     \
-  {                                                                           \
-    StackZone zone(Thread::Current());                                       \
-    const int kArrayLength = 127;                                             \
-    TypedData& array = TypedData::Handle(                                     \
-        TypedData::New(kTypedData##darttype##ArrayCid, kArrayLength));        \
-    intptr_t scale = array.ElementSizeInBytes();                              \
-    for (int i = 0; i < kArrayLength; i++) {                                  \
-      array.Set##darttype((i * scale), i);                                    \
-    }                                                                         \
-    uint8_t* buffer;                                                          \
-    MessageWriter writer(&buffer, &zone_allocator, true);                     \
-    writer.WriteMessage(array);                                               \
-    intptr_t buffer_len = writer.BytesWritten();                              \
-    MessageSnapshotReader reader(buffer, buffer_len,                          \
-                          Isolate::Current(),                                 \
-                          zone.GetZone());                                    \
-    TypedData& serialized_array = TypedData::Handle();                        \
-    serialized_array ^= reader.ReadObject();                                  \
-    for (int i = 0; i < kArrayLength; i++) {                                  \
-      EXPECT_EQ(static_cast<ctype>(i),                                        \
-                serialized_array.Get##darttype(i*scale));                     \
-    }                                                                         \
+#define TEST_TYPED_ARRAY(darttype, ctype)                                      \
+  {                                                                            \
+    StackZone zone(thread);                                                    \
+    const int kArrayLength = 127;                                              \
+    TypedData& array = TypedData::Handle(                                      \
+        TypedData::New(kTypedData##darttype##ArrayCid, kArrayLength));         \
+    intptr_t scale = array.ElementSizeInBytes();                               \
+    for (int i = 0; i < kArrayLength; i++) {                                   \
+      array.Set##darttype((i * scale), i);                                     \
+    }                                                                          \
+    uint8_t* buffer;                                                           \
+    MessageWriter writer(&buffer, &zone_allocator, true);                      \
+    writer.WriteMessage(array);                                                \
+    intptr_t buffer_len = writer.BytesWritten();                               \
+    MessageSnapshotReader reader(buffer, buffer_len, thread);                  \
+    TypedData& serialized_array = TypedData::Handle();                         \
+    serialized_array ^= reader.ReadObject();                                   \
+    for (int i = 0; i < kArrayLength; i++) {                                   \
+      EXPECT_EQ(static_cast<ctype>(i),                                         \
+                serialized_array.Get##darttype(i*scale));                      \
+    }                                                                          \
   }
 
 
-#define TEST_EXTERNAL_TYPED_ARRAY(darttype, ctype)                            \
-  {                                                                           \
-    StackZone zone(Thread::Current());                                       \
-    ctype data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };                         \
-    intptr_t length = ARRAY_SIZE(data);                                       \
-    ExternalTypedData& array = ExternalTypedData::Handle(                     \
-        ExternalTypedData::New(kExternalTypedData##darttype##ArrayCid,        \
-                               reinterpret_cast<uint8_t*>(data), length));    \
-    intptr_t scale = array.ElementSizeInBytes();                              \
-    uint8_t* buffer;                                                          \
-    MessageWriter writer(&buffer, &zone_allocator, true);                     \
-    writer.WriteMessage(array);                                               \
-    intptr_t buffer_len = writer.BytesWritten();                              \
-    MessageSnapshotReader reader(buffer, buffer_len,                          \
-                          Isolate::Current(),                                 \
-                          zone.GetZone());                                    \
-    TypedData& serialized_array = TypedData::Handle();                        \
-    serialized_array ^= reader.ReadObject();                                  \
-    for (int i = 0; i < length; i++) {                                        \
-      EXPECT_EQ(static_cast<ctype>(data[i]),                                  \
-                serialized_array.Get##darttype(i*scale));                     \
-    }                                                                         \
+#define TEST_EXTERNAL_TYPED_ARRAY(darttype, ctype)                             \
+  {                                                                            \
+    StackZone zone(thread);                                                    \
+    ctype data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };                          \
+    intptr_t length = ARRAY_SIZE(data);                                        \
+    ExternalTypedData& array = ExternalTypedData::Handle(                      \
+        ExternalTypedData::New(kExternalTypedData##darttype##ArrayCid,         \
+                               reinterpret_cast<uint8_t*>(data), length));     \
+    intptr_t scale = array.ElementSizeInBytes();                               \
+    uint8_t* buffer;                                                           \
+    MessageWriter writer(&buffer, &zone_allocator, true);                      \
+    writer.WriteMessage(array);                                                \
+    intptr_t buffer_len = writer.BytesWritten();                               \
+    MessageSnapshotReader reader(buffer, buffer_len, thread);                  \
+    TypedData& serialized_array = TypedData::Handle();                         \
+    serialized_array ^= reader.ReadObject();                                   \
+    for (int i = 0; i < length; i++) {                                         \
+      EXPECT_EQ(static_cast<ctype>(data[i]),                                   \
+                serialized_array.Get##darttype(i*scale));                      \
+    }                                                                          \
   }
 
 
 TEST_CASE(SerializeTypedArray) {
   TEST_TYPED_ARRAY(Int8, int8_t);
   TEST_TYPED_ARRAY(Uint8, uint8_t);
   TEST_TYPED_ARRAY(Int16, int16_t);
   TEST_TYPED_ARRAY(Uint16, uint16_t);
   TEST_TYPED_ARRAY(Int32, int32_t);
   TEST_TYPED_ARRAY(Uint32, uint32_t);
@@ skipping 12 matching lines @@
   TEST_EXTERNAL_TYPED_ARRAY(Int32, int32_t);
   TEST_EXTERNAL_TYPED_ARRAY(Uint32, uint32_t);
   TEST_EXTERNAL_TYPED_ARRAY(Int64, int64_t);
   TEST_EXTERNAL_TYPED_ARRAY(Uint64, uint64_t);
   TEST_EXTERNAL_TYPED_ARRAY(Float32, float);
   TEST_EXTERNAL_TYPED_ARRAY(Float64, double);
 }
 
 
 TEST_CASE(SerializeEmptyByteArray) {
-  StackZone zone(Thread::Current());
-
   // Write snapshot with object content.
   const int kTypedDataLength = 0;
   TypedData& typed_data = TypedData::Handle(
       TypedData::New(kTypedDataUint8ArrayCid, kTypedDataLength));
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(typed_data);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  MessageSnapshotReader reader(buffer,
-                               buffer_len,
-                               Isolate::Current(),
-                               zone.GetZone());
+  MessageSnapshotReader reader(buffer, buffer_len, thread);
   TypedData& serialized_typed_data = TypedData::Handle();
   serialized_typed_data ^= reader.ReadObject();
   EXPECT(serialized_typed_data.IsTypedData());
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kTypedData, root->type);
   EXPECT_EQ(Dart_TypedData_kUint8, root->value.as_typed_data.type);
@@ skipping 118 matching lines @@
   Library& lib = Library::Handle(Library::New(lib_url));
   lib.Register();
   EXPECT(CompilerTest::TestCompileScript(lib, script));
 
   // Write snapshot with script content.
   uint8_t* buffer;
   TestSnapshotWriter writer(&buffer, &malloc_allocator);
   writer.WriteScript(script);
 
   // Read object back from the snapshot.
-  ScriptSnapshotReader reader(buffer,
-                              writer.BytesWritten(),
-                              Isolate::Current(),
-                              Thread::Current()->zone());
-  Script& serialized_script = Script::Handle();
+  ScriptSnapshotReader reader(buffer, writer.BytesWritten(), thread);
+  Script& serialized_script = Script::Handle(thread->zone());
   serialized_script ^= reader.ReadObject();
 
   // Check if the serialized script object matches the original script.
   String& expected_literal = String::Handle();
   String& actual_literal = String::Handle();
   String& str = String::Handle();
   str ^= serialized_script.url();
   EXPECT(url.Equals(str));
 
   const TokenStream& expected_tokens = TokenStream::Handle(script.tokens());
@@ skipping 198 matching lines @@
   uint8_t* isolate_snapshot_buffer;
 
   // Start an Isolate, load a script and create a full snapshot.
   Timer timer1(true, "Snapshot_test");
   timer1.Start();
   {
     TestIsolateScope __test_isolate__;
 
     Isolate* isolate = Isolate::Current();
     StackZone zone(isolate);
-    HandleScope scope(isolate);
+    HandleScope scope(Thread::Current());
 
     // Create a test library and Load up a test script in it.
     TestCase::LoadTestScript(kScriptChars, NULL);
     EXPECT_VALID(Api::CheckAndFinalizePendingClasses(isolate));
     timer1.Stop();
     OS::PrintErr("Without Snapshot: %" Pd64 "us\n", timer1.TotalElapsedTime());
 
     // Write snapshot with object content.
     {
       FullSnapshotWriter writer(NULL,
@@ skipping 38 matching lines @@
   uint8_t* isolate_snapshot_buffer;
 
   // Start an Isolate, load a script and create a full snapshot.
   Timer timer1(true, "Snapshot_test");
   timer1.Start();
   {
     TestIsolateScope __test_isolate__;
 
     Isolate* isolate = Isolate::Current();
     StackZone zone(isolate);
-    HandleScope scope(isolate);
+    HandleScope scope(Thread::Current());
 
     // Create a test library and Load up a test script in it.
     Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
     EXPECT_VALID(Api::CheckAndFinalizePendingClasses(isolate));
     timer1.Stop();
     OS::PrintErr("Without Snapshot: %" Pd64 "us\n", timer1.TotalElapsedTime());
 
     // Write snapshot with object content.
     {
       FullSnapshotWriter writer(NULL,
@@ skipping 584 matching lines @@
   EXPECT_VALID(surrogates_string_result);
   EXPECT(Dart_IsString(surrogates_string_result));
 
   Dart_Handle crappy_string_result;
   crappy_string_result =
       Dart_Invoke(lib, NewString("getCrappyString"), 0, NULL);
   EXPECT_VALID(crappy_string_result);
   EXPECT(Dart_IsString(crappy_string_result));
 
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
 
     {
       StackZone zone(Thread::Current());
       Smi& smi = Smi::Handle();
       smi ^= Api::UnwrapHandle(smi_result);
       uint8_t* buffer;
       MessageWriter writer(&buffer, &zone_allocator, false);
       writer.WriteMessage(smi);
       intptr_t buffer_len = writer.BytesWritten();
 
@@ skipping 71 matching lines @@
 
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   Dart_EnterScope();
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
 
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     StackZone zone(isolate);
     intptr_t buf_len = 0;
     {
       // Generate a list of nulls from Dart code.
       uint8_t* buf = GetSerialized(lib, "getList", &buf_len);
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserialized(buf, buf_len);
       EXPECT_NOTNULL(root);
       EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
@@ skipping 103 matching lines @@
 
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   Dart_EnterScope();
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
 
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     StackZone zone(isolate);
     intptr_t buf_len = 0;
     {
       // Generate a list of nulls from Dart code.
       uint8_t* buf = GetSerialized(lib, "getList", &buf_len);
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserialized(buf, buf_len);
       EXPECT_NOTNULL(root);
       EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
@@ skipping 218 matching lines @@
 
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   Dart_EnterScope();
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
 
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     StackZone zone(isolate);
     intptr_t buf_len = 0;
     {
       // Generate a list of strings from Dart code.
       uint8_t* buf = GetSerialized(lib, "getStringList", &buf_len);
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserialized(buf, buf_len);
       EXPECT_NOTNULL(root);
       EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
@@ skipping 204 matching lines @@
 
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   Dart_EnterScope();
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
 
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     StackZone zone(isolate);
     intptr_t buf_len = 0;
     {
       // Generate a list of strings from Dart code.
       uint8_t* buf = GetSerialized(lib, "getStringList", &buf_len);
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserialized(buf, buf_len);
       EXPECT_NOTNULL(root);
       EXPECT_EQ(Dart_CObject_kArray, root->type);
       EXPECT_EQ(kArrayLength, root->value.as_array.length);
@@ skipping 220 matching lines @@
 
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   Dart_EnterScope();
 
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
 
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     StackZone zone(isolate);
     intptr_t buf_len = 0;
     {
       // Generate a list of Uint8Lists from Dart code.
       uint8_t* buf = GetSerialized(lib, "getTypedDataList", &buf_len);
       ApiNativeScope scope;
       Dart_CObject* root = GetDeserialized(buf, buf_len);
       EXPECT_NOTNULL(root);
       EXPECT_EQ(Dart_CObject_kArray, root->type);
       struct {
@@ skipping 222 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