Get rid of ZoneScope completely.

test/cctest/test-regexp.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 54 matching lines @@
 #include "ia32/regexp-macro-assembler-ia32.h"
 #endif
 #endif  // V8_INTERPRETED_REGEXP
 
 using namespace v8::internal;
 
 
 static bool CheckParse(const char* input) {
   V8::Initialize(NULL);
   v8::HandleScope scope(v8::Isolate::GetCurrent());
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
+  Zone zone(Isolate::Current());
   FlatStringReader reader(Isolate::Current(), CStrVector(input));
   RegExpCompileData result;
   return v8::internal::RegExpParser::ParseRegExp(
-      &reader, false, &result, Isolate::Current()->runtime_zone());
+      &reader, false, &result, &zone);
 }
 
 
 static SmartArrayPointer<const char> Parse(const char* input) {
   V8::Initialize(NULL);
   v8::HandleScope scope(v8::Isolate::GetCurrent());
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
+  Zone zone(Isolate::Current());
   FlatStringReader reader(Isolate::Current(), CStrVector(input));
   RegExpCompileData result;
   CHECK(v8::internal::RegExpParser::ParseRegExp(
-      &reader, false, &result, Isolate::Current()->runtime_zone()));
+      &reader, false, &result, &zone));
   CHECK(result.tree != NULL);
   CHECK(result.error.is_null());
-  SmartArrayPointer<const char> output =
-      result.tree->ToString(Isolate::Current()->runtime_zone());
+  SmartArrayPointer<const char> output = result.tree->ToString(&zone);
   return output;
 }
 
 static bool CheckSimple(const char* input) {
   V8::Initialize(NULL);
   v8::HandleScope scope(v8::Isolate::GetCurrent());
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
+  Zone zone(Isolate::Current());
   FlatStringReader reader(Isolate::Current(), CStrVector(input));
   RegExpCompileData result;
   CHECK(v8::internal::RegExpParser::ParseRegExp(
-      &reader, false, &result, Isolate::Current()->runtime_zone()));
+      &reader, false, &result, &zone));
   CHECK(result.tree != NULL);
   CHECK(result.error.is_null());
   return result.simple;
 }
 
 struct MinMaxPair {
   int min_match;
   int max_match;
 };
 
 static MinMaxPair CheckMinMaxMatch(const char* input) {
   V8::Initialize(NULL);
   v8::HandleScope scope(v8::Isolate::GetCurrent());
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
+  Zone zone(Isolate::Current());
   FlatStringReader reader(Isolate::Current(), CStrVector(input));
   RegExpCompileData result;
   CHECK(v8::internal::RegExpParser::ParseRegExp(
-      &reader, false, &result, Isolate::Current()->runtime_zone()));
+      &reader, false, &result, &zone));
   CHECK(result.tree != NULL);
   CHECK(result.error.is_null());
   int min_match = result.tree->min_match();
   int max_match = result.tree->max_match();
   MinMaxPair pair = { min_match, max_match };
   return pair;
 }
 
 
 #define CHECK_PARSE_ERROR(input) CHECK(!CheckParse(input))
@@ skipping 248 matching lines @@
   CHECK_PARSE_EQ("[A-Z$-][x]", "(! [A-Z $ -] [x])");
   CHECK_PARSE_EQ("a{3,4*}", "(: 'a{3,' (# 0 - g '4') '}')");
   CHECK_PARSE_EQ("{", "'{'");
   CHECK_PARSE_EQ("a|", "(| 'a' %)");
 }
 
 static void ExpectError(const char* input,
                         const char* expected) {
   V8::Initialize(NULL);
   v8::HandleScope scope(v8::Isolate::GetCurrent());
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
+  Zone zone(Isolate::Current());
   FlatStringReader reader(Isolate::Current(), CStrVector(input));
   RegExpCompileData result;
   CHECK(!v8::internal::RegExpParser::ParseRegExp(
-      &reader, false, &result, Isolate::Current()->runtime_zone()));
+      &reader, false, &result, &zone));
   CHECK(result.tree == NULL);
   CHECK(!result.error.is_null());
   SmartArrayPointer<char> str = result.error->ToCString(ALLOW_NULLS);
   CHECK_EQ(expected, *str);
 }
 
 
 TEST(Errors) {
   V8::Initialize(NULL);
   const char* kEndBackslash = "\\ at end of pattern";
@@ skipping 59 matching lines @@
   return !IsWhiteSpace(c);
 }
 
 
 static bool NotWord(uc16 c) {
   return !IsRegExpWord(c);
 }
 
 
 static void TestCharacterClassEscapes(uc16 c, bool (pred)(uc16 c)) {
-  ZoneScope scope(Isolate::Current()->runtime_zone());
-  Zone* zone = Isolate::Current()->runtime_zone();
+  Zone zone(Isolate::Current());
   ZoneList<CharacterRange>* ranges =
-      new(zone) ZoneList<CharacterRange>(2, zone);
-  CharacterRange::AddClassEscape(c, ranges, zone);
+      new(&zone) ZoneList<CharacterRange>(2, &zone);
+  CharacterRange::AddClassEscape(c, ranges, &zone);
   for (unsigned i = 0; i < (1 << 16); i++) {
     bool in_class = false;
     for (int j = 0; !in_class && j < ranges->length(); j++) {
       CharacterRange& range = ranges->at(j);
       in_class = (range.from() <= i && i <= range.to());
     }
     CHECK_EQ(pred(i), in_class);
   }
 }
 
 
 TEST(CharacterClassEscapes) {
   v8::internal::V8::Initialize(NULL);
   TestCharacterClassEscapes('.', IsRegExpNewline);
   TestCharacterClassEscapes('d', IsDigit);
   TestCharacterClassEscapes('D', NotDigit);
   TestCharacterClassEscapes('s', IsWhiteSpace);
   TestCharacterClassEscapes('S', NotWhiteSpace);
   TestCharacterClassEscapes('w', IsRegExpWord);
   TestCharacterClassEscapes('W', NotWord);
 }
 
 
