revert thread isolate in PreallocatedStorageAllocationPolicy

This reverts 16467 for breaking windows build

TBR=svenpanne@chromium.org

BUG=

Review URL: https://codereview.chromium.org/23824005

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16468 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

diff --git a/src/allocation-inl.h b/src/allocation-inl.h
index d215b176b10359fd1fceedd7e656bccc94dafb28..d32db4b17fc18c314f3ce51adb087cfa2333c038 100644 (file)
--- a/src/allocation-inl.h
+++ b/src/allocation-inl.h
@@ -35,12 +35,12 @@ namespace internal {
 
 
 void* PreallocatedStorageAllocationPolicy::New(size_t size) {
-  return isolate_->PreallocatedStorageNew(size);
+  return Isolate::Current()->PreallocatedStorageNew(size);
 }
 
 
 void PreallocatedStorageAllocationPolicy::Delete(void* p) {
-  return isolate_->PreallocatedStorageDelete(p);
+  return Isolate::Current()->PreallocatedStorageDelete(p);
 }
 
 

diff --git a/src/allocation.h b/src/allocation.h
index b70087955cbdaad42da9feee1af97d5e472c9414..45bde4c4cb07068a05e301d2124990637d82609d 100644 (file)
--- a/src/allocation.h
+++ b/src/allocation.h
@@ -104,7 +104,6 @@ char* StrNDup(const char* str, int n);
 // and free. Used as the default policy for lists.
 class FreeStoreAllocationPolicy {
  public:
-  typedef FreeStoreAllocationPolicy Deleter;
   INLINE(void* New(size_t size)) { return Malloced::New(size); }
   INLINE(static void Delete(void* p)) { Malloced::Delete(p); }
 };
@@ -132,21 +131,9 @@ class PreallocatedStorage {
 };
 
 
-class Isolate;
-
-
-class PreallocatedStorageAllocationPolicy {
- public:
-  typedef PreallocatedStorageAllocationPolicy Deleter;
-  INLINE(explicit PreallocatedStorageAllocationPolicy(Isolate* isolate))
-    : isolate_(isolate) { }
-  INLINE(PreallocatedStorageAllocationPolicy(
-      const PreallocatedStorageAllocationPolicy& policy))
-    : isolate_(policy.isolate_) { }
+struct PreallocatedStorageAllocationPolicy {
   INLINE(void* New(size_t size));
-  INLINE(void Delete(void* ptr));
- private:
-  Isolate* isolate_;
+  INLINE(static void Delete(void* ptr));
 };
 
 

diff --git a/src/isolate.cc b/src/isolate.cc
index 69199305ca11a7c269993b3dae0133252ebf56ab..0e7b6d55d1521965efb3c4b7a04974e66c19d3cd 100644 (file)
--- a/src/isolate.cc
+++ b/src/isolate.cc
@@ -2059,7 +2059,7 @@ Isolate::~Isolate() {
   delete eternal_handles_;
   eternal_handles_ = NULL;
 
-  DebugObjectCache::Delete(string_stream_debug_object_cache_);
+  delete string_stream_debug_object_cache_;
   string_stream_debug_object_cache_ = NULL;
 
   delete external_reference_table_;

diff --git a/src/list.h b/src/list.h
index d64256887b1d2822e9e571cc31ded21f87fa7d47..0e4e35bb41b78b3ff5aa8b106ea284d1e4ded91c 100644 (file)
--- a/src/list.h
+++ b/src/list.h
@@ -48,15 +48,13 @@ namespace internal {
 // template <typename T,
 //           class AllocationPolicy = FreeStoreAllocationPolicy> class List;
 template <typename T, class AllocationPolicy>
-class List : private AllocationPolicy::Deleter {
+class List {
  public:
-  explicit List(AllocationPolicy allocator = AllocationPolicy())
-    : AllocationPolicy::Deleter(allocator) {
+  explicit List(AllocationPolicy allocator = AllocationPolicy()) {
     Initialize(0, allocator);
   }
   INLINE(explicit List(int capacity,
-                       AllocationPolicy allocator = AllocationPolicy()))
-    : AllocationPolicy::Deleter(allocator) {
+                       AllocationPolicy allocator = AllocationPolicy())) {
     Initialize(capacity, allocator);
   }
   INLINE(~List()) { DeleteData(data_); }
@@ -73,7 +71,7 @@ class List : private AllocationPolicy::Deleter {
     return allocator.New(static_cast<int>(size));
   }
   INLINE(void operator delete(void* p)) {
-    AllocationPolicy::Deleter::Delete(p);
+    AllocationPolicy::Delete(p);
   }
 
   // Please the MSVC compiler.  We should never have to execute this.
@@ -81,13 +79,6 @@ class List : private AllocationPolicy::Deleter {
     UNREACHABLE();
   }
 
-  // Delete via the instance Deleter
-  static void Delete(List* p) {
-    if (p == NULL) return;
-    p->~List();
-    p->AllocationPolicy::Deleter::Delete(p);
-  }
-
   // Returns a reference to the element at index i.  This reference is
   // not safe to use after operations that can change the list's
   // backing store (e.g. Add).
@@ -188,7 +179,7 @@ class List : private AllocationPolicy::Deleter {
     return static_cast<T*>(allocator.New(n * sizeof(T)));
   }
   INLINE(void DeleteData(T* data))  {
-    this->AllocationPolicy::Deleter::Delete(data);
+    AllocationPolicy::Delete(data);
   }
 
   // Increase the capacity of a full list, and add an element.

diff --git a/src/string-stream.cc b/src/string-stream.cc
index 8ab1244364310e4b997cae276975a358bd9598f2..9c4394ed7f01d1e3e3f1b405a616e1701664433a 100644 (file)
--- a/src/string-stream.cc
+++ b/src/string-stream.cc
@@ -204,9 +204,7 @@ void StringStream::PrintObject(Object* o) {
     }
     if (debug_object_cache->length() < kMentionedObjectCacheMaxSize) {
       Add("#%d#", debug_object_cache->length());
-      HeapObject* ho = HeapObject::cast(o);
-      PreallocatedStorageAllocationPolicy policy(ho->GetIsolate());
-      debug_object_cache->Add(ho, policy);
+      debug_object_cache->Add(HeapObject::cast(o));
     } else {
       Add("@%p", o);
     }
@@ -301,9 +299,8 @@ void StringStream::ClearMentionedObjectCache() {
   Isolate* isolate = Isolate::Current();
   isolate->set_string_stream_current_security_token(NULL);
   if (isolate->string_stream_debug_object_cache() == NULL) {
-    PreallocatedStorageAllocationPolicy policy(isolate);
     isolate->set_string_stream_debug_object_cache(
-        new(policy) DebugObjectCache(policy));
+        new List<HeapObject*, PreallocatedStorageAllocationPolicy>(0));
   }
   isolate->string_stream_debug_object_cache()->Clear();
 }

diff --git a/src/zone.h b/src/zone.h
index 34fb7387eacce42d5e01a5ac7b470e33f8199ca1..bd7cc39b0c4f224b0646792fbd8ed262fdc5f986 100644 (file)
--- a/src/zone.h
+++ b/src/zone.h
@@ -174,11 +174,6 @@ struct ZoneScope {
 // structures to allocate themselves and their elements in the Zone.
 struct ZoneAllocationPolicy {
  public:
-  class Deleter {
-   public:
-    INLINE(explicit Deleter(const ZoneAllocationPolicy&)) {}
-    INLINE(static void Delete(void *pointer)) { }
-  };
   explicit ZoneAllocationPolicy(Zone* zone) : zone_(zone) { }
   INLINE(void* New(size_t size));
   INLINE(static void Delete(void *pointer)) { }

diff --git a/test/cctest/test-list.cc b/test/cctest/test-list.cc
index ca15bf99b6bb42efbcd9d351958176e580bb1e29..a29972b583bb7754cb33b8bcba9580c3620958b7 100644 (file)
--- a/test/cctest/test-list.cc
+++ b/test/cctest/test-list.cc
@@ -35,8 +35,6 @@ using namespace v8::internal;
 // Use a testing allocator that clears memory before deletion.
 class ZeroingAllocationPolicy {
  public:
-  typedef ZeroingAllocationPolicy Deleter;
-
   void* New(size_t size) {
     // Stash the size in the first word to use for Delete.
     size_t true_size = size + sizeof(size_t);