Restrict registered PersistentNodes to non-empty ones.

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 119 matching lines @@
         if (weaknessConfiguration == WeakPersistentConfiguration) {
             visitor->registerWeakCell(&m_raw);
         } else {
             visitor->mark(m_raw);
         }
     }
 
     RawPtr<T> release()
     {
         RawPtr<T> result = m_raw;
-        m_raw = nullptr;
+        assign(nullptr);
         return result;
     }
 
-    void clear() { m_raw = nullptr; }
+    void clear() { assign(nullptr); }
     T& operator*() const { return *m_raw; }
     bool operator!() const { return !m_raw; }
     operator T*() const { return m_raw; }
     operator RawPtr<T>() const { return m_raw; }
     T* operator->() const { return *this; }
     T* get() const { return m_raw; }
 
     template<typename U>
     PersistentBase& operator=(U* other)
     {
-        m_raw = other;
-        checkPointer();
-        recordBacktrace();
+        assign(other);
         return *this;
     }
 
     PersistentBase& operator=(std::nullptr_t)
     {
-        m_raw = nullptr;
+        assign(nullptr);
         return *this;
     }
 
     PersistentBase& operator=(const PersistentBase& other)
     {
-        m_raw = other;
-        checkPointer();
-        recordBacktrace();
+        assign(other);
         return *this;
     }
 
     template<typename U>
     PersistentBase& operator=(const PersistentBase<U, weaknessConfiguration, crossThreadnessConfiguration>& other)
     {
-        m_raw = other;
-        checkPointer();
-        recordBacktrace();
+        assign(other);
         return *this;
     }
 
     template<typename U>
     PersistentBase& operator=(const Member<U>& other)
     {
-        m_raw = other;
-        checkPointer();
-        recordBacktrace();
+        assign(other);
         return *this;
     }
 
     template<typename U>
     PersistentBase& operator=(const RawPtr<U>& other)
     {
-        m_raw = other;
-        checkPointer();
-        recordBacktrace();
+        assign(other);
         return *this;
     }
 
 
 private:
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
+    void assign(T* ptr)
+    {
+        m_raw = ptr;
+        checkPointer();
+        recordBacktrace();
+        if (m_raw) {
+            if (!m_persistentNode)
+                initialize();
+            return;
+        }
+        if (m_persistentNode && crossThreadnessConfiguration != CrossThreadPersistentConfiguration)
+            uninitialize();
+    }
+
+    NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void initialize()
     {
+        ASSERT(!m_persistentNode);
+        if (!m_raw)
+            return;
+
         TraceCallback traceCallback = TraceMethodDelegate<PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>, &PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>::trace>::trampoline;
         if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
             m_persistentNode = ThreadState::crossThreadPersistentRegion().allocatePersistentNode(this, traceCallback);
         } else {
             ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
             ASSERT(state->checkThread());
             m_persistentNode = state->persistentRegion()->allocatePersistentNode(this, traceCallback);
 #if ENABLE(ASSERT)
             m_state = state;
 #endif
         }
     }
 
     void uninitialize()
     {
+        if (!m_persistentNode)
+            return;
+
         if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
             ThreadState::crossThreadPersistentRegion().freePersistentNode(m_persistentNode);
         } else {
             ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
             ASSERT(state->checkThread());
             // Persistent handle must be created and destructed in the same thread.
             ASSERT(m_state == state);
             state->persistentRegion()->freePersistentNode(m_persistentNode);
         }
+        m_persistentNode = nullptr;
     }
 
     void checkPointer()
     {
 #if ENABLE(ASSERT)
         if (!m_raw)
             return;
 
         // Heap::isHeapObjectAlive(m_raw) checks that m_raw is a traceable
         // object. In other words, it checks that the pointer is either of:
@@ skipping 13 matching lines @@
         if (m_raw)
             m_tracingName = Heap::createBacktraceString();
     }
 
     String m_tracingName;
 #else
     inline void recordBacktrace() const { }
 #endif
     // m_raw is accessed most, so put it at the first field.
     T* m_raw;
-    PersistentNode* m_persistentNode;
+    PersistentNode* m_persistentNode = nullptr;
 #if ENABLE(ASSERT)
-    ThreadState* m_state;
+    ThreadState* m_state = nullptr;
 #endif
 };
 
 // Persistent is a way to create a strong pointer from an off-heap object
 // to another on-heap object. As long as the Persistent handle is alive
 // the GC will keep the object pointed to alive. The Persistent handle is
 // always a GC root from the point of view of the GC.
 //
 // We have to construct and destruct Persistent in the same thread.
 template<typename T>
@@ skipping 1092 matching lines @@
     // TODO(sof): extend WTF::FunctionWrapper call overloading to also handle (CrossThread)WeakPersistent.
     static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
 template<typename T>
 PassRefPtr<T> adoptRef(blink::RefCountedGarbageCollected<T>*) = delete;
 
 } // namespace WTF
 
 #endif