Revert of Oilpan: Decommit backing storage of CallbackStacks

third_party/WebKit/Source/platform/heap/CallbackStack.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/heap/CallbackStack.h"
-#include "wtf/PageAllocator.h"
 
 namespace blink {
 
-CallbackStack::Block::Block(Block* next)
+void CallbackStack::Block::clear()
 {
-    static_assert((blockSize * sizeof(Item)) % WTF::kPageAllocationGranularity == 0, "CallbackStack::blockSize * sizeof(Item) must be a multiple of WTF::kPageAllocationGranularity");
-    m_buffer = static_cast<Item*>(WTF::allocPages(nullptr, blockSize * sizeof(Item), WTF::kPageAllocationGranularity, WTF::PageAccessible));
-    RELEASE_ASSERT(m_buffer);
-
-#if ENABLE(ASSERT)
-    for (size_t i = 0; i < blockSize; i++)
-        m_buffer[i] = Item(0, 0);
-#endif
-
-    m_limit = &(m_buffer[blockSize]);
-    m_current = &(m_buffer[0]);
-    m_next = next;
-}
-
-CallbackStack::Block::~Block()
-{
-    WTF::freePages(m_buffer, blockSize * sizeof(Item));
-    m_buffer = nullptr;
-    m_limit = nullptr;
-    m_current = nullptr;
-    m_next = nullptr;
-}
-
-void CallbackStack::Block::decommit()
-{
-#if ENABLE(ASSERT)
-    for (size_t i = 0; i < blockSize; i++)
-        m_buffer[i] = Item(0, 0);
-#endif
-
-    WTF::discardSystemPages(m_buffer, blockSize * sizeof(Item));
-
     m_current = &m_buffer[0];
     m_next = nullptr;
+    clearUnused();
 }
 
 void CallbackStack::Block::invokeEphemeronCallbacks(Visitor* visitor)
 {
     // This loop can tolerate entries being added by the callbacks after
     // iteration starts.
     for (unsigned i = 0; m_buffer + i < m_current; i++) {
         Item& item = m_buffer[i];
         item.call(visitor);
     }
 }
 
 #if ENABLE(ASSERT)
 bool CallbackStack::Block::hasCallbackForObject(const void* object)
 {
     for (unsigned i = 0; m_buffer + i < m_current; i++) {
         Item* item = &m_buffer[i];
         if (item->object() == object)
             return true;
     }
     return false;
 }
 #endif
 
-CallbackStack::CallbackStack()
-    : m_first(new Block(0))
-    , m_last(m_first)
+void CallbackStack::Block::clearUnused()
+{
+#if ENABLE(ASSERT)
+    for (size_t i = 0; i < blockSize; i++)
+        m_buffer[i] = Item(0, 0);
+#endif
+}
+
+CallbackStack::CallbackStack() : m_first(new Block(0)), m_last(m_first)
 {
 }
 
 CallbackStack::~CallbackStack()
 {
-    RELEASE_ASSERT(isEmpty());
+    clear();
     delete m_first;
     m_first = nullptr;
     m_last = nullptr;
 }
 
-void CallbackStack::decommit()
+void CallbackStack::clear()
 {
     Block* next;
     for (Block* current = m_first->next(); current; current = next) {
         next = current->next();
         delete current;
     }
-    m_first->decommit();
+    m_first->clear();
     m_last = m_first;
 }
 
 bool CallbackStack::isEmpty() const
 {
     return hasJustOneBlock() && m_first->isEmptyBlock();
 }
 
 CallbackStack::Item* CallbackStack::allocateEntrySlow()
 {
     ASSERT(!m_first->allocateEntry());
     m_first = new Block(m_first);
     return m_first->allocateEntry();
 }
 
 CallbackStack::Item* CallbackStack::popSlow()
 {
     ASSERT(m_first->isEmptyBlock());
 
     for (;;) {
         Block* next = m_first->next();
         if (!next) {
 #if ENABLE(ASSERT)
-            m_first->decommit();
+            m_first->clear();
 #endif
             return nullptr;
         }
         delete m_first;
         m_first = next;
         if (Item* item = m_first->pop())
             return item;
     }
 }
 
@@ skipping 35 matching lines @@
 {
     for (Block* current = m_first; current; current = current->next()) {
         if (current->hasCallbackForObject(object))
             return true;
     }
     return false;
 }
 #endif
 
 } // namespace blink