Oilpan: Introduce class MainThreadOnly

Source/platform/heap/Heap.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 1532 matching lines @@
 
     template<typename T>
     static T& getOther(T* other)
     {
         return *other;
     }
 
     static void enterNoAllocationScope()
     {
 #if ENABLE(ASSERT)
-        ThreadStateFor<AnyThread>::state()->enterNoAllocationScope();
+        ThreadStateFor<AnyThreadAffinity>::state()->enterNoAllocationScope();
 #endif
     }
 
     static void leaveNoAllocationScope()
     {
 #if ENABLE(ASSERT)
-        ThreadStateFor<AnyThread>::state()->leaveNoAllocationScope();
+        ThreadStateFor<AnyThreadAffinity>::state()->leaveNoAllocationScope();
 #endif
     }
 
 private:
     template<typename T, size_t u, typename V> friend class WTF::Vector;
     template<typename T, typename U, typename V, typename W> friend class WTF::HashSet;
     template<typename T, typename U, typename V, typename W, typename X, typename Y> friend class WTF::HashMap;
 };
 
 template<typename Value>
@@ skipping 183 matching lines @@
 };
 
 template<typename T>
 struct ThreadingTrait<WeakMember<T> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename Key, typename Value, typename T, typename U, typename V>
 struct ThreadingTrait<HashMap<Key, Value, T, U, V, HeapAllocator> > {
     static const ThreadAffinity Affinity =
-        (ThreadingTrait<Key>::Affinity == MainThreadOnly)
-        && (ThreadingTrait<Value>::Affinity == MainThreadOnly) ? MainThreadOnly : AnyThread;
+        (ThreadingTrait<Key>::Affinity == MainThreadAffinity)
+        && (ThreadingTrait<Value>::Affinity == MainThreadAffinity) ? MainThreadAffinity : AnyThreadAffinity;
 };
 
 template<typename First, typename Second>
 struct ThreadingTrait<WTF::KeyValuePair<First, Second> > {
     static const ThreadAffinity Affinity =
-        (ThreadingTrait<First>::Affinity == MainThreadOnly)
-        && (ThreadingTrait<Second>::Affinity == MainThreadOnly) ? MainThreadOnly : AnyThread;
+        (ThreadingTrait<First>::Affinity == MainThreadAffinity)
+        && (ThreadingTrait<Second>::Affinity == MainThreadAffinity) ? MainThreadAffinity : AnyThreadAffinity;
 };
 
 template<typename T, typename U, typename V>
 struct ThreadingTrait<HashSet<T, U, V, HeapAllocator> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 
 template<typename T, size_t inlineCapacity>
 struct ThreadingTrait<Vector<T, inlineCapacity, HeapAllocator> > {
@@ skipping 13 matching lines @@
 template<typename T, typename U, typename V>
 struct ThreadingTrait<HashCountedSet<T, U, V, HeapAllocator> > {
     static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 template<typename Table>
 struct ThreadingTrait<HeapHashTableBacking<Table> > {
     typedef typename Table::KeyType Key;
     typedef typename Table::ValueType Value;
     static const ThreadAffinity Affinity =
-        (ThreadingTrait<Key>::Affinity == MainThreadOnly)
-        && (ThreadingTrait<Value>::Affinity == MainThreadOnly) ? MainThreadOnly : AnyThread;
+        (ThreadingTrait<Key>::Affinity == MainThreadAffinity)
+        && (ThreadingTrait<Value>::Affinity == MainThreadAffinity) ? MainThreadAffinity : AnyThreadAffinity;
 };
 
 template<typename T, typename U, typename V, typename W, typename X>
 struct ThreadingTrait<HeapHashMap<T, U, V, W, X> > : public ThreadingTrait<HashMap<T, U, V, W, X, HeapAllocator> > { };
 
 template<typename T, typename U, typename V>
 struct ThreadingTrait<HeapHashSet<T, U, V> > : public ThreadingTrait<HashSet<T, U, V, HeapAllocator> > { };
 
 template<typename T, size_t inlineCapacity>
 struct ThreadingTrait<HeapVector<T, inlineCapacity> > : public ThreadingTrait<Vector<T, inlineCapacity, HeapAllocator> > { };
@@ skipping 567 matching lines @@
 };
 
 template<typename T>
 struct IfWeakMember<WeakMember<T> > {
     static bool isDead(Visitor* visitor, const WeakMember<T>& t) { return !visitor->isAlive(t.get()); }
 };
 
 }
 
 #endif // Heap_h