Remove TLS access for current Zone.

test/cctest/test-strings.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 
 // Check that we can traverse very deep stacks of ConsStrings using
 // StringInputBuffer.  Check that Get(int) works on very deep stacks
 // of ConsStrings.  These operations may not be very fast, but they
 // should be possible without getting errors due to too deep recursion.
 
 #include <stdlib.h>
 
 #include "v8.h"
@@ skipping 64 matching lines @@
  private:
   const char* data_;
   size_t length_;
 };
 
 
 static void InitializeBuildingBlocks(
     Handle<String> building_blocks[NUMBER_OF_BUILDING_BLOCKS]) {
   // 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.
+  Zone* zone = Isolate::Current()->zone();
   for (int i = 0; i < NUMBER_OF_BUILDING_BLOCKS; i++) {
     int len = gen() % 16;
     if (len > 14) {
       len += 1234;
     }
     switch (gen() % 4) {
       case 0: {
         uc16 buf[2000];
         for (int j = 0; j < len; j++) {
           buf[j] = gen() % 65536;
@@ skipping 11 matching lines @@
           buf[j] = gen() % 128;
         }
         building_blocks[i] =
             FACTORY->NewStringFromAscii(Vector<const char>(buf, len));
         for (int j = 0; j < len; j++) {
           CHECK_EQ(buf[j], building_blocks[i]->Get(j));
         }
         break;
       }
       case 2: {
-        uc16* buf = ZONE->NewArray<uc16>(len);
+        uc16* buf = zone->NewArray<uc16>(len);
         for (int j = 0; j < len; j++) {
           buf[j] = gen() % 65536;
         }
-        Resource* resource = new Resource(Vector<const uc16>(buf, len));
+        Resource* resource = new(zone) Resource(Vector<const uc16>(buf, len));
         building_blocks[i] = FACTORY->NewExternalStringFromTwoByte(resource);
         for (int j = 0; j < len; j++) {
           CHECK_EQ(buf[j], building_blocks[i]->Get(j));
         }
         break;
       }
       case 3: {
         char* buf = NewArray<char>(len);
         for (int j = 0; j < len; j++) {
           buf[j] = gen() % 128;
@@ skipping 210 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 zone(Isolate::Current(), DELETE_ON_EXIT);
+  ZoneScope zonescope(Isolate::Current(), DELETE_ON_EXIT);
 
   InitializeVM();
   v8::HandleScope handle_scope;
+  Zone* zone = Isolate::Current()->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 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 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 = env->Global();
   global->Set(v8_str("external_ascii"), ascii_external_strings);
   global->Set(v8_str("external_non_ascii"), non_ascii_external_strings);
@@ skipping 285 matching lines @@
   v8::V8::IgnoreOutOfMemoryException();
   v8::Local<v8::Value> result = CompileRun(
       "var a = 'a';                     "
       "for (var i = 0; i < 16; i++) {   "
       "  a += a;                        "
       "}                                "
       "a.replace(/a/g, a);              ");
   CHECK(result.IsEmpty());
   CHECK(context->HasOutOfMemoryException());
 }