-static RegExpNode* Compile(const char* input, bool multiline, bool is_ascii) {
+static RegExpNode* Compile(const char* input,
+                           bool multiline,
+                           bool is_ascii,
+                           Zone* zone) {
   V8::Initialize(NULL);
   Isolate* isolate = Isolate::Current();
   FlatStringReader reader(isolate, CStrVector(input));
   RegExpCompileData compile_data;
   if (!v8::internal::RegExpParser::ParseRegExp(&reader, multiline,
-                                               &compile_data,
-                                               isolate->runtime_zone()))
+                                               &compile_data, zone))
     return NULL;
   Handle<String> pattern = isolate->factory()->
       NewStringFromUtf8(CStrVector(input));
   Handle<String> sample_subject =
       isolate->factory()->NewStringFromUtf8(CStrVector(""));
   RegExpEngine::Compile(&compile_data,
                         false,
                         false,
                         multiline,
                         pattern,
                         sample_subject,
                         is_ascii,
-                        isolate->runtime_zone());
+                        zone);
   return compile_data.node;
 }
 
 
 static void Execute(const char* input,
                     bool multiline,
                     bool is_ascii,
                     bool dot_output = false) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
-  RegExpNode* node = Compile(input, multiline, is_ascii);
+  Zone zone(Isolate::Current());
+  RegExpNode* node = Compile(input, multiline, is_ascii, &zone);
   USE(node);
 #ifdef DEBUG
   if (dot_output) {
     RegExpEngine::DotPrint(input, node, false);
     exit(0);
   }
 #endif  // DEBUG
 }
 
 
