Oilpan: Clarify ownership of split-off heaps.

Source/platform/heap/Heap.h

 /*
  * 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 704 matching lines @@
 #if ENABLE(ASSERT)
     virtual bool isConsistentForSweeping() = 0;
 
     virtual void getScannedStats(HeapStats&) = 0;
 #endif
 
     virtual void prepareHeapForTermination() = 0;
 
     virtual int normalPageCount() = 0;
 
-    virtual BaseHeap* split(int normalPages) = 0;
-    virtual void merge(BaseHeap* other) = 0;
+    virtual PassOwnPtr<BaseHeap> split(int normalPages) = 0;
+    virtual void merge(PassOwnPtr<BaseHeap> other) = 0;
 
     // Returns a bucket number for inserting a FreeListEntry of a
     // given size. All FreeListEntries in the given bucket, n, have
     // size >= 2^n.
     static int bucketIndexForSize(size_t);
 };
 
 // Thread heaps represent a part of the per-thread Blink heap.
 //
 // Each Blink thread has a number of thread heaps: one general heap
@@ skipping 40 matching lines @@
     void addToFreeList(Address, size_t);
     inline static size_t roundedAllocationSize(size_t size)
     {
         return allocationSizeFromSize(size) - sizeof(Header);
     }
 
     virtual void prepareHeapForTermination();
 
     virtual int normalPageCount() { return m_numberOfNormalPages; }
 
-    virtual BaseHeap* split(int numberOfNormalPages);
-    virtual void merge(BaseHeap* splitOffBase);
+    virtual PassOwnPtr<BaseHeap> split(int numberOfNormalPages) override;
+    virtual void merge(PassOwnPtr<BaseHeap> splitOffBase) override;
 
     void removePageFromHeap(HeapPage<Header>*);
 
     PLATFORM_EXPORT void promptlyFreeObject(Header*);
 
 private:
     void addPageToHeap(const GCInfo*);
     PLATFORM_EXPORT Address outOfLineAllocate(size_t, const GCInfo*);
     static size_t allocationSizeFromSize(size_t);
     PLATFORM_EXPORT Address allocateLargeObject(size_t, const GCInfo*);
@@ skipping 1598 matching lines @@
 };
 
 template<typename T>
 struct IfWeakMember<WeakMember<T> > {
     static bool isDead(Visitor* visitor, const WeakMember<T>& t) { return !visitor->isAlive(t.get()); }
 };
 
 }
 
 #endif // Heap_h