Oilpan: add explicit Persistent<T>(T&) and Member<T>(T&) constructors.

Source/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 198 matching lines @@
 private:
     PersistentAnchor() : PersistentNode(TraceMethodDelegate<PersistentAnchor, &PersistentAnchor::trace>::trampoline)
     {
         m_next = this;
         m_prev = this;
     }
 
     friend class ThreadState;
 };
 
+#ifndef NDEBUG
+    // For global persistent handles we cannot check that the
+    // pointer is in the heap because that would involve
+    // inspecting the heap of running threads.
+#define ASSERT_IS_VALID_PERSISTENT_POINTER(pointer) \
+    bool isGlobalPersistent = WTF::IsSubclass<RootsAccessor, GlobalPersistents>::value; \
+    ASSERT(!pointer || isGlobalPersistent || ThreadStateFor<ThreadingTrait<T>::Affinity>::state()->contains(pointer))
+#else
+#define ASSERT_IS_VALID_PERSISTENT_POINTER(raw)
+#endif
+
 template<typename T>
 class CrossThreadPersistent;
 
 // Persistent handles are used to store pointers into the
 // managed heap. As long as the Persistent handle is alive
 // the GC will keep the object pointed to alive. Persistent
 // handles can be stored in objects and they are not scoped.
 // Persistent handles must not be used to contain pointers
 // between objects that are in the managed heap. They are only
 // meant to point to managed heap objects from variables/members
@@ skipping 15 matching lines @@
     }
 
     Persistent(std::nullptr_t) : m_raw(0)
     {
         COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInPersistent);
     }
 
     Persistent(T* raw) : m_raw(raw)
     {
         COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInPersistent);
-#ifndef NDEBUG
-        // For global persistent handles we cannot check that the
-        // pointer is in the heap because that would involve
-        // inspecting the heap of running threads.
-        bool isGlobalPersistent = WTF::IsSubclass<RootsAccessor, GlobalPersistents>::value;
-        ASSERT(!raw || isGlobalPersistent || ThreadStateFor<ThreadingTrait<T>::Affinity>::state()->contains(raw));
-#endif
+        ASSERT_IS_VALID_PERSISTENT_POINTER(m_raw);
+    }
+
+    explicit Persistent(T& raw) : m_raw(&raw)
+    {
+        COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInPersistent);
+        ASSERT_IS_VALID_PERSISTENT_POINTER(m_raw);
     }
 
     Persistent(const Persistent& other) : m_raw(other)
     {
         COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInPersistent);
     }
 
     template<typename U>
     Persistent(const Persistent<U, RootsAccessor>& other) : m_raw(other) { }
 
@@ skipping 75 matching lines @@
     }
 
     T* get() const { return m_raw; }
 
 private:
     T* m_raw;
 
     friend class CrossThreadPersistent<T>;
 };
 
+#undef ASSERT_IS_VALID_PERSISTENT_POINTER
+
 // Unlike Persistent, we can destruct a CrossThreadPersistent in a thread
 // different from the construction thread.
 template<typename T>
 class CrossThreadPersistent : public Persistent<T, GlobalPersistents> {
     WTF_DISALLOW_CONSTRUCTION_FROM_ZERO(CrossThreadPersistent);
     WTF_DISALLOW_ZERO_ASSIGNMENT(CrossThreadPersistent);
 public:
     CrossThreadPersistent(T* raw) : Persistent<T, GlobalPersistents>(raw) { }
 
     using Persistent<T, GlobalPersistents>::operator=;
@@ skipping 59 matching lines @@
     Member(std::nullptr_t) : m_raw(0)
     {
         COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInMember);
     }
 
     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);

[haraken, 2014/04/02 07:49:41]

Can we implement ASSERT_IS_VALID_MEMBER_POINTER as well?

[sof, 2014/04/02 08:05:50]

Catching out cross-heap references would be useful.

[haraken, 2014/04/02 08:09:29]

Oh, sorry. Cross-heap references are allowed, so we cannot add the ASSERT.

If we want to add some ASSERT, we need to check if the pointer is in either of
the thread heaps. However, we cannot check that without stopping all threads.
Thus we cannot add the ASSERT.

[sof, 2014/04/02 08:12:54]

Interesting, what code relies on creating such cross references?

[haraken, 2014/04/02 08:15:41]

I think some classes in webdatabase/ are using cross-thread Members.

tkent-san: Can you point out any example?

[Mads Ager (chromium), 2014/04/02 08:22:04]

That is correct, we have cross thread pointers in the webdatabase code. When I
added these compile-time assert I initially did have the contains check here but
the check that we really want cannot be done because it needs to check that the
pointer is in *some* oilpan heap - not necessarily for this thread.

+    }
+
     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 496 matching lines @@
 };
 
 template<typename T, typename U>
 struct NeedsTracing<HashMap<T, U> > {
     static const bool value = false;
 };
 
 } // namespace WTF
 
 #endif