Make trace() over persistents private.

third_party/WebKit/Source/platform/heap/Persistent.h

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef Persistent_h
 #define Persistent_h
 
 #include "platform/heap/Member.h"
 #include "platform/heap/PersistentNode.h"
 #include "wtf/Allocator.h"
@@ skipping 73 matching lines @@
     }
 
     ~PersistentBase()
     {
         uninitialize();
         m_raw = nullptr;
     }
 
     bool isHashTableDeletedValue() const { return m_raw == reinterpret_cast<T*>(-1); }
 
-    template<typename VisitorDispatcher>
-    void trace(VisitorDispatcher visitor)
-    {
-        static_assert(sizeof(T), "T must be fully defined");
-        static_assert(IsGarbageCollectedType<T>::value, "T needs to be a garbage collected object");
-        if (weaknessConfiguration == WeakPersistentConfiguration) {
-            visitor->registerWeakCell(&m_raw);
-        } else {
-            visitor->mark(m_raw);
-        }
-    }
-
     T* release()
     {
         T* result = m_raw;
         assign(nullptr);
         return result;
     }
 
     void clear() { assign(nullptr); }
     T& operator*() const { return *m_raw; }
     explicit operator bool() const { return m_raw; }
@@ skipping 65 matching lines @@
             m_raw = ptr;
         checkPointer();
         if (m_raw) {
             if (!m_persistentNode)
                 initialize();
             return;
         }
         uninitialize();
     }
 
+    template<typename VisitorDispatcher>
+    void tracePersistent(VisitorDispatcher visitor)
+    {
+        static_assert(sizeof(T), "T must be fully defined");
+        static_assert(IsGarbageCollectedType<T>::value, "T needs to be a garbage collected object");
+        if (weaknessConfiguration == WeakPersistentConfiguration) {
+            visitor->registerWeakCell(&m_raw);
+        } else {
+            visitor->mark(m_raw);
+        }
+    }
+
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void initialize()
     {
         ASSERT(!m_persistentNode);
         if (!m_raw || isHashTableDeletedValue())
             return;
 
-        TraceCallback traceCallback = TraceMethodDelegate<PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>, &PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>::trace>::trampoline;
+        TraceCallback traceCallback = TraceMethodDelegate<PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>, &PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>::tracePersistent>::trampoline;
         if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
             ProcessHeap::crossThreadPersistentRegion().allocatePersistentNode(m_persistentNode, this, traceCallback);
             return;
         }
         ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
         ASSERT(state->checkThread());
         m_persistentNode = state->getPersistentRegion()->allocatePersistentNode(this, traceCallback);
 #if ENABLE(ASSERT)
         m_state = state;
 #endif
@@ skipping 281 matching lines @@
     PersistentHeapCollectionBase(const OtherCollection& other) : Collection(other)
     {
         initialize();
     }
 
     ~PersistentHeapCollectionBase()
     {
         uninitialize();
     }
 
-    template<typename VisitorDispatcher>
-    void trace(VisitorDispatcher visitor)
-    {
-        static_assert(sizeof(Collection), "Collection must be fully defined");
-        visitor->trace(*static_cast<Collection*>(this));
-    }
-
     // See PersistentBase::registerAsStaticReference() comment.
     PersistentHeapCollectionBase* registerAsStaticReference()
     {
         if (m_persistentNode) {
             ASSERT(ThreadState::current());
             ThreadState::current()->registerStaticPersistentNode(m_persistentNode, &PersistentHeapCollectionBase<Collection>::clearPersistentNode);
             LEAK_SANITIZER_IGNORE_OBJECT(this);
         }
         return this;
     }
 
 private:
 
+    template<typename VisitorDispatcher>
+    void tracePersistent(VisitorDispatcher visitor)
+    {
+        static_assert(sizeof(Collection), "Collection must be fully defined");
+        visitor->trace(*static_cast<Collection*>(this));
+    }
+
     // Used when the registered PersistentNode of this object is
     // released during ThreadState shutdown, clearing the association.
     static void clearPersistentNode(void *self)
     {
         PersistentHeapCollectionBase<Collection>* collection = (reinterpret_cast<PersistentHeapCollectionBase<Collection>*>(self));
         collection->uninitialize();
         collection->clear();
     }
 
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void initialize()
     {
         // FIXME: Derive affinity based on the collection.
         ThreadState* state = ThreadState::current();
         ASSERT(state->checkThread());
-        m_persistentNode = state->getPersistentRegion()->allocatePersistentNode(this, TraceMethodDelegate<PersistentHeapCollectionBase<Collection>, &PersistentHeapCollectionBase<Collection>::trace>::trampoline);
+        m_persistentNode = state->getPersistentRegion()->allocatePersistentNode(this, TraceMethodDelegate<PersistentHeapCollectionBase<Collection>, &PersistentHeapCollectionBase<Collection>::tracePersistent>::trampoline);
 #if ENABLE(ASSERT)
         m_state = state;
 #endif
     }
 
     void uninitialize()
     {
         if (!m_persistentNode)
             return;
         ThreadState* state = ThreadState::current();
@@ skipping 196 matching lines @@
     // into it.
     //
     // TODO(sof): remove this hack once wtf/Functional.h can also work with a type like
     // CrossThreadWeakPersistent<>.
     static WeakPtr<T> unwrap(const StorageType& value) { return WeakPtr<T>(WeakReference<T>::create(value.get())); }
 };
 
 } // namespace WTF
 
 #endif // Persistent_h