Oilpan: move WorkerGlobalScope to oilpan's heap.

Source/platform/Supplementable.h

 /*
  * Copyright (C) 2012 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef Supplementable_h
 #define Supplementable_h
 
+#include "heap/Handle.h"
 #include "wtf/Assertions.h"
 #include "wtf/HashMap.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 
 #if !ASSERT_DISABLED
 #include "wtf/Threading.h"
 #endif
 
 namespace WebCore {
@@ skipping 41 matching lines @@
 // since in most case you'd provide the value while worker preparation is
 // being done on the main thread, even before the worker thread is started.
 // If that's the case you can explicitly call reattachThread() when the
 // Supplementable object is passed to the final destination thread (i.e.
 // worker thread). Please be extremely careful to use the method though,
 // as randomly calling the method could easily cause racy condition.
 //
 // Note that reattachThread() does nothing if assertion is not enabled.
 //
 
-template<typename T>
-class Supplementable;
+template<typename T, bool isGarbageCollected>
+class SupplementBase;
+
+template<typename T, bool isGarbageCollected>
+class SupplementableBase;
+
+template<typename T, bool isGarbageCollected>
+struct SupplementableTraits;
 
 template<typename T>
-class Supplement {
+struct SupplementableTraits<T, true> {
+    typedef PassOwnPtrWillBeRawPtr<SupplementBase<T, true> > SupplementArgumentType;
+    typedef WillBeHeapHashMap<const char*, OwnPtrWillBeMember<SupplementBase<T, true> >, PtrHash<const char*> > SupplementMap;
+};
+
+template<typename T>
+struct SupplementableTraits<T, false> {
+    typedef PassOwnPtr<SupplementBase<T, false> > SupplementArgumentType;
+    typedef HashMap<const char*, OwnPtr<SupplementBase<T, false> >, PtrHash<const char*> > SupplementMap;
+};
+
+template<bool>
+class SupplementTracing;
+
+template<>
+class SupplementTracing<true> {
 public:
-    virtual ~Supplement() { }
+    virtual void trace(Visitor*) = 0;
+};
+
+template<>
+class SupplementTracing<false> {
+public:
+    virtual void trace(Visitor*) { }
+};
+
+template<typename T, bool isGarbageCollected = false>
+class SupplementBase : public SupplementTracing<isGarbageCollected> {
+public:
+    virtual ~SupplementBase() { }
 #if SECURITY_ASSERT_ENABLED
     virtual bool isRefCountedWrapper() const { return false; }
 #endif
 
-    static void provideTo(Supplementable<T>& host, const char* key, PassOwnPtr<Supplement<T> > supplement)
+    static void provideTo(SupplementableBase<T, isGarbageCollected>& host, const char* key, typename SupplementableTraits<T, isGarbageCollected>::SupplementArgumentType supplement)
     {
         host.provideSupplement(key, supplement);
     }
 
-    static Supplement<T>* from(Supplementable<T>& host, const char* key)
+    static SupplementBase<T, isGarbageCollected>* from(SupplementableBase<T, isGarbageCollected>& host, const char* key)
     {
         return host.requireSupplement(key);
     }
 
-    static Supplement<T>* from(Supplementable<T>* host, const char* key)
+    static SupplementBase<T, isGarbageCollected>* from(SupplementableBase<T, isGarbageCollected>* host, const char* key)
     {
         return host ? host->requireSupplement(key) : 0;
     }
 };
 
-template<typename T>
-class Supplementable {
+template<typename T, bool isGarbageCollected = false>
+class SupplementableBase {
 public:
-    void provideSupplement(const char* key, PassOwnPtr<Supplement<T> > supplement)
+    void provideSupplement(const char* key, typename SupplementableTraits<T, isGarbageCollected>::SupplementArgumentType supplement)
     {
         ASSERT(m_threadId == currentThread());
         ASSERT(!m_supplements.get(key));
         m_supplements.set(key, supplement);
     }
 
     void removeSupplement(const char* key)
     {
         ASSERT(m_threadId == currentThread());
         m_supplements.remove(key);
     }
 
-    Supplement<T>* requireSupplement(const char* key)
+    SupplementBase<T, isGarbageCollected>* requireSupplement(const char* key)
     {
         ASSERT(m_threadId == currentThread());
         return m_supplements.get(key);
     }
 
     void reattachThread()
     {
 #if !ASSERT_DISABLED
         m_threadId = currentThread();
 #endif
     }
 
+    void trace(Visitor* visitor)
+    {
+        visitor->trace(m_supplements);
+    }

[haraken, 2014/02/27 02:46:01]

Let me make sure I'm understanding things correctly:

Given a Supplementable object A and Supplementing objects X and Y, trace() will
be called in the following sequence, right?

(1) A::trace() is called.
(2) A::trace() calls SupplementableBase::trace().
(3) SupplementableBase::trace() calls X::trace().
(4) SupplementableBase::trace() calls Y::trace().

+
 #if !ASSERT_DISABLED
 protected:
-    Supplementable() : m_threadId(currentThread()) { }
+    SupplementableBase() : m_threadId(currentThread()) { }
 #endif
 
 private:
-    typedef HashMap<const char*, OwnPtr<Supplement<T> >, PtrHash<const char*> > SupplementMap;
-    SupplementMap m_supplements;
+    typename SupplementableTraits<T, isGarbageCollected>::SupplementMap m_supplements;
 #if !ASSERT_DISABLED
     ThreadIdentifier m_threadId;
 #endif
 };
 
+template<typename T>
+class HeapSupplement : public SupplementBase<T, true> { };
+
+template<typename T>
+class HeapSupplementable : public SupplementableBase<T, true> { };
+
+template<typename T>
+class Supplement : public SupplementBase<T, false> { };
+
+template<typename T>
+class Supplementable : public SupplementableBase<T, false> { };
+
+template<typename T>
+struct ThreadingTrait<WebCore::SupplementBase<T, true> > {
+    static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
+};
+
+template<typename T>
+struct ThreadingTrait<WebCore::SupplementableBase<T, true> > {
+    static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
+};
+
 } // namespace WebCore
 
 #endif // Supplementable_h