Revert of Replaced different means of zone pooling/reusing by one zone segment pool

src/zone/zone.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_ZONE_ZONE_H_
 #define V8_ZONE_ZONE_H_
 
 #include <limits>
 
 #include "src/base/hashmap.h"
@@ skipping 26 matching lines @@
   // Allocate 'size' bytes of memory in the Zone; expands the Zone by
   // allocating new segments of memory on demand using malloc().
   void* New(size_t size);
 
   template <typename T>
   T* NewArray(size_t length) {
     DCHECK_LT(length, std::numeric_limits<size_t>::max() / sizeof(T));
     return static_cast<T*>(New(length * sizeof(T)));
   }
 
+  // Deletes all objects and free all memory allocated in the Zone.
+  void DeleteAll();
+
   // Returns true if more memory has been allocated in zones than
   // the limit allows.
   bool excess_allocation() const {
     return segment_bytes_allocated_ > kExcessLimit;
   }
 
   size_t allocation_size() const { return allocation_size_; }
 
   AccountingAllocator* allocator() const { return allocator_; }
 
@@ skipping 10 matching lines @@
 
   // Never allocate segments smaller than this size in bytes.
   static const size_t kMinimumSegmentSize = 8 * KB;
 
   // Never allocate segments larger than this size in bytes.
   static const size_t kMaximumSegmentSize = 1 * MB;
 
   // Report zone excess when allocation exceeds this limit.
   static const size_t kExcessLimit = 256 * MB;
 
-  // Deletes all objects and free all memory allocated in the Zone.
-  void DeleteAll();
-
   // The number of bytes allocated in this zone so far.
   size_t allocation_size_;
 
   // The number of bytes allocated in segments.  Note that this number
   // includes memory allocated from the OS but not yet allocated from
   // the zone.
   size_t segment_bytes_allocated_;
 
   // Expand the Zone to hold at least 'size' more bytes and allocate
   // the bytes. Returns the address of the newly allocated chunk of
@@ skipping 28 matching lines @@
   // (unused) destructors for classes derived from ZoneObject, which
   // require the operator to be visible. MSVC requires the delete
   // operator to be public.
 
   // ZoneObjects should never be deleted individually; use
   // Zone::DeleteAll() to delete all zone objects in one go.
   void operator delete(void*, size_t) { UNREACHABLE(); }
   void operator delete(void* pointer, Zone* zone) { UNREACHABLE(); }
 };
 
+// The ZoneScope is used to automatically call DeleteAll() on a
+// Zone when the ZoneScope is destroyed (i.e. goes out of scope)
+class ZoneScope final {
+ public:
+  explicit ZoneScope(Zone* zone) : zone_(zone) {}
+  ~ZoneScope() { zone_->DeleteAll(); }
+
+  Zone* zone() const { return zone_; }
+
+ private:
+  Zone* zone_;
+};
+
 // The ZoneAllocationPolicy is used to specialize generic data
 // structures to allocate themselves and their elements in the Zone.
 class ZoneAllocationPolicy final {
  public:
   explicit ZoneAllocationPolicy(Zone* zone) : zone_(zone) {}
   void* New(size_t size) { return zone()->New(size); }
   static void Delete(void* pointer) {}
   Zone* zone() const { return zone_; }
 
  private:
@@ skipping 75 matching lines @@
 
 typedef base::PointerTemplateHashMapImpl<ZoneAllocationPolicy> ZoneHashMap;
 
 typedef base::CustomMatcherTemplateHashMapImpl<ZoneAllocationPolicy>
     CustomMatcherZoneHashMap;
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_ZONE_ZONE_H_