Use OwnPtrs for heap contains cache and persistent anchor. We were leaking the HeapContainsCache.

Source/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 211 matching lines @@
 
     volatile int m_canResume;
     volatile int m_unparkedThreadCount;
     Mutex m_mutex;
     ThreadCondition m_parked;
     ThreadCondition m_resume;
 };
 
 ThreadState::ThreadState()
     : m_thread(currentThread())
+    , m_persistents(adoptPtr(new PersistentAnchor()))
     , m_startOfStack(reinterpret_cast<intptr_t*>(getStackStart()))
     , m_endOfStack(reinterpret_cast<intptr_t*>(getStackStart()))
     , m_safePointScopeMarker(0)
     , m_atSafePoint(false)
     , m_interruptors()
     , m_gcRequested(false)
     , m_sweepRequested(0)
     , m_sweepInProgress(false)
     , m_noAllocationCount(0)
     , m_inGC(false)
-    , m_heapContainsCache(new HeapContainsCache())
+    , m_heapContainsCache(adoptPtr(new HeapContainsCache()))
     , m_isCleaningUp(false)
 {
     ASSERT(!**s_threadSpecific);
     **s_threadSpecific = this;
 
-    m_persistents = new PersistentAnchor();
     m_stats.clear();
     m_statsAfterLastGC.clear();
     // First allocate the general heap, second iterate through to
     // allocate the type specific heaps
     m_heaps[GeneralHeap] = new ThreadHeap<FinalizedHeapObjectHeader>(this);
     for (int i = GeneralHeap + 1; i < NumberOfHeaps; i++)
         m_heaps[i] = new ThreadHeap<HeapObjectHeader>(this);
 }
 
 ThreadState::~ThreadState()
 {
     checkThread();
     for (int i = GeneralHeap; i < NumberOfHeaps; i++)
         delete m_heaps[i];
-    delete m_persistents;
-    m_persistents = 0;
     deleteAllValues(m_interruptors);
     **s_threadSpecific = 0;
 }
 
 void ThreadState::init()
 {
     s_threadSpecific = new WTF::ThreadSpecific<ThreadState*>();
     s_safePointBarrier = new SafePointBarrier;
     new(s_mainThreadStateStorage) ThreadState();
     attachedThreads().add(mainThreadState());
@@ skipping 427 matching lines @@
     state->safePoint(HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
 }