Oilpan: remove now-unused thread affinity macros.

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 94 matching lines @@
 template<typename T>
 struct DefaultThreadingTrait<T, true> {
     static const ThreadAffinity Affinity = MainThreadOnly;
 };
 
 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 796 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