[oilpan] Remove GC_INFO_{DEFINE,DECLARE} macros

Source/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 877 matching lines @@
     }
 
     void operator delete(void* p)
     {
         ASSERT_NOT_REACHED();
     }
 
 protected:
     HeapAllocated() { ASSERT(ThreadStateFor<ThreadingTrait<T>::Affinity>::State()->contains(reinterpret_cast<Address>(this))); }
     ~HeapAllocated() { }
+
+public:
+    typedef T HeapAllocatedBase;
 };
 
 // Forward declaration.
 template<typename T> class Persistent;
 #if defined(TRACE_GC_MARKING) && TRACE_GC_MARKING
 template<typename T> class NamedPersistent;
 #endif
 
 // Base class for the transition period. Provides new and delete
 // operators for allocation on the heap as well as finalization
 // behavior.
 template<typename T>
 class HeapAllocatedFinalized : public HeapAllocated<T> {
     WTF_MAKE_NONCOPYABLE(HeapAllocatedFinalized);
 
 protected:
     // Finalize is called when the object is freed from the heap. Finalize
     // can be overridden to support calling the destructor of a subclass.
     // This is similar to the way deref is overridden to call delete on
     // the correct subtype.
     void finalize()
     {
         static_cast<T*>(this)->~T();
     }
+    template<typename Any> friend struct FinalizerTrait;

[kouhei (in TOK), 2014/02/19 02:02:53]

Maybe this can be made public? all override of this method is declared public.

[zerny-chromium, 2014/02/19 09:44:48]

If this is the only friend declaration we need (ie, none are needed in client
code), then let's keep it protected.

 
     HeapAllocatedFinalized() { }
     ~HeapAllocatedFinalized() { }
     friend void heapAllocatedFinalizer<T>(void*);
     template<typename U> friend struct HasFinalizer;
     template<typename U, bool> friend struct FinalizerTraitImpl;
 };
 
 // Base class for objects that are in the heap and are still reference
 // counted.
@@ skipping 397 matching lines @@
 
 template<typename T, typename Traits>
 class HeapVectorBacking { };
 template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
 class HeapHashTableBacking { };
 
 
 } // namespace WebCore
 
 #endif