Rename ObjectAliveTrait::isAlive() to isHeapObjectAlive().

Source/platform/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 174 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*);
+    static bool isHeapObjectAlive(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 193 matching lines @@
     {
         // Check that we actually know the definition of T when tracing.
         COMPILE_ASSERT(sizeof(T), WeNeedToKnowTheDefinitionOfTheTypeWeAreTracing);
         // The strongification of collections relies on the fact that once a
         // collection has been strongified, there is no way that it can contain
         // non-live entries, so no entries will be removed. Since you can't set
         // the mark bit on a null pointer, that means that null pointers are
         // always 'alive'.
         if (!obj)
             return true;
-        return ObjectAliveTrait<T>::isAlive(this, obj);
+        return ObjectAliveTrait<T>::isHeapObjectAlive(this, obj);
     }
     template<typename T> inline bool isAlive(const Member<T>& member)
     {
         return isAlive(member.get());
     }
     template<typename T> inline bool isAlive(RawPtr<T> ptr)
     {
         return isAlive(ptr.get());
     }
 
@@ skipping 115 matching lines @@
 #if ENABLE(ASSERT)
     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 isHeapObjectAlive(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 isHeapObjectAlive(Visitor* visitor, T* obj)
     {
-        return obj->isAlive(visitor);
+        return obj->isHeapObjectAlive(visitor);
     }
 };
 
-template<typename T> bool ObjectAliveTrait<T>::isAlive(Visitor* visitor, T* obj)
+template<typename T> bool ObjectAliveTrait<T>::isHeapObjectAlive(Visitor* visitor, T* obj)
 {
-    return DefaultObjectAliveTrait<T>::isAlive(visitor, obj);
+    return DefaultObjectAliveTrait<T>::isHeapObjectAlive(visitor, obj);
 }
 
 // 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 {};
 //
 // We can't correctly handle "Member<B> p = &a" as we can't compute addr of
 // object header statically. This can be solved by using GarbageCollectedMixin:
 // class B : public GarbageCollectedMixin {};
 // class A : public GarbageCollected, public B {
 //   USING_GARBAGE_COLLECTED_MIXIN(A)
 // };
 //
 // With the helper, as long as we are using Member<B>, TypeTrait<B> will
 // dispatch adjustAndMark dynamically to find collect addr of the object header.
 // Note that this is only enabled for Member<B>. For Member<A> which we can
 // compute the object header addr statically, this dynamic dispatch is not used.
 
 class PLATFORM_EXPORT GarbageCollectedMixin {
 public:
     virtual void adjustAndMark(Visitor*) const { };
-    virtual bool isAlive(Visitor*) const { return true; };
+    virtual bool isHeapObjectAlive(Visitor*) const { return true; };
     virtual void trace(Visitor*) { }
 };
 
 #define USING_GARBAGE_COLLECTED_MIXIN(TYPE) \
 public: \
     virtual void adjustAndMark(blink::Visitor* visitor) const OVERRIDE    \
     { \
         typedef WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<TYPE>::Type, blink::GarbageCollected> IsSubclassOfGarbageCollected; \
         COMPILE_ASSERT(IsSubclassOfGarbageCollected::value, OnlyGarbageCollectedObjectsCanHaveGarbageCollectedMixins); \
         visitor->mark(static_cast<const TYPE*>(this), &blink::TraceTrait<TYPE>::trace); \
     } \
-    virtual bool isAlive(blink::Visitor* visitor) const OVERRIDE  \
+    virtual bool isHeapObjectAlive(blink::Visitor* visitor) const OVERRIDE  \
     { \
         return visitor->isAlive(this); \
     } \
 private:
 
 #if ENABLE(OILPAN)
 #define WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(TYPE) USING_GARBAGE_COLLECTED_MIXIN(TYPE)
 #else
 #define WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(TYPE)
 #endif
@@ skipping 43 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif