Oilpan: assert that new Persistents belong to Oilpan threads.

Source/platform/heap/Handle.h

 /*
  * Copyright (C) 2014 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 145 matching lines @@
 };
 
 // Base class for persistent handles. RootsAccessor specifies which list to
 // link resulting handle into. Owner specifies the class containing trace
 // method.
 template<typename RootsAccessor, typename Owner>
 class PersistentBase : public PersistentNode {
 public:
     ~PersistentBase()
     {
+        ASSERT(ThreadState::current());

[sof, 2015/04/16 11:08:46]

The assert in the dtor cannot be used, as the ThreadState may have been
detached&finalized by then.

The asserts during construction, along with the 'same roots' assert below
catches what we want to during destruction in any case.

         typename RootsAccessor::Lock lock;
         ASSERT(m_roots == RootsAccessor::roots()); // Check that the thread is using the same roots list.
         ASSERT(isHeapObjectAlive());
         ASSERT(m_next->isHeapObjectAlive());
         ASSERT(m_prev->isHeapObjectAlive());
         m_next->m_prev = m_prev;
         m_prev->m_next = m_next;
     }
 
 protected:
     inline PersistentBase()
         : PersistentNode(TraceMethodDelegate<Owner, &Owner::trace>::trampoline)
 #if ENABLE(ASSERT)
         , m_roots(RootsAccessor::roots())
 #endif
     {
+        // Persistent must belong to a thread that will GC it.
+        ASSERT(m_roots == GlobalPersistents::roots() || ThreadState::current());
         typename RootsAccessor::Lock lock;
         m_prev = RootsAccessor::roots();
         m_next = m_prev->m_next;
         m_prev->m_next = this;
         m_next->m_prev = this;
     }
 
     inline explicit PersistentBase(const PersistentBase& otherref)
         : PersistentNode(otherref.m_trace)
 #if ENABLE(ASSERT)
         , m_roots(RootsAccessor::roots())
 #endif
     {
+        ASSERT(m_roots == GlobalPersistents::roots() || ThreadState::current());
         // We don't support allocation of thread local Persistents while doing
         // thread shutdown/cleanup.
         ASSERT(!ThreadState::current()->isTerminating());
         typename RootsAccessor::Lock lock;
         ASSERT(otherref.m_roots == m_roots); // Handles must belong to the same list.
         PersistentBase* other = const_cast<PersistentBase*>(&otherref);
         m_prev = other;
         m_next = other->m_next;
         other->m_next = this;
         m_next->m_prev = this;
@@ skipping 907 matching lines @@
 template<typename T>
 struct ParamStorageTraits<RawPtr<T>> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
 };
 
 template<typename T>
 PassRefPtr<T> adoptRef(blink::RefCountedGarbageCollected<T>*) = delete;
 
 } // namespace WTF
 
 #endif