Oilpan: Fix isAlive dispatching for GarbageCollectedMixins.

Source/heap/Visitor.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 161 matching lines @@
 #endif
 };
 
 template<typename T> class TraceTrait<const T> : public TraceTrait<T> { };
 
 template<typename Collection>
 struct OffHeapCollectionTraceTrait;
 
 template<typename T>
 struct ObjectAliveTrait {
-    static bool isAlive(Visitor*, T);
-};
-
-template<typename T>
-struct ObjectAliveTrait<Member<T> > {
-    static bool isAlive(Visitor*, const Member<T>&);
+    static bool isAlive(Visitor*, T*);
 };
 
 // Visitor is used to traverse the Blink object graph. Used for the
 // marking phase of the mark-sweep garbage collector.
 //
 // Pointers are marked and pushed on the marking stack by calling the
 // |mark| method with the pointer as an argument.
 //
 // Pointers within objects are traced by calling the |trace| methods
 // with the object as an argument. Tracing objects will mark all of the
@@ skipping 161 matching lines @@
     // run on the thread performing garbage collection. Therefore, all
     // threads are stopped during weak cell callbacks.
     template<typename T>
     void registerWeakCell(T** cell)
     {
         registerWeakCell(reinterpret_cast<void**>(cell), &handleWeakCell<T>);
     }
 
     virtual bool isMarked(const void*) = 0;
 
-    template<typename T> inline bool isAlive(T obj) { return ObjectAliveTrait<T>::isAlive(this, obj); }
+    template<typename T> inline bool isAlive(T* obj)
+    {
+        return ObjectAliveTrait<T>::isAlive(this, obj);
+    }
     template<typename T> inline bool isAlive(const Member<T>& member)
     {
         return isAlive(member.get());
     }
 
 #ifndef NDEBUG
     void checkGCInfo(const void*, const GCInfo*);
 #endif
 
     // Macro to declare methods needed for each typed heap.
@@ skipping 138 matching lines @@
 #ifndef NDEBUG
     static void checkGCInfo(Visitor*, const T*) { }
 #endif
 };
 
 template<typename T, bool = NeedsAdjustAndMark<T>::value> class DefaultObjectAliveTrait;
 
 template<typename T>
 class DefaultObjectAliveTrait<T, false> {
 public:
-    static bool isAlive(Visitor* visitor, T obj)
+    static bool isAlive(Visitor* visitor, T* obj)
     {
         return visitor->isMarked(obj);
     }
 };
 
 template<typename T>
 class DefaultObjectAliveTrait<T, true> {
 public:
-    static bool isAlive(Visitor* visitor, T obj)
+    static bool isAlive(Visitor* visitor, T* obj)
     {
         return obj->isAlive(visitor);
     }
 };
 
-template<typename T> bool ObjectAliveTrait<T>::isAlive(Visitor* visitor, T obj)
+template<typename T> bool ObjectAliveTrait<T>::isAlive(Visitor* visitor, T* obj)
 {
     return DefaultObjectAliveTrait<T>::isAlive(visitor, obj);
 }
-template<typename T> bool ObjectAliveTrait<Member<T> >::isAlive(Visitor* visitor, const Member<T>& obj)
-{
-    return visitor->isMarked(obj.get());
-}
 
 // The GarbageCollectedMixin interface and helper macro
 // USING_GARBAGE_COLLECTED_MIXIN can be used to automatically define
 // TraceTrait/ObjectAliveTrait on non-leftmost deriving classes
 // which need to be garbage collected.
 //
 // Consider the following case:
 // class B {};
 // class A : public GarbageCollected, public B {};
 //
@@ skipping 64 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif