Refactor the Heap into ThreadHeap to prepare for per thread heaps

third_party/WebKit/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 37 matching lines @@
 
 namespace blink {
 
 enum WeaknessPersistentConfiguration {
     NonWeakPersistentConfiguration,
     WeakPersistentConfiguration
 };
 
 enum CrossThreadnessPersistentConfiguration {
     SingleThreadPersistentConfiguration,
-    CrossThreadPersistentConfiguration
+    CrossThreadPersistentConfiguration,
+    XThreadPersistentConfiguration
 };
 
 template<typename T, WeaknessPersistentConfiguration weaknessConfiguration, CrossThreadnessPersistentConfiguration crossThreadnessConfiguration>
 class PersistentBase {
 public:
     PersistentBase() : m_raw(nullptr)
     {
         initialize();
     }
 
@@ skipping 131 matching lines @@
     }
 
     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) {
+        if (crossThreadnessConfiguration == XThreadPersistentConfiguration) {
+            BasePage* page = pageFromObject(m_raw);
+            if (!page)
+                return;
+            m_persistentNode = page->heap()->threadState()->xThreadPersistentRegion()->allocatePersistentNode(this, traceCallback);
+        } else 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) {
+        if (crossThreadnessConfiguration == XThreadPersistentConfiguration) {
+            BasePage* page = pageFromObject(m_raw);
+            ASSERT(page);
+            page->heap()->threadState()->xThreadPersistentRegion()->freePersistentNode(m_persistentNode);
+        } else 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;
     }
@@ skipping 265 matching lines @@
     }
 
     template<typename U>
     CrossThreadWeakPersistent& operator=(const RawPtr<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 };
 
+template<typename T>
+class XThreadPersistent : public PersistentBase<T, NonWeakPersistentConfiguration, XThreadPersistentConfiguration> {
+    typedef PersistentBase<T, NonWeakPersistentConfiguration, XThreadPersistentConfiguration> Parent;
+public:
+    XThreadPersistent() : Parent() { }
+    XThreadPersistent(std::nullptr_t) : Parent(nullptr) { }
+    XThreadPersistent(T* raw) : Parent(raw) { }
+    XThreadPersistent(T& raw) : Parent(raw) { }
+    XThreadPersistent(const XThreadPersistent& other) : Parent(other) { }
+    template<typename U>
+    XThreadPersistent(const XThreadPersistent<U>& other) : Parent(other) { }
+    template<typename U>
+    XThreadPersistent(const Member<U>& other) : Parent(other) { }
+    template<typename U>
+    XThreadPersistent(const RawPtr<U>& other) : Parent(other.get()) { }
+
+    template<typename U>
+    XThreadPersistent& operator=(U* other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    XThreadPersistent& operator=(std::nullptr_t)
+    {
+        Parent::operator=(nullptr);
+        return *this;
+    }
+
+    XThreadPersistent& operator=(const XThreadPersistent& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    XThreadPersistent& operator=(const XThreadPersistent<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    XThreadPersistent& operator=(const Member<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    XThreadPersistent& operator=(const RawPtr<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+};
+
 template<typename Collection>
 class PersistentHeapCollectionBase : public Collection {
     // We overload the various new and delete operators with using the WTF PartitionAllocator 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::PartitionAllocator);
 public:
     PersistentHeapCollectionBase()
     {
         initialize();
@@ skipping 947 matching lines @@
     static_assert(sizeof(T), "T must be fully defined");
     using StorageType = T*;
 
     static StorageType wrap(T* value) { return value; }
     static T* unwrap(const StorageType& value) { return value; }
 };
 
 template<typename T>
 struct PointerParamStorageTraits<T*, true> {
     static_assert(sizeof(T), "T must be fully defined");
-    using StorageType = blink::CrossThreadPersistent<T>;
+    using StorageType = blink::XThreadPersistent<T>;
 
     static StorageType wrap(T* value) { return value; }
     static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
 template<typename T>
 struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
     static_assert(sizeof(T), "T must be fully defined");
 };
 
@@ skipping 13 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