Oilpan: Clarify ownership of split-off heaps.

Source/platform/heap/Heap.cpp

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 2672 matching lines @@
 {
     for (HeapPage<Header>* page = m_firstPage; page; page = page->next()) {
         page->setTerminating();
     }
     for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current; current = current->next()) {
         current->setTerminating();
     }
 }
 
 template<typename Header>
-BaseHeap* ThreadHeap<Header>::split(int numberOfNormalPages)
+PassOwnPtr<BaseHeap> ThreadHeap<Header>::split(int numberOfNormalPages)
 {
     // Create a new split off thread heap containing
     // |numberOfNormalPages| of the pages of this ThreadHeap for
     // parallel sweeping. The split off thread heap will be merged
     // with this heap at the end of sweeping and the temporary
     // ThreadHeap object will be deallocated after the merge.
     ASSERT(numberOfNormalPages > 0);
-    ThreadHeap<Header>* splitOff = new ThreadHeap(m_threadState, m_index);
+    OwnPtr<ThreadHeap<Header>> splitOff = adoptPtr(new ThreadHeap(m_threadState, m_index));
     HeapPage<Header>* splitPoint = m_firstPage;
     for (int i = 1; i < numberOfNormalPages; i++)
         splitPoint = splitPoint->next();
     splitOff->m_firstPage = m_firstPage;
     m_firstPage = splitPoint->m_next;
     splitOff->m_mergePoint = splitPoint;
     splitOff->m_numberOfNormalPages = numberOfNormalPages;
     m_numberOfNormalPages -= numberOfNormalPages;
     splitPoint->m_next = 0;
-    return splitOff;
+    return splitOff.release();
 }
 
 template<typename Header>
-void ThreadHeap<Header>::merge(BaseHeap* splitOffBase)
+void ThreadHeap<Header>::merge(PassOwnPtr<BaseHeap> splitOffBase)
 {
-    ThreadHeap<Header>* splitOff = static_cast<ThreadHeap<Header>*>(splitOffBase);
+    ThreadHeap<Header>* splitOff = static_cast<ThreadHeap<Header>*>(splitOffBase.get());
     // If the mergePoint is zero all split off pages became empty in
     // this round and we don't have to merge. There are no pages and
     // nothing on the freelists.
     ASSERT(splitOff->m_mergePoint || splitOff->m_numberOfNormalPages == 0);
     if (splitOff->m_mergePoint) {
         // Link the split off pages into the beginning of the list again.
         splitOff->m_mergePoint->m_next = m_firstPage;
         m_firstPage = splitOff->m_firstPage;
         m_numberOfNormalPages += splitOff->m_numberOfNormalPages;
         splitOff->m_firstPage = 0;
         // Merge free lists.
         for (size_t i = 0; i < blinkPageSizeLog2; i++) {
             if (!m_freeLists[i]) {
                 m_freeLists[i] = splitOff->m_freeLists[i];
             } else if (splitOff->m_freeLists[i]) {
                 m_lastFreeListEntries[i]->append(splitOff->m_freeLists[i]);
                 m_lastFreeListEntries[i] = splitOff->m_lastFreeListEntries[i];
             }
         }
     }
-    delete splitOffBase;
 }
 
 void Heap::getHeapSpaceSize(uint64_t* objectSpaceSize, uint64_t* allocatedSpaceSize)
 {
     *objectSpaceSize = 0;
     *allocatedSpaceSize = 0;
     ASSERT(ThreadState::isAnyThreadInGC());
     ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
     typedef ThreadState::AttachedThreadStateSet::iterator ThreadStateIterator;
     for (ThreadStateIterator it = threads.begin(), end = threads.end(); it != end; ++it) {
@@ skipping 166 matching lines @@
 CallbackStack* Heap::s_weakCallbackStack;
 CallbackStack* Heap::s_ephemeronStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = 0;
 
 }