Oilpan: Fix ParamStorageTraits for RawPtr<T>.

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 51 matching lines @@
     template<size_t> struct F;
     template<typename U> static TrueType hasAdjustAndMark(F<sizeof(&U::adjustAndMark)>*);
     template<typename U> static TrueType hasIsAlive(F<sizeof(&U::isAlive)>*);
 #endif
     template<typename U> static FalseType hasIsAlive(...);
     template<typename U> static FalseType hasAdjustAndMark(...);
 
     static bool const value = (sizeof(TrueType) == sizeof(hasAdjustAndMark<T>(0))) && (sizeof(TrueType) == sizeof(hasIsAlive<T>(0)));
 };
 
-#define COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, ErrorMessage)                                                          \
-    do {                                                                                                              \
-        typedef typename WTF::RemoveConst<T>::Type NonConstType;                                                      \
-        typedef WTF::IsSubclassOfTemplate<NonConstType, GarbageCollected> GarbageCollectedSubclass;                   \
-        typedef IsGarbageCollectedMixin<NonConstType> GarbageCollectedMixinSubclass;                                  \
-        typedef WTF::IsSubclassOfTemplate3<NonConstType, HeapHashSet> HeapHashSetSubclass;                            \
-        typedef WTF::IsSubclassOfTemplate3<NonConstType, HeapLinkedHashSet> HeapLinkedHashSetSubclass;                \
-        typedef WTF::IsSubclassOfTemplateTypenameSizeTypename<NonConstType, HeapListHashSet> HeapListHashSetSubclass; \
-        typedef WTF::IsSubclassOfTemplate5<NonConstType, HeapHashMap> HeapHashMapSubclass;                            \
-        typedef WTF::IsSubclassOfTemplateTypenameSize<NonConstType, HeapVector> HeapVectorSubclass;                   \
-        typedef WTF::IsSubclassOfTemplateTypenameSize<NonConstType, HeapDeque> HeapDequeSubclass;                     \
-        typedef WTF::IsSubclassOfTemplate3<NonConstType, HeapHashCountedSet> HeapHashCountedSetSubclass;              \
-        typedef WTF::IsSubclassOfTemplate<NonConstType, HeapTerminatedArray> HeapTerminatedArraySubclass;             \
-        COMPILE_ASSERT(GarbageCollectedSubclass::value ||                                                             \
-            GarbageCollectedMixinSubclass::value ||                                                                   \
-            HeapHashSetSubclass::value ||                                                                             \
-            HeapLinkedHashSetSubclass::value ||                                                                       \
-            HeapListHashSetSubclass::value ||                                                                         \
-            HeapHashMapSubclass::value ||                                                                             \
-            HeapVectorSubclass::value ||                                                                              \
-            HeapDequeSubclass::value ||                                                                               \
-            HeapHashCountedSetSubclass::value ||                                                                      \
-            HeapTerminatedArraySubclass::value,                                                                       \
-            ErrorMessage);                                                                                            \
-    } while (0)
+template <typename T>
+struct IsGarbageCollectedType {
+    typedef typename WTF::RemoveConst<T>::Type NonConstType;
+    typedef WTF::IsSubclassOfTemplate<NonConstType, GarbageCollected> GarbageCollectedSubclass;
+    typedef IsGarbageCollectedMixin<NonConstType> GarbageCollectedMixinSubclass;
+    typedef WTF::IsSubclassOfTemplate3<NonConstType, HeapHashSet> HeapHashSetSubclass;
+    typedef WTF::IsSubclassOfTemplate3<NonConstType, HeapLinkedHashSet> HeapLinkedHashSetSubclass;
+    typedef WTF::IsSubclassOfTemplateTypenameSizeTypename<NonConstType, HeapListHashSet> HeapListHashSetSubclass;
+    typedef WTF::IsSubclassOfTemplate5<NonConstType, HeapHashMap> HeapHashMapSubclass;
+    typedef WTF::IsSubclassOfTemplateTypenameSize<NonConstType, HeapVector> HeapVectorSubclass;
+    typedef WTF::IsSubclassOfTemplateTypenameSize<NonConstType, HeapDeque> HeapDequeSubclass;
+    typedef WTF::IsSubclassOfTemplate3<NonConstType, HeapHashCountedSet> HeapHashCountedSetSubclass;
+    typedef WTF::IsSubclassOfTemplate<NonConstType, HeapTerminatedArray> HeapTerminatedArraySubclass;
+    static const bool value =
+        GarbageCollectedSubclass::value
+        || GarbageCollectedMixinSubclass::value
+        || HeapHashSetSubclass::value
+        || HeapLinkedHashSetSubclass::value
+        || HeapListHashSetSubclass::value
+        || HeapHashMapSubclass::value
+        || HeapVectorSubclass::value
+        || HeapDequeSubclass::value
+        || HeapHashCountedSetSubclass::value
+        || HeapTerminatedArraySubclass::value;
+};
+
+#define COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, ErrorMessage) \
+    COMPILE_ASSERT(IsGarbageCollectedType<T>::value, ErrorMessage)
 
 template<typename T> class Member;
 
 class PersistentNode {
 public:
     explicit PersistentNode(TraceCallback trace)
         : m_trace(trace)
     {
     }
 
@@ skipping 1046 matching lines @@
 struct NeedsTracing<ListHashSetNode<T, WebCore::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;
 };
 
 // For wtf/Functional.h
 template<typename T, bool isGarbageCollected> struct PointerParamStorageTraits;
 
-template<typename T> struct PointerParamStorageTraits<T*, false> {
+template<typename T>
+struct PointerParamStorageTraits<T*, false> {
     typedef T* StorageType;
 
     static StorageType wrap(T* value) { return value; }
     static T* unwrap(const StorageType& value) { return value; }
 };
 
-template<typename T> struct PointerParamStorageTraits<T*, true> {
+template<typename T>
+struct PointerParamStorageTraits<T*, true> {
     typedef WebCore::CrossThreadPersistent<T> StorageType;
 
     static StorageType wrap(T* value) { return value; }
     static T* unwrap(const StorageType& value) { return value.get(); }
 };
 
-// FIXME: This doesn't support collections and const types. See
-// COMPILE_ASSERT_IS_GARBAGE_COLLECTED.
-template<typename T> struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, WTF::IsSubclassOfTemplate<T, WebCore::GarbageCollected>::value || WebCore::IsGarbageCollectedMixin<T>::value> {
+template<typename T>
+struct ParamStorageTraits<T*> : public PointerParamStorageTraits<T*, WebCore::IsGarbageCollectedType<T>::value> {
 };
 
-// We assume RawPtr<T> is used only for garbage-collected types.
-template<typename T> struct ParamStorageTraits<RawPtr<T> > {
-    typedef WebCore::CrossThreadPersistent<T> StorageType;
-
-    static StorageType wrap(RawPtr<T> value) { return value.get(); }
-    static T* unwrap(const StorageType& value) { return value.get(); }
+template<typename T>
+struct ParamStorageTraits<RawPtr<T> > : public PointerParamStorageTraits<T*, WebCore::IsGarbageCollectedType<T>::value> {
 };
 
 } // namespace WTF
 
 #endif