@@ skipping 18 matching lines @@
 
 
 static unsigned PseudoRandom(int i, int j) {
   return ~(~((i * 781) ^ (j * 329)));
 }
 
 
 TEST(SplayTreeSimple) {
   v8::internal::V8::Initialize(NULL);
   static const unsigned kLimit = 1000;
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
-  ZoneSplayTree<TestConfig> tree(Isolate::Current()->runtime_zone());
+  Zone zone(Isolate::Current());
+  ZoneSplayTree<TestConfig> tree(&zone);
   bool seen[kLimit];
   for (unsigned i = 0; i < kLimit; i++) seen[i] = false;
 #define CHECK_MAPS_EQUAL() do {                                      \
     for (unsigned k = 0; k < kLimit; k++)                            \
       CHECK_EQ(seen[k], tree.Find(k, &loc));                         \
   } while (false)
   for (int i = 0; i < 50; i++) {
     for (int j = 0; j < 50; j++) {
       unsigned next = PseudoRandom(i, j) % kLimit;
       if (seen[next]) {
@@ skipping 46 matching lines @@
     Vector<uc16> range(ranges[i], 2 * kRangeSize);
     for (int j = 0; j < 2 * kRangeSize; j++) {
       range[j] = PseudoRandom(i + 25, j + 87) % kLimit;
     }
     range.Sort();
     for (int j = 1; j < 2 * kRangeSize; j++) {
       CHECK(range[j-1] <= range[j]);
     }
   }
   // Enter test data into dispatch table.
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
-  DispatchTable table(Isolate::Current()->runtime_zone());
+  Zone zone(Isolate::Current());
+  DispatchTable table(&zone);
   for (int i = 0; i < kRangeCount; i++) {
     uc16* range = ranges[i];
     for (int j = 0; j < 2 * kRangeSize; j += 2)
-      table.AddRange(CharacterRange(range[j], range[j + 1]), i,
-                     Isolate::Current()->runtime_zone());
+      table.AddRange(CharacterRange(range[j], range[j + 1]), i, &zone);
   }
   // Check that the table looks as we would expect
   for (int p = 0; p < kLimit; p++) {
     OutSet* outs = table.Get(p);
     for (int j = 0; j < kRangeCount; j++) {
       uc16* range = ranges[j];
       bool is_on = false;
       for (int k = 0; !is_on && (k < 2 * kRangeSize); k += 2)
         is_on = (range[k] <= p && p <= range[k + 1]);
       CHECK_EQ(is_on, outs->Get(j));
@@ skipping 42 matching lines @@
 #elif V8_TARGET_ARCH_ARM
 typedef RegExpMacroAssemblerARM ArchRegExpMacroAssembler;
 #elif V8_TARGET_ARCH_MIPS
 typedef RegExpMacroAssemblerMIPS ArchRegExpMacroAssembler;
 #endif
 
 class ContextInitializer {
  public:
   ContextInitializer()
       : scope_(v8::Isolate::GetCurrent()),
-        env_(v8::Context::New(v8::Isolate::GetCurrent())),
-        zone_(Isolate::Current()->runtime_zone()) {
+        env_(v8::Context::New(v8::Isolate::GetCurrent())) {
     env_->Enter();
   }
   ~ContextInitializer() {
     env_->Exit();
   }
  private:
   v8::HandleScope scope_;
   v8::Handle<v8::Context> env_;
-  v8::internal::ZoneScope zone_;
 };
 
 
 static ArchRegExpMacroAssembler::Result Execute(Code* code,
                                                 String* input,
                                                 int start_offset,
                                                 const byte* input_start,
                                                 const byte* input_end,
                                                 int* captures) {
   return NativeRegExpMacroAssembler::Execute(
       code,
       input,
       start_offset,
       input_start,
       input_end,
       captures,
       0,
       Isolate::Current());
 }
 
 
 TEST(MacroAssemblerNativeSuccess) {
   v8::V8::Initialize();
   ContextInitializer initializer;
-  Factory* factory = Isolate::Current()->factory();
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Zone zone(isolate);
 
-  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4,
-                             Isolate::Current()->runtime_zone());
+  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4, &zone);
 
   m.Succeed();
 
   Handle<String> source = factory->NewStringFromAscii(CStrVector(""));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
 
   int captures[4] = {42, 37, 87, 117};
   Handle<String> input = factory->NewStringFromAscii(CStrVector("foofoo"));
   Handle<SeqOneByteString> seq_input = Handle<SeqOneByteString>::cast(input);
@@ skipping 12 matching lines @@
   CHECK_EQ(-1, captures[0]);
   CHECK_EQ(-1, captures[1]);
   CHECK_EQ(-1, captures[2]);
   CHECK_EQ(-1, captures[3]);
 }
 
 
 TEST(MacroAssemblerNativeSimple) {
   v8::V8::Initialize();
   ContextInitializer initializer;
-  Factory* factory = Isolate::Current()->factory();
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Zone zone(isolate);
 
-  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4,
-                             Isolate::Current()->runtime_zone());
+  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4, &zone);
 
   Label fail, backtrack;
   m.PushBacktrack(&fail);
   m.CheckNotAtStart(NULL);
   m.LoadCurrentCharacter(2, NULL);
   m.CheckNotCharacter('o', NULL);
   m.LoadCurrentCharacter(1, NULL, false);
   m.CheckNotCharacter('o', NULL);
   m.LoadCurrentCharacter(0, NULL, false);
   m.CheckNotCharacter('f', NULL);
@@ skipping 41 matching lines @@
                    start_adr + input->length(),
                    captures);
 
   CHECK_EQ(NativeRegExpMacroAssembler::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerNativeSimpleUC16) {
   v8::V8::Initialize();
   ContextInitializer initializer;
-  Factory* factory = Isolate::Current()->factory();
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Zone zone(isolate);
 
-  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4,
-                             Isolate::Current()->runtime_zone());
+  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4, &zone);
 
   Label fail, backtrack;
   m.PushBacktrack(&fail);
   m.CheckNotAtStart(NULL);
   m.LoadCurrentCharacter(2, NULL);
   m.CheckNotCharacter('o', NULL);
   m.LoadCurrentCharacter(1, NULL, false);
   m.CheckNotCharacter('o', NULL);
   m.LoadCurrentCharacter(0, NULL, false);
   m.CheckNotCharacter('f', NULL);
