Revert "Revert "[oilpan]: Make thread shutdown more robust.""

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 191 matching lines @@
         m_prev->m_next = this;
         m_next->m_prev = this;
     }
 
     inline explicit PersistentBase(const PersistentBase& otherref)
         : PersistentNode(otherref.m_trace)
 #ifndef NDEBUG
         , m_roots(RootsAccessor::roots())
 #endif
     {
+        // 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;
     }
 
     inline PersistentBase& operator=(const PersistentBase& otherref) { return *this; }
 
 #ifndef NDEBUG
 private:
     PersistentNode* m_roots;
 #endif
 };
 
 // A dummy Persistent handle that ensures the list of persistents is never null.
 // This removes a test from a hot path.
 class PersistentAnchor : public PersistentNode {
 public:
     void trace(Visitor* visitor)
     {
         for (PersistentNode* current = m_next; current != this; current = current->m_next)
             current->trace(visitor);
     }
 
+    int numberOfPersistents()
+    {
+        int numberOfPersistents = 0;
+        for (PersistentNode* current = m_next; current != this; current = current->m_next)
+            ++numberOfPersistents;
+        return numberOfPersistents;
+    }
+
     virtual ~PersistentAnchor()
     {
         // FIXME: oilpan: Ideally we should have no left-over persistents at this point. However currently there is a
         // large number of objects leaked when we tear down the main thread. Since some of these might contain a
         // persistent or e.g. be RefCountedGarbageCollected we cannot guarantee there are no remaining Persistents at
         // this point.
     }
 
 private:
     PersistentAnchor() : PersistentNode(TraceMethodDelegate<PersistentAnchor, &PersistentAnchor::trace>::trampoline)
@@ skipping 914 matching lines @@
 struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, WebCore::IsGarbageCollectedType<T>::value> {
 };
 
 template<typename T>
 struct ParamStorageTraits<RawPtr<T> > : public PointerParamStorageTraits<T*, WebCore::IsGarbageCollectedType<T>::value> {
 };
 
 } // namespace WTF
 
 #endif