Oilpan: Add CrossThreadWeakPersistent.

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 30 matching lines @@
 #include "wtf/Functional.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/Locker.h"
 #include "wtf/MainThread.h"
 #include "wtf/RawPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/TypeTraits.h"
 
 namespace blink {
 
-enum PersistentConfiguration {
-    NormalPersistentConfiguration,
-    WeakPersistentConfiguration,
-    CrossThreadPersistentConfiguration,
+enum WeaknessPersistentConfiguration {
+    NonWeakPersistentConfiguration,
+    WeakPersistentConfiguration
 };
 
-template<typename T, PersistentConfiguration persistentConfiguration>
+enum CrossThreadnessPersistentConfiguration {
+    SingleThreadPersistentConfiguration,
+    CrossThreadPersistentConfiguration
+};
+
+template<typename T, WeaknessPersistentConfiguration weaknessConfiguration, CrossThreadnessPersistentConfiguration crossThreadnessConfiguration>
 class PersistentBase {
 public:
     PersistentBase() : m_raw(nullptr)
     {
         initialize();
     }
 
     PersistentBase(std::nullptr_t) : m_raw(nullptr)
     {
         initialize();
@@ skipping 14 matching lines @@
     }
 
     PersistentBase(const PersistentBase& other) : m_raw(other)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    PersistentBase(const PersistentBase<U, persistentConfiguration>& other) : m_raw(other)
+    PersistentBase(const PersistentBase<U, weaknessConfiguration, crossThreadnessConfiguration>& other) : m_raw(other)
     {
         initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
     PersistentBase(const Member<U>& other) : m_raw(other)
     {
         initialize();
@@ skipping 13 matching lines @@
     {
         uninitialize();
         m_raw = nullptr;
     }
 
     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 (persistentConfiguration == WeakPersistentConfiguration) {
+        if (weaknessConfiguration == WeakPersistentConfiguration) {
             visitor->registerWeakCell(&m_raw);
         } else {
             visitor->mark(m_raw);
         }
     }
 
     RawPtr<T> release()
     {
         RawPtr<T> result = m_raw;
         m_raw = nullptr;
@@ skipping 25 matching lines @@
 
     PersistentBase& operator=(const PersistentBase& other)
     {
         m_raw = other;
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     template<typename U>
-    PersistentBase& operator=(const PersistentBase<U, persistentConfiguration>& other)
+    PersistentBase& operator=(const PersistentBase<U, weaknessConfiguration, crossThreadnessConfiguration>& other)
     {
         m_raw = other;
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     template<typename U>
     PersistentBase& operator=(const Member<U>& other)
     {
@@ skipping 10 matching lines @@
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
 
 private:
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void initialize()
     {
-        TraceCallback traceCallback = TraceMethodDelegate<PersistentBase<T, persistentConfiguration>, &PersistentBase<T, persistentConfiguration>::trace>::trampoline;
-        if (persistentConfiguration == CrossThreadPersistentConfiguration) {
+        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);
             state->persistentAllocated();
 #if ENABLE(ASSERT)
             m_state = state;
 #endif
         }
     }
 
     void uninitialize()
     {
-        if (persistentConfiguration == CrossThreadPersistentConfiguration) {
+        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);
             state->persistentFreed();
         }
     }
@@ skipping 35 matching lines @@
 #endif
 };
 
 // Persistent is a way to create a strong pointer from an on-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>
-class Persistent : public PersistentBase<T, NormalPersistentConfiguration> {
-    typedef PersistentBase<T, NormalPersistentConfiguration> Parent;
+class Persistent : public PersistentBase<T, NonWeakPersistentConfiguration, SingleThreadPersistentConfiguration> {
+    typedef PersistentBase<T, NonWeakPersistentConfiguration, SingleThreadPersistentConfiguration> Parent;
 public:
     Persistent() : Parent() { }
     Persistent(std::nullptr_t) : Parent(nullptr) { }
     Persistent(T* raw) : Parent(raw) { }
     Persistent(T& raw) : Parent(raw) { }
     Persistent(const Persistent& other) : Parent(other) { }
     template<typename U>
     Persistent(const Persistent<U>& other) : Parent(other) { }
     template<typename U>
     Persistent(const Member<U>& other) : Parent(other) { }
     template<typename U>
     Persistent(const RawPtr<U>& other) : Parent(other.get()) { }
 };
 
 // WeakPersistent is a way to create a weak pointer from an off-heap object
 // to an on-heap object. The m_raw is automatically cleared when the pointee
 // gets collected.
 //
 // We have to construct and destruct WeakPersistent in the same thread.
 //
 // Note that collections of WeakPersistents are not supported. Use a persistent
 // collection of WeakMembers instead.
 //
 //   HashSet<WeakPersistent<T>> m_set; // wrong
 //   PersistentHeapHashSet<WeakMember<T>> m_set; // correct
 template<typename T>
-class WeakPersistent : public PersistentBase<T, WeakPersistentConfiguration> {
-    typedef PersistentBase<T, WeakPersistentConfiguration> Parent;
+class WeakPersistent : public PersistentBase<T, WeakPersistentConfiguration, SingleThreadPersistentConfiguration> {
+    typedef PersistentBase<T, WeakPersistentConfiguration, SingleThreadPersistentConfiguration> Parent;
 public:
     WeakPersistent() : Parent() { }
     WeakPersistent(std::nullptr_t) : Parent(nullptr) { }
     WeakPersistent(T* raw) : Parent(raw) { }
     WeakPersistent(T& raw) : Parent(raw) { }
     WeakPersistent(const WeakPersistent& other) : Parent(other) { }
     template<typename U>
     WeakPersistent(const WeakPersistent<U>& other) : Parent(other) { }
     template<typename U>
     WeakPersistent(const Member<U>& other) : Parent(other) { }
     template<typename U>
     WeakPersistent(const RawPtr<U>& other) : Parent(other.get()) { }
 };
 
 // Unlike Persistent, we can destruct a CrossThreadPersistent in a thread
 // different from the construction thread.
 template<typename T>
-class CrossThreadPersistent : public PersistentBase<T, CrossThreadPersistentConfiguration> {
-    typedef PersistentBase<T, CrossThreadPersistentConfiguration> Parent;
+class CrossThreadPersistent : public PersistentBase<T, NonWeakPersistentConfiguration, CrossThreadPersistentConfiguration> {
+    typedef PersistentBase<T, NonWeakPersistentConfiguration, CrossThreadPersistentConfiguration> Parent;
 public:
     CrossThreadPersistent() : Parent() { }
     CrossThreadPersistent(std::nullptr_t) : Parent(nullptr) { }
     CrossThreadPersistent(T* raw) : Parent(raw) { }
     CrossThreadPersistent(T& raw) : Parent(raw) { }
     CrossThreadPersistent(const CrossThreadPersistent& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const CrossThreadPersistent<U>& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const Member<U>& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const RawPtr<U>& other) : Parent(other.get()) { }
 };
 
+template<typename T>
+class CrossThreadWeakPersistent : public PersistentBase<T, WeakPersistentConfiguration, CrossThreadPersistentConfiguration> {
+    typedef PersistentBase<T, WeakPersistentConfiguration, CrossThreadPersistentConfiguration> Parent;
+public:
+    CrossThreadWeakPersistent() : Parent() { }
+    CrossThreadWeakPersistent(std::nullptr_t) : Parent(nullptr) { }
+    CrossThreadWeakPersistent(T* raw) : Parent(raw) { }
+    CrossThreadWeakPersistent(T& raw) : Parent(raw) { }
+    CrossThreadWeakPersistent(const CrossThreadWeakPersistent& other) : Parent(other) { }
+    template<typename U>
+    CrossThreadWeakPersistent(const CrossThreadWeakPersistent<U>& other) : Parent(other) { }
+    template<typename U>
+    CrossThreadWeakPersistent(const Member<U>& other) : Parent(other) { }
+    template<typename U>
+    CrossThreadWeakPersistent(const RawPtr<U>& other) : Parent(other.get()) { }
+};
+
 // PersistentNode must be the left-most class to let the
 // visitor->trace(static_cast<Collection*>(this)) trace the correct position.
 // FIXME: derive affinity based on the collection.
 template<typename Collection>
 class PersistentHeapCollectionBase : public Collection {
     // We overload the various new and delete operators with using the WTF DefaultAllocator to ensure persistent
     // heap collections are always allocated off-heap. This allows persistent collections to be used in
     // DEFINE_STATIC_LOCAL et. al.
     WTF_USE_ALLOCATOR(PersistentHeapCollectionBase, WTF::DefaultAllocator);
 public:
@@ skipping 808 matching lines @@
 struct ParamStorageTraits<RawPtr<T>> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
     static_assert(sizeof(T), "T must be fully defined");
 };
 
 template<typename T>
 PassRefPtr<T> adoptRef(blink::RefCountedGarbageCollected<T>*) = delete;
 
 } // namespace WTF
 
 #endif