@@ skipping 46 matching lines @@
                    start_adr + input->length() * 2,
                    captures);
 
   CHECK_EQ(NativeRegExpMacroAssembler::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerNativeBacktrack) {
   v8::V8::Initialize();
   ContextInitializer initializer;
-  Factory* factory = Isolate::Current()->factory();
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Zone zone(isolate);
 
-  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0,
-                             Isolate::Current()->runtime_zone());
+  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0, &zone);
 
   Label fail;
   Label backtrack;
   m.LoadCurrentCharacter(10, &fail);
   m.Succeed();
   m.Bind(&fail);
   m.PushBacktrack(&backtrack);
   m.LoadCurrentCharacter(10, NULL);
   m.Succeed();
   m.Bind(&backtrack);
@@ skipping 15 matching lines @@
               start_adr + input->length(),
               NULL);
 
   CHECK_EQ(NativeRegExpMacroAssembler::FAILURE, result);
 }
 
 
 TEST(MacroAssemblerNativeBackReferenceASCII) {
   v8::V8::Initialize();
   ContextInitializer initializer;
-  Factory* factory = Isolate::Current()->factory();
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Zone zone(isolate);
 
-  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4,
-                             Isolate::Current()->runtime_zone());
+  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4, &zone);
 
   m.WriteCurrentPositionToRegister(0, 0);
   m.AdvanceCurrentPosition(2);
   m.WriteCurrentPositionToRegister(1, 0);
   Label nomatch;
   m.CheckNotBackReference(0, &nomatch);
   m.Fail();
   m.Bind(&nomatch);
   m.AdvanceCurrentPosition(2);
   Label missing_match;
@@ skipping 24 matching lines @@
   CHECK_EQ(0, output[0]);
   CHECK_EQ(2, output[1]);
   CHECK_EQ(6, output[2]);
   CHECK_EQ(-1, output[3]);
 }
 
 
 TEST(MacroAssemblerNativeBackReferenceUC16) {
   v8::V8::Initialize();
   ContextInitializer initializer;
-  Factory* factory = Isolate::Current()->factory();
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Zone zone(isolate);
 
-  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4,
-                             Isolate::Current()->runtime_zone());
+  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::UC16, 4, &zone);
 
   m.WriteCurrentPositionToRegister(0, 0);
   m.AdvanceCurrentPosition(2);
   m.WriteCurrentPositionToRegister(1, 0);
   Label nomatch;
   m.CheckNotBackReference(0, &nomatch);
   m.Fail();
   m.Bind(&nomatch);
   m.AdvanceCurrentPosition(2);
   Label missing_match;
@@ skipping 27 matching lines @@
   CHECK_EQ(2, output[1]);
   CHECK_EQ(6, output[2]);
   CHECK_EQ(-1, output[3]);
 }
 
 
 
 TEST(MacroAssemblernativeAtStart) {
   v8::V8::Initialize();
   ContextInitializer initializer;
-  Factory* factory = Isolate::Current()->factory();
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Zone zone(isolate);
 
-  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0,
-                             Isolate::Current()->runtime_zone());
+  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0, &zone);
 
   Label not_at_start, newline, fail;
   m.CheckNotAtStart(&not_at_start);
   // Check that prevchar = '\n' and current = 'f'.
   m.CheckCharacter('\n', &newline);
   m.Bind(&fail);
   m.Fail();
   m.Bind(&newline);
   m.LoadCurrentCharacter(0, &fail);
   m.CheckNotCharacter('f', &fail);
@@ skipping 34 matching lines @@
                    start_adr + input->length(),
                    NULL);
 
   CHECK_EQ(NativeRegExpMacroAssembler::SUCCESS, result);
 }
 
 
 TEST(MacroAssemblerNativeBackRefNoCase) {
   v8::V8::Initialize();
   ContextInitializer initializer;
-  Factory* factory = Isolate::Current()->factory();
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Zone zone(isolate);
 
-  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4,
-                             Isolate::Current()->runtime_zone());
+  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 4, &zone);
 
   Label fail, succ;
 
   m.WriteCurrentPositionToRegister(0, 0);
   m.WriteCurrentPositionToRegister(2, 0);
   m.AdvanceCurrentPosition(3);
   m.WriteCurrentPositionToRegister(3, 0);
   m.CheckNotBackReferenceIgnoreCase(2, &fail);  // Match "AbC".
   m.CheckNotBackReferenceIgnoreCase(2, &fail);  // Match "ABC".
   Label expected_fail;
