Oilpan: fix Windows build after r187674.

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 45 matching lines @@
 namespace blink {
 
 template<typename T> class GarbageCollected;
 template<typename T> class GarbageCollectedFinalized;
 class GarbageCollectedMixin;
 class GeneralHeapObjectHeader;
 class HeapObjectHeader;
 class InlinedGlobalMarkingVisitor;
 template<typename T> class Member;
 template<typename T> class WeakMember;
+template<typename ValueArg, size_t inlineCapacity> struct HeapListHashSetAllocator;
 class Visitor;
 
+} // namespace blink
+
+namespace WTF {
+
+template<typename ValueArg, typename Allocator> class ListHashSetNode;
+
+template<typename T>
+struct NeedsTracing<blink::Member<T>> {
+    static const bool value = true;
+};
+
+template<typename T>
+struct IsWeak<blink::WeakMember<T>> {
+    static const bool value = true;
+};
+
+template<typename T, size_t inlineCapacity>
+struct NeedsTracing<ListHashSetNode<T, blink::HeapListHashSetAllocator<T, inlineCapacity>> *> {
+    // All heap allocated node pointers need visiting to keep the nodes alive,
+    // regardless of whether they contain pointers to other heap allocated
+    // objects.
+    static const bool value = true;
+};
+
+} // namespace WTF
+
+namespace blink {
+
 template <typename T> struct IsGarbageCollectedType;
 #define STATIC_ASSERT_IS_GARBAGE_COLLECTED(T, ErrorMessage) \
     static_assert(IsGarbageCollectedType<T>::value, ErrorMessage)
 #define STATIC_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, ErrorMessage) \
     static_assert(!IsGarbageCollectedType<T>::value, ErrorMessage)
 
 template<bool needsTracing, WTF::WeakHandlingFlag weakHandlingFlag, WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits> struct CollectionBackingTraceTrait;
 
 // The TraceMethodDelegate is used to convert a trace method for type T to a TraceCallback.
 // This allows us to pass a type's trace method as a parameter to the PersistentNode
@@ skipping 95 matching lines @@
 public:
     static const bool value = false;
 };
 
 template <typename T>
 struct HasInlinedTraceMethod<T, typename T::HasInlinedTraceMethod> {
 public:
     static const bool value = true;
 };
 
-template <typename T, bool = HasInlinedTraceMethod<T>::value>
+template <typename T, bool needsTracing, bool = HasInlinedTraceMethod<T>::value>
 struct TraceCompatibilityAdaptor;
 
 // The TraceTrait is used to specify how to mark an object pointer and
 // how to trace all of the pointers in the object.
 //
 // By default, the 'trace' method implemented on an object itself is
 // used to trace the pointers to other heap objects inside the object.
 //
 // However, the TraceTrait can be specialized to use a different
 // implementation. A common case where a TraceTrait specialization is
 // needed is when multiple inheritance leads to pointers that are not
 // to the start of the object in the Blink garbage-collected heap. In
 // that case the pointer has to be adjusted before marking.
 template<typename T>
 class TraceTrait {
+    static const bool needsTracing = WTF::NeedsTracing<T>::value || WTF::IsWeak<T>::value;
 public:
     // Default implementation of TraceTrait<T>::trace just statically
     // dispatches to the trace method of the class T.
     template<typename VisitorDispatcher>
     static void trace(VisitorDispatcher visitor, void* self)
     {
-        TraceCompatibilityAdaptor<T>::trace(visitor, static_cast<T*>(self));
+        TraceCompatibilityAdaptor<T, needsTracing>::trace(visitor, static_cast<T*>(self));
     }
 
     template<typename VisitorDispatcher>
     static void mark(VisitorDispatcher visitor, const T* t)
     {
         DefaultTraceTrait<T>::mark(visitor, t);
     }
 
 #if ENABLE(ASSERT)
     static void checkGCInfo(const T* t)
@@ skipping 675 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif