Oilpan: Clarify ownership of split-off heaps.

Source/platform/heap/ThreadState.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 1129 matching lines @@
     for (int i = 0; i < NumberOfFinalizedHeaps; i++)
         finalizedPages += m_heaps[FirstFinalizedHeap + i]->normalPageCount();
 
     int pagesToSweepInParallel = nonFinalizedPages < finalizedPages ? nonFinalizedPages : ((nonFinalizedPages + finalizedPages) / 2);
 
     // Start the sweeper thread for the non finalized heaps. No
     // finalizers need to run and therefore the pages can be
     // swept on other threads.
     static const int minNumberOfPagesForParallelSweep = 10;
     HeapStats heapStatsVector[NumberOfNonFinalizedHeaps];
-    BaseHeap* splitOffHeaps[NumberOfNonFinalizedHeaps] = { 0 };
+    OwnPtr<BaseHeap> splitOffHeaps[NumberOfNonFinalizedHeaps];
     for (int i = 0; i < NumberOfNonFinalizedHeaps && pagesToSweepInParallel > 0; i++) {
         BaseHeap* heap = m_heaps[FirstNonFinalizedHeap + i];
         int pageCount = heap->normalPageCount();
         // Only use the sweeper thread if it exists and there are
         // pages to sweep.
         if (m_sweeperThread && pageCount > minNumberOfPagesForParallelSweep) {
             // Create a new thread heap instance to make sure that the
             // state modified while sweeping is separate for the
             // sweeper thread and the owner thread.
             int pagesToSplitOff = std::min(pageCount, pagesToSweepInParallel);
             pagesToSweepInParallel -= pagesToSplitOff;
-            BaseHeap* splitOff = heap->split(pagesToSplitOff);
-            splitOffHeaps[i] = splitOff;
+            splitOffHeaps[i] = heap->split(pagesToSplitOff);
             HeapStats* stats = &heapStatsVector[i];
-            m_sweeperThread->postTask(new SweepNonFinalizedHeapTask(this, splitOff, stats));
+            m_sweeperThread->postTask(new SweepNonFinalizedHeapTask(this, splitOffHeaps[i].get(), stats));
         }
     }
 
     {
         // Sweep the remainder of the non-finalized pages (or all of them
         // if there is no sweeper thread).
         TRACE_EVENT0("blink_gc", "ThreadState::sweepNonFinalizedHeaps");
         for (int i = 0; i < NumberOfNonFinalizedHeaps; i++) {
             HeapStats stats;
             m_heaps[FirstNonFinalizedHeap + i]->sweep(&stats);
             m_stats.add(&stats);
         }
     }
 
     {
         // Sweep the finalized pages.
         TRACE_EVENT0("blink_gc", "ThreadState::sweepFinalizedHeaps");
         for (int i = 0; i < NumberOfFinalizedHeaps; i++) {
             HeapStats stats;
             m_heaps[FirstFinalizedHeap + i]->sweep(&stats);
             m_stats.add(&stats);
         }
     }
 
     // Wait for the sweeper threads and update the heap stats with the
     // stats for the heap portions swept by those threads.
     waitUntilSweepersDone();
     for (int i = 0; i < NumberOfNonFinalizedHeaps; i++) {
         m_stats.add(&heapStatsVector[i]);
-        if (BaseHeap* splitOff = splitOffHeaps[i])
-            m_heaps[FirstNonFinalizedHeap + i]->merge(splitOff);
+        if (splitOffHeaps[i])
+            m_heaps[FirstNonFinalizedHeap + i]->merge(splitOffHeaps[i].release());
     }
 
     for (int i = 0; i < NumberOfHeaps; i++)
         m_heaps[i]->postSweepProcessing();
 
     getStats(m_statsAfterLastGC);
 }
 
 void ThreadState::addInterruptor(Interruptor* interruptor)
 {
@@ skipping 66 matching lines @@
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
 
 }