@@ skipping 34 matching lines @@
   CHECK_EQ(12, output[1]);
   CHECK_EQ(0, output[2]);
   CHECK_EQ(3, output[3]);
 }
 
 
 
 TEST(MacroAssemblerNativeRegisters) {
   v8::V8::Initialize();
   ContextInitializer initializer;
-  Factory* factory = Isolate::Current()->factory();
+  Isolate* isolate = Isolate::Current();
+  Factory* factory = isolate->factory();
+  Zone zone(isolate);
 
-  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 6,
-                             Isolate::Current()->runtime_zone());
+  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 6, &zone);
 
   uc16 foo_chars[3] = {'f', 'o', 'o'};
   Vector<const uc16> foo(foo_chars, 3);
 
   enum registers { out1, out2, out3, out4, out5, out6, sp, loop_cnt };
   Label fail;
   Label backtrack;
   m.WriteCurrentPositionToRegister(out1, 0);  // Output: [0]
   m.PushRegister(out1, RegExpMacroAssembler::kNoStackLimitCheck);
   m.PushBacktrack(&backtrack);
@@ skipping 80 matching lines @@
   CHECK_EQ(9, output[4]);
   CHECK_EQ(-1, output[5]);
 }
 
 
 TEST(MacroAssemblerStackOverflow) {
   v8::V8::Initialize();
   ContextInitializer initializer;
   Isolate* isolate = Isolate::Current();
   Factory* factory = isolate->factory();
+  Zone zone(isolate);
 
-  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0,
-                             Isolate::Current()->runtime_zone());
+  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 0, &zone);
 
   Label loop;
   m.Bind(&loop);
   m.PushBacktrack(&loop);
   m.GoTo(&loop);
 
   Handle<String> source =
       factory->NewStringFromAscii(CStrVector("<stack overflow test>"));
   Handle<Object> code_object = m.GetCode(source);
   Handle<Code> code = Handle<Code>::cast(code_object);
@@ skipping 16 matching lines @@
   CHECK(isolate->has_pending_exception());
   isolate->clear_pending_exception();
 }
 
 
 TEST(MacroAssemblerNativeLotsOfRegisters) {
   v8::V8::Initialize();
   ContextInitializer initializer;
   Isolate* isolate = Isolate::Current();
   Factory* factory = isolate->factory();
+  Zone zone(isolate);
 
-  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 2,
-                             Isolate::Current()->runtime_zone());
+  ArchRegExpMacroAssembler m(NativeRegExpMacroAssembler::ASCII, 2, &zone);
 
   // At least 2048, to ensure the allocated space for registers
   // span one full page.
   const int large_number = 8000;
   m.WriteCurrentPositionToRegister(large_number, 42);
   m.WriteCurrentPositionToRegister(0, 0);
   m.WriteCurrentPositionToRegister(1, 1);
   Label done;
   m.CheckNotBackReference(0, &done);  // Performs a system-stack push.
   m.Bind(&done);
