Oilpan: add Member<T>(RawPtr<U>) constructor.

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 26 matching lines @@
 #include "wtf/HashFunctions.h"
 #include "wtf/Locker.h"
 #include "wtf/RawPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/TypeTraits.h"
 
 namespace WebCore {
 
 template<typename T> class HeapTerminatedArray;
 
-#define COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, ErrorMessage)                                          \
-    typedef typename WTF::RemoveConst<T>::Type NonConstType;                                          \
-    typedef WTF::IsSubclassOfTemplate<NonConstType, GarbageCollected> GarbageCollectedSubclass;       \
-    typedef WTF::IsSubclass<NonConstType, GarbageCollectedMixin> GarbageCollectedMixinSubclass;       \
-    typedef WTF::IsSubclassOfTemplate3<NonConstType, HeapHashSet> HeapHashSetSubclass;                \
-    typedef WTF::IsSubclassOfTemplate5<NonConstType, HeapHashMap> HeapHashMapSubclass;                \
-    typedef WTF::IsSubclassOfTemplateTypenameSize<NonConstType, HeapVector> HeapVectorSubclass;       \
-    typedef WTF::IsSubclassOfTemplate<NonConstType, HeapTerminatedArray> HeapTerminatedArraySubclass; \
-    COMPILE_ASSERT(GarbageCollectedSubclass::value ||                                                 \
-        GarbageCollectedMixinSubclass::value ||                                                       \
-        HeapHashSetSubclass::value ||                                                                 \
-        HeapHashMapSubclass::value ||                                                                 \
-        HeapVectorSubclass::value ||                                                                  \
-        HeapTerminatedArraySubclass::value,                                                           \
-        ErrorMessage);
+#define COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, ErrorMessage)                                              \
+    do {                                                                                                  \
+        typedef typename WTF::RemoveConst<T>::Type NonConstType;                                          \
+        typedef WTF::IsSubclassOfTemplate<NonConstType, GarbageCollected> GarbageCollectedSubclass;       \
+        typedef WTF::IsSubclass<NonConstType, GarbageCollectedMixin> GarbageCollectedMixinSubclass;       \
+        typedef WTF::IsSubclassOfTemplate3<NonConstType, HeapHashSet> HeapHashSetSubclass;                \
+        typedef WTF::IsSubclassOfTemplate5<NonConstType, HeapHashMap> HeapHashMapSubclass;                \
+        typedef WTF::IsSubclassOfTemplateTypenameSize<NonConstType, HeapVector> HeapVectorSubclass;       \
+        typedef WTF::IsSubclassOfTemplate<NonConstType, HeapTerminatedArray> HeapTerminatedArraySubclass; \
+        COMPILE_ASSERT(GarbageCollectedSubclass::value ||                                                 \
+            GarbageCollectedMixinSubclass::value ||                                                       \
+            HeapHashSetSubclass::value ||                                                                 \
+            HeapHashMapSubclass::value ||                                                                 \
+            HeapVectorSubclass::value ||                                                                  \
+            HeapTerminatedArraySubclass::value,                                                           \
+            ErrorMessage);                                                                                \
+    } while (0)
 
 template<typename T> class Member;
 
 class PersistentNode {
 public:
     explicit PersistentNode(TraceCallback trace)
         : m_trace(trace)
     {
     }
 
@@ skipping 369 matching lines @@
     Member(T* raw) : m_raw(raw)
     {
         COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInMember);
     }
 
     explicit Member(T& raw) : m_raw(&raw)
     {
         COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInMember);
     }
 
+    template<typename U>
+    Member(const RawPtr<U>& other) : m_raw(other.get())
+    {
+        COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInMember);
+        COMPILE_ASSERT_IS_GARBAGE_COLLECTED(U, NonGarbageCollectedObjectInMember);
+    }
+
     Member(WTF::HashTableDeletedValueType) : m_raw(reinterpret_cast<T*>(-1))
     {
         COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInMember);
     }
 
     bool isHashTableDeletedValue() const { return m_raw == reinterpret_cast<T*>(-1); }
 
     template<typename U>
     Member(const Persistent<U>& other) : m_raw(other) { }
 
@@ skipping 509 matching lines @@
 };
 
 template<typename T, typename U>
 struct NeedsTracing<HashMap<T, U> > {
     static const bool value = false;
 };
 
 } // namespace WTF
 
 #endif