Oilpan: enable eager tracing.

Source/platform/heap/Handle.h

 /*
  * Copyright (C) 2014 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 968 matching lines @@
 
 template<typename T>
 class TraceEagerlyTrait<CrossThreadPersistent<T>> {
 public:
     static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T, typename U, typename V, typename W, typename X>
 class TraceEagerlyTrait<HeapHashMap<T, U, V, W, X> > {
 public:
-    static const bool value = IS_EAGERLY_TRACED_HEAP_COLLECTION(T) || IS_EAGERLY_TRACED_HEAP_COLLECTION(U);
+    static const bool value = TraceEagerlyTrait<T>::value || TraceEagerlyTrait<U>::value;

[Erik Corry, 2014/12/09 15:49:02]

Can't this just be "true"?  We can eagerly trace the collection itself even if
its backing contains pointers that cannot be eagerly traced.

[sof, 2014/12/09 21:55:37]

why not. I've made the enabled flag/setting for this feature take precedence, so
as to enable eager tracing with its current setting.

 };
 
 template<typename T, typename U, typename V>
 class TraceEagerlyTrait<HeapHashSet<T, U, V> > {
 public:
-    static const bool value = IS_EAGERLY_TRACED_HEAP_COLLECTION(T);
+    static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T, typename U, typename V>
 class TraceEagerlyTrait<HeapLinkedHashSet<T, U, V> > {
 public:
-    static const bool value = IS_EAGERLY_TRACED_HEAP_COLLECTION(T);
+    static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T, size_t inlineCapacity, typename U>
 class TraceEagerlyTrait<HeapListHashSet<T, inlineCapacity, U> > {
 public:
-    static const bool value = IS_EAGERLY_TRACED_HEAP_COLLECTION(T);
+    static const bool value = TraceEagerlyTrait<T>::value;
+};
+
+template<typename T, size_t inlineCapacity>
+class TraceEagerlyTrait<WTF::ListHashSetNode<T, HeapListHashSetAllocator<T, inlineCapacity>>> {
+public:
+    static const bool value = false;
 };
 
 template<typename T, size_t inlineCapacity>
 class TraceEagerlyTrait<HeapVector<T, inlineCapacity> > {
 public:
-    static const bool value = IS_EAGERLY_TRACED_HEAP_COLLECTION(T);
+    static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T, typename U>
 class TraceEagerlyTrait<HeapVectorBacking<T, U> > {
 public:
-    static const bool value = IS_EAGERLY_TRACED_HEAP_COLLECTION(T);
+    static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T, size_t inlineCapacity>
 class TraceEagerlyTrait<HeapDeque<T, inlineCapacity> > {
 public:
-    static const bool value = IS_EAGERLY_TRACED_HEAP_COLLECTION(T);
+    static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 template<typename T, typename U, typename V>
 class TraceEagerlyTrait<HeapHashCountedSet<T, U, V> > {
 public:
-    static const bool value = IS_EAGERLY_TRACED_HEAP_COLLECTION(T);
+    static const bool value = TraceEagerlyTrait<T>::value;
 };
 
 } // namespace blink
 
 namespace WTF {
 
 template <typename T> struct VectorTraits<blink::Member<T> > : VectorTraitsBase<blink::Member<T> > {
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
     static const bool canMoveWithMemcpy = true;
@@ skipping 179 matching lines @@
 template<typename T>
 struct ParamStorageTraits<RawPtr<T> > : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
 };
 
 template<typename T>
 PassRefPtr<T> adoptRef(blink::RefCountedGarbageCollected<T>*) = delete;
 
 } // namespace WTF
 
 #endif