Get rid of ZoneScope completely.

test/cctest/test-strings.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 115 matching lines @@
 
  private:
   const char* data_;
   size_t length_;
 };
 
 
 static void InitializeBuildingBlocks(Handle<String>* building_blocks,
                                      int bb_length,
                                      bool long_blocks,
-                                     RandomNumberGenerator* rng) {
+                                     RandomNumberGenerator* rng,
+                                     Zone* zone) {
   // A list of pointers that we don't have any interest in cleaning up.
   // If they are reachable from a root then leak detection won't complain.
   Isolate* isolate = Isolate::Current();
   Factory* factory = isolate->factory();
-  Zone* zone = isolate->runtime_zone();
   for (int i = 0; i < bb_length; i++) {
     int len = rng->next(16);
     int slice_head_chars = 0;
     int slice_tail_chars = 0;
     int slice_depth = 0;
     for (int j = 0; j < 3; j++) {
       if (rng->next(0.35)) slice_depth++;
     }
     // Must truncate something for a slice string. Loop until
     // at least one end will be sliced.
@@ skipping 104 matching lines @@
   CHECK(this->empty_leaves_ == that.empty_leaves_);
   CHECK(this->chars_ == that.chars_);
   CHECK(this->left_traversals_ == that.left_traversals_);
   CHECK(this->right_traversals_ == that.right_traversals_);
 }
 
 
 class ConsStringGenerationData {
  public:
   static const int kNumberOfBuildingBlocks = 256;
-  explicit ConsStringGenerationData(bool long_blocks);
+  ConsStringGenerationData(bool long_blocks, Zone* zone);
   void Reset();
   inline Handle<String> block(int offset);
   inline Handle<String> block(uint32_t offset);
   // Input variables.
   double early_termination_threshold_;
   double leftness_;
   double rightness_;
   double empty_leaf_threshold_;
   unsigned max_leaves_;
   // Cached data.
   Handle<String> building_blocks_[kNumberOfBuildingBlocks];
   String* empty_string_;
   RandomNumberGenerator rng_;
   // Stats.
   ConsStringStats stats_;
   unsigned early_terminations_;
  private:
   DISALLOW_COPY_AND_ASSIGN(ConsStringGenerationData);
 };
 
 
-ConsStringGenerationData::ConsStringGenerationData(bool long_blocks) {
+ConsStringGenerationData::ConsStringGenerationData(bool long_blocks,
+                                                   Zone* zone) {
   rng_.init();
   InitializeBuildingBlocks(
-      building_blocks_, kNumberOfBuildingBlocks, long_blocks, &rng_);
+      building_blocks_, kNumberOfBuildingBlocks, long_blocks, &rng_, zone);
   empty_string_ = Isolate::Current()->heap()->empty_string();
   Reset();
 }
 
 
 Handle<String> ConsStringGenerationData::block(uint32_t offset) {
   return building_blocks_[offset % kNumberOfBuildingBlocks ];
 }
 
 
@@ skipping 261 matching lines @@
   }
   s1->Get(s1->length() - 1);
   s2->Get(s2->length() - 1);
 }
 
 
 TEST(Traverse) {
   printf("TestTraverse\n");
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
-  ZoneScope zone(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT);
-  ConsStringGenerationData data(false);
+  Zone zone(Isolate::Current());
+  ConsStringGenerationData data(false, &zone);
   Handle<String> flat = ConstructBalanced(&data);
   FlattenString(flat);
   Handle<String> left_asymmetric = ConstructLeft(&data, DEEP_DEPTH);
   Handle<String> right_asymmetric = ConstructRight(&data, DEEP_DEPTH);
   Handle<String> symmetric = ConstructBalanced(&data);
   printf("1\n");
   Traverse(flat, symmetric);
   printf("2\n");
   Traverse(flat, left_asymmetric);
   printf("3\n");
@@ skipping 68 matching lines @@
     "early_terminations", data.early_terminations_);
 #endif
 }
 
 
 template<typename BuildString>
 void TestStringCharacterStream(BuildString build, int test_cases) {
   CcTest::InitializeVM();
   Isolate* isolate = Isolate::Current();
   HandleScope outer_scope(isolate);
-  ZoneScope zone(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT);
-  ConsStringGenerationData data(true);
+  Zone zone(isolate);
+  ConsStringGenerationData data(true, &zone);
   for (int i = 0; i < test_cases; i++) {
     printf("%d\n", i);
     HandleScope inner_scope(isolate);
     AlwaysAllocateScope always_allocate;
     // Build flat version of cons string.
     Handle<String> flat_string = build(i, &data);
     ConsStringStats flat_string_stats;
     AccumulateStats(flat_string, &flat_string_stats);
     // Flatten string.
     FlattenString(flat_string);
@@ skipping 247 matching lines @@
     for (int j = 0; j < lengths[i]; j++)
       CHECK_EQ(as_utf8[j], static_cast<unsigned char>(buffer[j]));
     // Check that the rest of the buffer hasn't been touched
     for (int j = lengths[i]; j < 11; j++)
       CHECK_EQ(kNoChar, buffer[j]);
   }
 }
 
 
 TEST(ExternalShortStringAdd) {
-  ZoneScope zonescope(Isolate::Current()->runtime_zone(), DELETE_ON_EXIT);
+  Isolate* isolate = Isolate::Current();
+  Zone zone(isolate);
 
   CcTest::InitializeVM();
   v8::HandleScope handle_scope(CcTest::isolate());
-  Zone* zone = Isolate::Current()->runtime_zone();
 
   // Make sure we cover all always-flat lengths and at least one above.
   static const int kMaxLength = 20;
   CHECK_GT(kMaxLength, i::ConsString::kMinLength);
 
   // Allocate two JavaScript arrays for holding short strings.
   v8::Handle<v8::Array> ascii_external_strings =
       v8::Array::New(kMaxLength + 1);
   v8::Handle<v8::Array> non_ascii_external_strings =
       v8::Array::New(kMaxLength + 1);
 
   // Generate short ascii and non-ascii external strings.
   for (int i = 0; i <= kMaxLength; i++) {
-    char* ascii = zone->NewArray<char>(i + 1);
+    char* ascii = zone.NewArray<char>(i + 1);
     for (int j = 0; j < i; j++) {
       ascii[j] = 'a';
     }
     // Terminating '\0' is left out on purpose. It is not required for external
     // string data.
     AsciiResource* ascii_resource =
-        new(zone) AsciiResource(Vector<const char>(ascii, i));
+        new(&zone) AsciiResource(Vector<const char>(ascii, i));
     v8::Local<v8::String> ascii_external_string =
         v8::String::NewExternal(ascii_resource);
 
     ascii_external_strings->Set(v8::Integer::New(i), ascii_external_string);
-    uc16* non_ascii = zone->NewArray<uc16>(i + 1);
+    uc16* non_ascii = zone.NewArray<uc16>(i + 1);
     for (int j = 0; j < i; j++) {
       non_ascii[j] = 0x1234;
     }
     // Terminating '\0' is left out on purpose. It is not required for external
     // string data.
-    Resource* resource = new(zone) Resource(Vector<const uc16>(non_ascii, i));
+    Resource* resource = new(&zone) Resource(Vector<const uc16>(non_ascii, i));
     v8::Local<v8::String> non_ascii_external_string =
       v8::String::NewExternal(resource);
     non_ascii_external_strings->Set(v8::Integer::New(i),
                                     non_ascii_external_string);
   }
 
   // Add the arrays with the short external strings in the global object.
   v8::Handle<v8::Object> global = CcTest::env()->Global();
   global->Set(v8_str("external_ascii"), ascii_external_strings);
   global->Set(v8_str("external_non_ascii"), non_ascii_external_strings);
@@ skipping 35 matching lines @@
     "test()";
   CHECK_EQ(0, CompileRun(source)->Int32Value());
 }
 
 
 TEST(CachedHashOverflow) {
   // We incorrectly allowed strings to be tagged as array indices even if their
   // values didn't fit in the hash field.
   // See http://code.google.com/p/v8/issues/detail?id=728
   Isolate* isolate = Isolate::Current();
-  ZoneScope zone(isolate->runtime_zone(), DELETE_ON_EXIT);
+  Zone zone(isolate);
 
   CcTest::InitializeVM();
   v8::HandleScope handle_scope(CcTest::isolate());
   // Lines must be executed sequentially. Combining them into one script
   // makes the bug go away.
   const char* lines[] = {
       "var x = [];",
       "x[4] = 42;",
       "var s = \"1073741828\";",
       "x[s];",
@@ skipping 313 matching lines @@
       CheckCanonicalEquivalence(c, test);
       continue;
     }
     if (upper != c && lower != c) {
       CheckCanonicalEquivalence(c, test);
       continue;
     }
     CHECK_EQ(Min(upper, lower), test);
   }
 }