@@ skipping 26 matching lines @@
   CHECK_EQ(42, captures[1]);
 
   isolate->clear_pending_exception();
 }
 
 #else  // V8_INTERPRETED_REGEXP
 
 TEST(MacroAssembler) {
   V8::Initialize(NULL);
   byte codes[1024];
-  RegExpMacroAssemblerIrregexp m(Vector<byte>(codes, 1024),
-                                 Isolate::Current()->runtime_zone());
+  Zone zone(Isolate::Current());
+  RegExpMacroAssemblerIrregexp m(Vector<byte>(codes, 1024), &zone);
   // ^f(o)o.
   Label start, fail, backtrack;
 
   m.SetRegister(4, 42);
   m.PushRegister(4, RegExpMacroAssembler::kNoStackLimitCheck);
   m.AdvanceRegister(4, 42);
   m.GoTo(&start);
   m.Fail();
   m.Bind(&start);
   m.PushBacktrack(&fail);
@@ skipping 46 matching lines @@
 }
 
 #endif  // V8_INTERPRETED_REGEXP
 
 
 TEST(AddInverseToTable) {
   v8::internal::V8::Initialize(NULL);
   static const int kLimit = 1000;
   static const int kRangeCount = 16;
   for (int t = 0; t < 10; t++) {
-    ZoneScope zone_scope(Isolate::Current()->runtime_zone());
-    Zone* zone = Isolate::Current()->runtime_zone();
+    Zone zone(Isolate::Current());
     ZoneList<CharacterRange>* ranges =
-        new(zone)
-        ZoneList<CharacterRange>(kRangeCount, zone);
+        new(&zone) ZoneList<CharacterRange>(kRangeCount, &zone);
     for (int i = 0; i < kRangeCount; i++) {
       int from = PseudoRandom(t + 87, i + 25) % kLimit;
       int to = from + (PseudoRandom(i + 87, t + 25) % (kLimit / 20));
       if (to > kLimit) to = kLimit;
-      ranges->Add(CharacterRange(from, to), zone);
+      ranges->Add(CharacterRange(from, to), &zone);
     }
-    DispatchTable table(zone);
-    DispatchTableConstructor cons(&table, false,
-                                  Isolate::Current()->runtime_zone());
+    DispatchTable table(&zone);
+    DispatchTableConstructor cons(&table, false, &zone);
     cons.set_choice_index(0);
     cons.AddInverse(ranges);
     for (int i = 0; i < kLimit; i++) {
       bool is_on = false;
       for (int j = 0; !is_on && j < kRangeCount; j++)
         is_on = ranges->at(j).Contains(i);
       OutSet* set = table.Get(i);
       CHECK_EQ(is_on, set->Get(0) == false);
     }
   }
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
-  Zone* zone = Isolate::Current()->runtime_zone();
+  Zone zone(Isolate::Current());
   ZoneList<CharacterRange>* ranges =
-      new(zone) ZoneList<CharacterRange>(1, zone);
-  ranges->Add(CharacterRange(0xFFF0, 0xFFFE), zone);
-  DispatchTable table(zone);
-  DispatchTableConstructor cons(&table, false,
-                                Isolate::Current()->runtime_zone());
+      new(&zone) ZoneList<CharacterRange>(1, &zone);
+  ranges->Add(CharacterRange(0xFFF0, 0xFFFE), &zone);
+  DispatchTable table(&zone);
+  DispatchTableConstructor cons(&table, false, &zone);
   cons.set_choice_index(0);
   cons.AddInverse(ranges);
   CHECK(!table.Get(0xFFFE)->Get(0));
   CHECK(table.Get(0xFFFF)->Get(0));
 }
 
 
 static uc32 canonicalize(uc32 c) {
   unibrow::uchar canon[unibrow::Ecma262Canonicalize::kMaxWidth];
   int count = unibrow::Ecma262Canonicalize::Convert(c, '\0', canon, NULL);
@@ skipping 87 matching lines @@
       CHECK_EQ(length, length2);
       for (int k = 0; k < length; k++)
         CHECK_EQ(static_cast<int>(chars[k]), static_cast<int>(chars2[k]));
     }
   }
 }
 
 
 static void TestRangeCaseIndependence(CharacterRange input,
                                       Vector<CharacterRange> expected) {
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
-  Zone* zone = Isolate::Current()->runtime_zone();
+  Zone zone(Isolate::Current());
   int count = expected.length();
   ZoneList<CharacterRange>* list =
-      new(zone) ZoneList<CharacterRange>(count, zone);
-  input.AddCaseEquivalents(list, false, zone);
+      new(&zone) ZoneList<CharacterRange>(count, &zone);
+  input.AddCaseEquivalents(list, false, &zone);
   CHECK_EQ(count, list->length());
   for (int i = 0; i < list->length(); i++) {
     CHECK_EQ(expected[i].from(), list->at(i).from());
     CHECK_EQ(expected[i].to(), list->at(i).to());
   }
 }
 
 
 static void TestSimpleRangeCaseIndependence(CharacterRange input,
                                             CharacterRange expected) {
@@ skipping 40 matching lines @@
     CharacterRange range = ranges->at(i);
     if (range.from() <= c && c <= range.to())
       return true;
   }
   return false;
 }
 
 
 TEST(CharClassDifference) {
   v8::internal::V8::Initialize(NULL);
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
-  Zone* zone = Isolate::Current()->runtime_zone();
+  Zone zone(Isolate::Current());
   ZoneList<CharacterRange>* base =
-      new(zone) ZoneList<CharacterRange>(1, zone);
-  base->Add(CharacterRange::Everything(), zone);
+      new(&zone) ZoneList<CharacterRange>(1, &zone);
+  base->Add(CharacterRange::Everything(), &zone);
   Vector<const int> overlay = CharacterRange::GetWordBounds();
   ZoneList<CharacterRange>* included = NULL;
   ZoneList<CharacterRange>* excluded = NULL;
-  CharacterRange::Split(base, overlay, &included, &excluded,
-                        Isolate::Current()->runtime_zone());
+  CharacterRange::Split(base, overlay, &included, &excluded, &zone);
   for (int i = 0; i < (1 << 16); i++) {
     bool in_base = InClass(i, base);
     if (in_base) {
       bool in_overlay = false;
       for (int j = 0; !in_overlay && j < overlay.length(); j += 2) {
         if (overlay[j] <= i && i < overlay[j+1])
           in_overlay = true;
       }
       CHECK_EQ(in_overlay, InClass(i, included));
       CHECK_EQ(!in_overlay, InClass(i, excluded));
     } else {
       CHECK(!InClass(i, included));
       CHECK(!InClass(i, excluded));
     }
   }
 }
 
 
 TEST(CanonicalizeCharacterSets) {
   v8::internal::V8::Initialize(NULL);
-  ZoneScope scope(Isolate::Current()->runtime_zone());
-  Zone* zone = Isolate::Current()->runtime_zone();
+  Zone zone(Isolate::Current());
   ZoneList<CharacterRange>* list =
-      new(zone) ZoneList<CharacterRange>(4, zone);
+      new(&zone) ZoneList<CharacterRange>(4, &zone);
   CharacterSet set(list);
 
-  list->Add(CharacterRange(10, 20), zone);
-  list->Add(CharacterRange(30, 40), zone);
-  list->Add(CharacterRange(50, 60), zone);
+  list->Add(CharacterRange(10, 20), &zone);
+  list->Add(CharacterRange(30, 40), &zone);
+  list->Add(CharacterRange(50, 60), &zone);
   set.Canonicalize();
   ASSERT_EQ(3, list->length());
   ASSERT_EQ(10, list->at(0).from());
   ASSERT_EQ(20, list->at(0).to());
   ASSERT_EQ(30, list->at(1).from());
   ASSERT_EQ(40, list->at(1).to());
   ASSERT_EQ(50, list->at(2).from());
   ASSERT_EQ(60, list->at(2).to());
 
   list->Rewind(0);
-  list->Add(CharacterRange(10, 20), zone);
-  list->Add(CharacterRange(50, 60), zone);
-  list->Add(CharacterRange(30, 40), zone);
+  list->Add(CharacterRange(10, 20), &zone);
+  list->Add(CharacterRange(50, 60), &zone);
+  list->Add(CharacterRange(30, 40), &zone);
   set.Canonicalize();
   ASSERT_EQ(3, list->length());
   ASSERT_EQ(10, list->at(0).from());
   ASSERT_EQ(20, list->at(0).to());
   ASSERT_EQ(30, list->at(1).from());
   ASSERT_EQ(40, list->at(1).to());
   ASSERT_EQ(50, list->at(2).from());
   ASSERT_EQ(60, list->at(2).to());
 
   list->Rewind(0);
-  list->Add(CharacterRange(30, 40), zone);
-  list->Add(CharacterRange(10, 20), zone);
-  list->Add(CharacterRange(25, 25), zone);
-  list->Add(CharacterRange(100, 100), zone);
-  list->Add(CharacterRange(1, 1), zone);
+  list->Add(CharacterRange(30, 40), &zone);
+  list->Add(CharacterRange(10, 20), &zone);
+  list->Add(CharacterRange(25, 25), &zone);
+  list->Add(CharacterRange(100, 100), &zone);
+  list->Add(CharacterRange(1, 1), &zone);
   set.Canonicalize();
   ASSERT_EQ(5, list->length());
   ASSERT_EQ(1, list->at(0).from());
   ASSERT_EQ(1, list->at(0).to());
   ASSERT_EQ(10, list->at(1).from());
   ASSERT_EQ(20, list->at(1).to());
   ASSERT_EQ(25, list->at(2).from());
   ASSERT_EQ(25, list->at(2).to());
   ASSERT_EQ(30, list->at(3).from());
   ASSERT_EQ(40, list->at(3).to());
   ASSERT_EQ(100, list->at(4).from());
   ASSERT_EQ(100, list->at(4).to());
 
   list->Rewind(0);
-  list->Add(CharacterRange(10, 19), zone);
-  list->Add(CharacterRange(21, 30), zone);
-  list->Add(CharacterRange(20, 20), zone);
+  list->Add(CharacterRange(10, 19), &zone);
+  list->Add(CharacterRange(21, 30), &zone);
+  list->Add(CharacterRange(20, 20), &zone);
   set.Canonicalize();
   ASSERT_EQ(1, list->length());
   ASSERT_EQ(10, list->at(0).from());
   ASSERT_EQ(30, list->at(0).to());
 }
 
 
 TEST(CharacterRangeMerge) {
   v8::internal::V8::Initialize(NULL);
-  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
-  ZoneList<CharacterRange> l1(4, Isolate::Current()->runtime_zone());
-  ZoneList<CharacterRange> l2(4, Isolate::Current()->runtime_zone());
-  Zone* zone = Isolate::Current()->runtime_zone();
+  Zone zone(Isolate::Current());
+  ZoneList<CharacterRange> l1(4, &zone);
+  ZoneList<CharacterRange> l2(4, &zone);
   // Create all combinations of intersections of ranges, both singletons and
   // longer.
 
   int offset = 0;
 
   // The five kinds of singleton intersections:
   //     X
   //   Y      - outside before
   //    Y     - outside touching start
   //     Y    - overlap
   //      Y   - outside touching end
   //       Y  - outside after
 
   for (int i = 0; i < 5; i++) {
-    l1.Add(CharacterRange::Singleton(offset + 2), zone);
-    l2.Add(CharacterRange::Singleton(offset + i), zone);
+    l1.Add(CharacterRange::Singleton(offset + 2), &zone);
+    l2.Add(CharacterRange::Singleton(offset + i), &zone);
     offset += 6;
   }
 
   // The seven kinds of singleton/non-singleton intersections:
   //    XXX
   //  Y        - outside before
   //   Y       - outside touching start
   //    Y      - inside touching start
   //     Y     - entirely inside
   //      Y    - inside touching end
   //       Y   - outside touching end
   //        Y  - disjoint after
 
   for (int i = 0; i < 7; i++) {
-    l1.Add(CharacterRange::Range(offset + 2, offset + 4), zone);
-    l2.Add(CharacterRange::Singleton(offset + i), zone);
+    l1.Add(CharacterRange::Range(offset + 2, offset + 4), &zone);
+    l2.Add(CharacterRange::Singleton(offset + i), &zone);
     offset += 8;
   }
 
   // The eleven kinds of non-singleton intersections:
   //
   //       XXXXXXXX
   // YYYY                  - outside before.
   //   YYYY                - outside touching start.
   //     YYYY              - overlapping start
   //       YYYY            - inside touching start
   //         YYYY          - entirely inside
   //           YYYY        - inside touching end
   //             YYYY      - overlapping end
   //               YYYY    - outside touching end
   //                 YYYY  - outside after
   //       YYYYYYYY        - identical
   //     YYYYYYYYYYYY      - containing entirely.
 
   for (int i = 0; i < 9; i++) {
-    l1.Add(CharacterRange::Range(offset + 6, offset + 15), zone);  // Length 8.
-    l2.Add(CharacterRange::Range(offset + 2 * i, offset + 2 * i + 3), zone);
+    l1.Add(CharacterRange::Range(offset + 6, offset + 15), &zone);  // Length 8.
+    l2.Add(CharacterRange::Range(offset + 2 * i, offset + 2 * i + 3), &zone);
     offset += 22;
   }
-  l1.Add(CharacterRange::Range(offset + 6, offset + 15), zone);
-  l2.Add(CharacterRange::Range(offset + 6, offset + 15), zone);
+  l1.Add(CharacterRange::Range(offset + 6, offset + 15), &zone);
+  l2.Add(CharacterRange::Range(offset + 6, offset + 15), &zone);
   offset += 22;
-  l1.Add(CharacterRange::Range(offset + 6, offset + 15), zone);
-  l2.Add(CharacterRange::Range(offset + 4, offset + 17), zone);
+  l1.Add(CharacterRange::Range(offset + 6, offset + 15), &zone);
+  l2.Add(CharacterRange::Range(offset + 4, offset + 17), &zone);
   offset += 22;
 
   // Different kinds of multi-range overlap:
   // XXXXXXXXXXXXXXXXXXXXXX         XXXXXXXXXXXXXXXXXXXXXX
   //   YYYY  Y  YYYY  Y  YYYY  Y  YYYY  Y  YYYY  Y  YYYY  Y
 
-  l1.Add(CharacterRange::Range(offset, offset + 21), zone);
-  l1.Add(CharacterRange::Range(offset + 31, offset + 52), zone);
+  l1.Add(CharacterRange::Range(offset, offset + 21), &zone);
+  l1.Add(CharacterRange::Range(offset + 31, offset + 52), &zone);
   for (int i = 0; i < 6; i++) {
-    l2.Add(CharacterRange::Range(offset + 2, offset + 5), zone);
-    l2.Add(CharacterRange::Singleton(offset + 8), zone);
+    l2.Add(CharacterRange::Range(offset + 2, offset + 5), &zone);
+    l2.Add(CharacterRange::Singleton(offset + 8), &zone);
     offset += 9;
   }
 
   ASSERT(CharacterRange::IsCanonical(&l1));
   ASSERT(CharacterRange::IsCanonical(&l2));
 
-  ZoneList<CharacterRange> first_only(4, Isolate::Current()->runtime_zone());
-  ZoneList<CharacterRange> second_only(4, Isolate::Current()->runtime_zone());
-  ZoneList<CharacterRange> both(4, Isolate::Current()->runtime_zone());
+  ZoneList<CharacterRange> first_only(4, &zone);
+  ZoneList<CharacterRange> second_only(4, &zone);
+  ZoneList<CharacterRange> both(4, &zone);
 }
 
 
 TEST(Graph) {
   V8::Initialize(NULL);
   Execute("\\b\\w+\\b", false, true, true);
 }