Oilpan: Introduce class MainThreadOnly

Source/platform/heap/ThreadState.h

 /*
  * Copyright (C) 2013 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 62 matching lines @@
 // only and objects that can be used on any thread.
 //
 // For objects that can only be used on the main thread we avoid going
 // through thread-local storage to get to the thread state.
 //
 // FIXME: We should evaluate the performance gain. Having
 // ThreadAffinity is complicating the implementation and we should get
 // rid of it if it is fast enough to go through thread-local storage
 // always.
 enum ThreadAffinity {
-    AnyThread,
-    MainThreadOnly,
+    AnyThreadAffinity,
+    MainThreadAffinity,
 };
 
-// FIXME: These forward declarations violate dependency rules. Remove them.
-// Ideally we want to provide a USED_IN_MAIN_THREAD_ONLY(T) macro, which
-// indicates that classes in T's hierarchy are used only by the main thread.
-class Node;
-class NodeList;
+class MainThreadOnly { };
 
-template<typename T,
-    bool mainThreadOnly = WTF::IsSubclass<typename WTF::RemoveConst<T>::Type, Node>::value
-        || WTF::IsSubclass<typename WTF::RemoveConst<T>::Type, NodeList>::value> struct DefaultThreadingTrait;
+template<typename T, bool mainThreadOnly = WTF::IsSubclass<typename WTF::RemoveConst<T>::Type, MainThreadOnly>::value> struct DefaultThreadingTrait;
 
 template<typename T>
 struct DefaultThreadingTrait<T, false> {
-    static const ThreadAffinity Affinity = AnyThread;
+    static const ThreadAffinity Affinity = AnyThreadAffinity;
 };
 
 template<typename T>
 struct DefaultThreadingTrait<T, true> {
-    static const ThreadAffinity Affinity = MainThreadOnly;
+    static const ThreadAffinity Affinity = MainThreadAffinity;
 };
 
 template<typename T>
 struct ThreadingTrait {
     static const ThreadAffinity Affinity = DefaultThreadingTrait<T>::Affinity;
 };
 
-// Marks the specified class as being used from multiple threads. When
-// a class is used from multiple threads we go through thread local
-// storage to get the heap in which to allocate an object of that type
-// and when allocating a Persistent handle for an object with that
-// type. Notice that marking the base class does not automatically
-// mark its descendants and they have to be explicitly marked.
-#define USED_FROM_MULTIPLE_THREADS(Class)                 \
-    class Class;                                          \
-    template<> struct ThreadingTrait<Class> {             \
-        static const ThreadAffinity Affinity = AnyThread; \
-    }
-
-#define USED_FROM_MULTIPLE_THREADS_NAMESPACE(Namespace, Class)          \
-    namespace Namespace {                                               \
-        class Class;                                                    \
-    }                                                                   \
-    namespace blink {                                                 \
-        template<> struct ThreadingTrait<Namespace::Class> {            \
-            static const ThreadAffinity Affinity = AnyThread;           \
-        };                                                              \
-    }
-
 template<typename U> class ThreadingTrait<const U> : public ThreadingTrait<U> { };
 
 // Declare that a class has a pre-finalizer function.  The function is called in
 // the object's owner thread, and can access Member<>s to other
 // garbage-collected objects allocated in the thread.  However we must not
 // allocate new garbage-collected objects, nor update Member<> and Persistent<>
 // pointers.
 //
 // This feature is similar to the HeapHashMap<WeakMember<Foo>, OwnPtr<Disposer>>
 // idiom.  The difference between this and the idiom is that pre-finalizer
@@ skipping 676 matching lines @@
 
 #if defined(ADDRESS_SANITIZER)
     void* m_asanFakeStack;
 #endif
 
     Vector<PageMemoryRegion*> m_allocatedRegionsSinceLastGC;
 };
 
 template<ThreadAffinity affinity> class ThreadStateFor;
 
-template<> class ThreadStateFor<MainThreadOnly> {
+template<> class ThreadStateFor<MainThreadAffinity> {
 public:
     static ThreadState* state()
     {
         // This specialization must only be used from the main thread.
         ASSERT(ThreadState::current()->isMainThread());
         return ThreadState::mainThreadState();
     }
 };
 
-template<> class ThreadStateFor<AnyThread> {
+template<> class ThreadStateFor<AnyThreadAffinity> {
 public:
     static ThreadState* state() { return ThreadState::current(); }
 };
 
 // The SafePointAwareMutexLocker is used to enter a safepoint while waiting for
 // a mutex lock. It also ensures that the lock is not held while waiting for a GC
 // to complete in the leaveSafePoint method, by releasing the lock if the
 // leaveSafePoint method cannot complete without blocking, see
 // SafePointBarrier::checkAndPark.
 class SafePointAwareMutexLocker {
@@ skipping 91 matching lines @@
     // whether the page is part of a terminting thread or
     // if the page is traced after being terminated (orphaned).
     uintptr_t m_terminating : 1;
     uintptr_t m_tracedAfterOrphaned : 1;
     uintptr_t m_promptlyFreedSize : 17; // == blinkPageSizeLog2
 };
 
 }
 
 #endif // ThreadState_h