Get rid of the ZoneScopeMode.

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(), DELETE_ON_EXIT);
+  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
   FlatStringReader reader(Isolate::Current(), CStrVector(input));
   RegExpCompileData result;
   return v8::internal::RegExpParser::ParseRegExp(
       &reader, false, &result, Isolate::Current()->runtime_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(), DELETE_ON_EXIT);
+  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
   FlatStringReader reader(Isolate::Current(), CStrVector(input));
   RegExpCompileData result;
   CHECK(v8::internal::RegExpParser::ParseRegExp(
       &reader, false, &result, Isolate::Current()->runtime_zone()));
   CHECK(result.tree != NULL);
   CHECK(result.error.is_null());
   SmartArrayPointer<const char> output =
       result.tree->ToString(Isolate::Current()->runtime_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(), DELETE_ON_EXIT);
+  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
   FlatStringReader reader(Isolate::Current(), CStrVector(input));
   RegExpCompileData result;
   CHECK(v8::internal::RegExpParser::ParseRegExp(
       &reader, false, &result, Isolate::Current()->runtime_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(), DELETE_ON_EXIT);
+  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
   FlatStringReader reader(Isolate::Current(), CStrVector(input));
   RegExpCompileData result;
   CHECK(v8::internal::RegExpParser::ParseRegExp(
       &reader, false, &result, Isolate::Current()->runtime_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;
@@ skipping 252 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(), DELETE_ON_EXIT);
+  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
   FlatStringReader reader(Isolate::Current(), CStrVector(input));
   RegExpCompileData result;
   CHECK(!v8::internal::RegExpParser::ParseRegExp(
       &reader, false, &result, Isolate::Current()->runtime_zone()));
   CHECK(result.tree == NULL);
   CHECK(!result.error.is_null());
   SmartArrayPointer<char> str = result.error->ToCString(ALLOW_NULLS);
   CHECK_EQ(expected, *str);
 }
 
@@ skipping 63 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(), DELETE_ON_EXIT);
+  ZoneScope scope(Isolate::Current()->runtime_zone());
   Zone* zone = Isolate::Current()->runtime_zone();
   ZoneList<CharacterRange>* ranges =
       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());
     }
@@ skipping 37 matching lines @@
                         isolate->runtime_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(), DELETE_ON_EXIT);
+  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
   RegExpNode* node = Compile(input, multiline, is_ascii);
   USE(node);
 #ifdef DEBUG
   if (dot_output) {
     RegExpEngine::DotPrint(input, node, false);
     exit(0);
   }
 #endif  // DEBUG
 }
 
@@ skipping 19 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(), DELETE_ON_EXIT);
+  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
   ZoneSplayTree<TestConfig> tree(Isolate::Current()->runtime_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;
@@ skipping 47 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(), DELETE_ON_EXIT);
+  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
   DispatchTable table(Isolate::Current()->runtime_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());
   }
   // Check that the table looks as we would expect
   for (int p = 0; p < kLimit; p++) {
     OutSet* outs = table.Get(p);
@@ skipping 49 matching lines @@
 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(), DELETE_ON_EXIT) {
+        zone_(Isolate::Current()->runtime_zone()) {
     env_->Enter();
   }
   ~ContextInitializer() {
     env_->Exit();
   }
  private:
   v8::HandleScope scope_;
   v8::Handle<v8::Context> env_;
   v8::internal::ZoneScope zone_;
 };
@@ skipping 698 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(), DELETE_ON_EXIT);
+    ZoneScope zone_scope(Isolate::Current()->runtime_zone());
     Zone* zone = Isolate::Current()->runtime_zone();
     ZoneList<CharacterRange>* ranges =
         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);
     }
     DispatchTable table(zone);
     DispatchTableConstructor cons(&table, false,
                                   Isolate::Current()->runtime_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(), DELETE_ON_EXIT);
+  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
   Zone* zone = Isolate::Current()->runtime_zone();
   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());
   cons.set_choice_index(0);
   cons.AddInverse(ranges);
   CHECK(!table.Get(0xFFFE)->Get(0));
@@ skipping 94 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(), DELETE_ON_EXIT);
+  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
   Zone* zone = Isolate::Current()->runtime_zone();
   int count = expected.length();
   ZoneList<CharacterRange>* list =
       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());
   }
@@ skipping 45 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(), DELETE_ON_EXIT);
+  ZoneScope zone_scope(Isolate::Current()->runtime_zone());
   Zone* zone = Isolate::Current()->runtime_zone();
   ZoneList<CharacterRange>* base =
       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());
   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(), DELETE_ON_EXIT);
+  ZoneScope scope(Isolate::Current()->runtime_zone());
   Zone* zone = Isolate::Current()->runtime_zone();
   ZoneList<CharacterRange>* list =
       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);
   set.Canonicalize();
   ASSERT_EQ(3, list->length());
@@ skipping 42 matching lines @@
   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(), DELETE_ON_EXIT);
+  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();
   // Create all combinations of intersections of ranges, both singletons and
   // longer.
 
   int offset = 0;
 
   // The five kinds of singleton intersections:
   //     X
@@ skipping 70 matching lines @@
   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());
 }
 
 
 TEST(Graph) {
   V8::Initialize(NULL);
   Execute("\\b\\w+\\b", false, true, true);
 }