Oilpan: support eager tracing of objects when marking.

Source/platform/heap/HeapTest.cpp

 /*
  * 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 215 matching lines @@
     EXPECT_TRUE(scope.allThreadsParked());
     return Heap::objectPayloadSizeForTesting();
 }
 
 #define DEFINE_VISITOR_METHODS(Type)                                       \
     virtual void mark(const Type* object, TraceCallback callback) override \
     {                                                                      \
         if (object)                                                        \
             m_count++;                                                     \
     }                                                                      \
-    virtual bool isMarked(const Type*) override { return false; }
+    virtual bool isMarked(const Type*) override { return false; }          \
+    virtual bool ensureMarked(const Type* objectPointer) override          \
+    {                                                                      \
+        return ensureMarked(objectPointer);                                \
+    }
 
 class CountingVisitor : public Visitor {
 public:
     CountingVisitor()
         : m_count(0)
     {
     }
 
     virtual void mark(const void* object, TraceCallback) override
     {
@@ skipping 14 matching lines @@
     }
 
     virtual void registerDelayedMarkNoTracing(const void*) override { }
     virtual void registerWeakMembers(const void*, const void*, WeakPointerCallback) override { }
     virtual void registerWeakTable(const void*, EphemeronCallback, EphemeronCallback) override { }
 #if ENABLE(ASSERT)
     virtual bool weakTableRegistered(const void*) override { return false; }
 #endif
     virtual void registerWeakCell(void**, WeakPointerCallback) override { }
     virtual bool isMarked(const void*) override { return false; }
+    virtual bool ensureMarked(const void* objectPointer) override
+    {
+        if (!objectPointer || isMarked(objectPointer))
+            return false;
+        markNoTracing(objectPointer);
+        return true;
+    }
 
     FOR_EACH_TYPED_HEAP(DEFINE_VISITOR_METHODS)
 
     size_t count() { return m_count; }
     void reset() { m_count = 0; }
 
 private:
     size_t m_count;
 };
 
+#undef DEFINE_VISITOR_METHODS
+
 class SimpleObject : public GarbageCollected<SimpleObject> {
 public:
     static SimpleObject* create() { return new SimpleObject(); }
     void trace(Visitor*) { }
     char getPayload(int i) { return payload[i]; }
     // This virtual method is unused but it is here to make sure
     // that this object has a vtable. This object is used
     // as the super class for objects that also have garbage
     // collected mixins and having a virtual here makes sure
     // that adjustment is needed both for marking and for isAlive
     // checks.
     virtual void virtualMethod() { }
 protected:
     SimpleObject() { }
     char payload[64];
 };
 
-#undef DEFINE_VISITOR_METHODS
-
 class HeapTestSuperClass : public GarbageCollectedFinalized<HeapTestSuperClass> {
 public:
     static HeapTestSuperClass* create()
     {
         return new HeapTestSuperClass();
     }
 
     virtual ~HeapTestSuperClass()
     {
         ++s_destructorCalls;
@@ skipping 4916 matching lines @@
 
 TEST(HeapTest, NonNodeAllocatingNodeInDestructor)
 {
     new NonNodeAllocatingNodeInDestructor();
     Heap::collectGarbage(ThreadState::NoHeapPointersOnStack);
     EXPECT_EQ(10, (*NonNodeAllocatingNodeInDestructor::s_node)->value());
     delete NonNodeAllocatingNodeInDestructor::s_node;
     NonNodeAllocatingNodeInDestructor::s_node = 0;
 }
 
+class TraceTypeEagerly1 : public GarbageCollected<TraceTypeEagerly1> { };
+WILL_BE_EAGERLY_TRACED(TraceTypeEagerly1);
+class TraceTypeEagerly2 : public TraceTypeEagerly1 { };
+
+class TraceTypeEagerly3 { };
+WILL_BE_EAGERLY_TRACED(TraceTypeEagerly3);
+
+class TraceTypeEagerly4 : public TraceTypeEagerly3 { };
+
+class TraceTypeEagerly5 { };
+WILL_BE_EAGERLY_TRACED_CLASS(TraceTypeEagerly5);
+
+class TraceTypeEagerly6 : public TraceTypeEagerly5 { };
+
+class TraceTypeEagerly7 { };
+
+class TraceTypeNonEagerly1 { };
+WILL_NOT_BE_EAGERLY_TRACED(TraceTypeNonEagerly1);
+
+TEST(HeapTest, TraceTypesEagerly)
+{
+    COMPILE_ASSERT(TraceEagerlyTrait<TraceTypeEagerly1>::value, ShouldBeTrue);
+    COMPILE_ASSERT(TraceEagerlyTrait<Member<TraceTypeEagerly1>>::value, ShouldBeTrue);
+    COMPILE_ASSERT(TraceEagerlyTrait<WeakMember<TraceTypeEagerly1>>::value, ShouldBeTrue);
+    COMPILE_ASSERT(!TraceEagerlyTrait<RawPtr<TraceTypeEagerly1>>::value, ShouldBeTrue);
+    COMPILE_ASSERT(TraceEagerlyTrait<HeapVector<Member<TraceTypeEagerly1>>>::value, ShouldBeTrue);
+    COMPILE_ASSERT(TraceEagerlyTrait<HeapVector<WeakMember<TraceTypeEagerly1>>>::value, ShouldBeTrue);
+    COMPILE_ASSERT(TraceEagerlyTrait<HeapHashSet<Member<TraceTypeEagerly1>>>::value, ShouldBeTrue);
+    COMPILE_ASSERT(TraceEagerlyTrait<HeapHashSet<Member<TraceTypeEagerly1>>>::value, ShouldBeTrue);
+    using HashMapIntToObj = HeapHashMap<int, Member<TraceTypeEagerly1>>;
+    COMPILE_ASSERT(TraceEagerlyTrait<HashMapIntToObj>::value, ShouldBeTrue);
+    using HashMapObjToInt = HeapHashMap<Member<TraceTypeEagerly1>, int>;
+    COMPILE_ASSERT(TraceEagerlyTrait<HashMapObjToInt>::value, ShouldBeTrue);
+
+    COMPILE_ASSERT(TraceEagerlyTrait<TraceTypeEagerly2>::value, ShouldBeTrue);
+    COMPILE_ASSERT(TraceEagerlyTrait<TraceTypeEagerly3>::value, ShouldBeTrue);
+
+    COMPILE_ASSERT(TraceEagerlyTrait<TraceTypeEagerly4>::value, ShouldBeTrue);
+
+    COMPILE_ASSERT(TraceEagerlyTrait<TraceTypeEagerly5>::value, ShouldBeTrue);
+    COMPILE_ASSERT(TraceEagerlyTrait<Member<TraceTypeEagerly5>>::value, ShouldBeTrue);
+
+    COMPILE_ASSERT(!TraceEagerlyTrait<TraceTypeEagerly6>::value, ShouldBeTrue);
+    COMPILE_ASSERT(!TraceEagerlyTrait<TraceTypeEagerly7>::value, ShouldBeTrue);
+
+    COMPILE_ASSERT(!TraceEagerlyTrait<TraceTypeNonEagerly1>::value, ShouldBeTrue);
+}
+
 } // namespace blink