Make ContentDecryptionModuleResult cross-thread destructible.

public/platform/WebPrivatePtr.h

Index: public/platform/WebPrivatePtr.h
diff --git a/public/platform/WebPrivatePtr.h b/public/platform/WebPrivatePtr.h
index f62961f062b7e81375a0ff153d9aa1659edc8968..b7763cf9ce495a4ecbf0c0bde307bb783af3deda 100644
--- a/public/platform/WebPrivatePtr.h
+++ b/public/platform/WebPrivatePtr.h
@@ -99,6 +99,32 @@ private:
     T* m_ptr;
 };
 
+template <typename T>
+struct WebPrivatePtrPersistentIsCrossThreadAccessible {
+private:
+    using YesType = char;
+    struct NoType {
+        char padding[8];
+    };
+
+    template <typename U> static YesType checkMarker(typename U::IsCrossThreadAccessibleMarker*);
+    template <typename U> static NoType checkMarker(...);
+public:
+    static const bool value = sizeof(checkMarker<T>(nullptr)) == sizeof(YesType);
+};
+
+template <typename T, bool = WebPrivatePtrPersistentIsCrossThreadAccessible<T>::value>
+struct WebPrivatePtrPersistentStorageType {
+public:
+    using type = Persistent<T>;
+};
+
+template <typename T>
+struct WebPrivatePtrPersistentStorageType<T, true> {
+public:
+    using type = CrossThreadPersistent<T>;

[haraken, 2015/07/23 01:41:41]

How about making CrossThreadPersistent by default? It seems that we're hitting
this issue in multiple places.

My long term plan is:

- Split Oilpan's heap (which is currently shared by all Blink threads) to
per-thread heaps.

- Use CrossThreadPersistent to point to an object in a heap of another thread.
This includes not only a CrossThreadPersistent from an oilpaned thread to
another oilpaned thread but also a CrossThreadPersistent from an non-oilpaned
thread to another oilpaned thread.

To make it workable, we need to make CrossThreadPersistent more thread-safe;
specifically:

(a) Acquire a global lock when the CrossThreadPersistent is created &
destructed.

(b) Acquire a gc lock when the CrossThreadPersistent is used (to avoid other
threads from mutating objects in a heap of another thread that is performing a
GC).

(a) is already implemented. (b) is not yet implemented.

This implies the following fact about the safety of the CrossThreadPersistent in
WebPrivatePtr:

- It is safe to create & destruct the WebPrivatePtr in different threads. The
different thread can be a non-oilpaned thread.

- It is unsafe to use the WebPrivatePtr in a non-oilpaned thread (because (b) is
not yet implemented).

I'm assuming that the above two facts hold in the current code base, but is my
understanding correct? (It would be worth having an assert to verify that a
CrossThreadPersistent is not used by a non-oilpaned thread.)

+};
+
 template<typename T>
 class PtrStorageImpl<T, GarbageCollectedLifetime> {
 public:
@@ -110,7 +136,7 @@ public:
         }
 
         if (!m_handle)
-            m_handle = new Persistent<T>();
+            m_handle = new (typename WebPrivatePtrPersistentStorageType<T>::type)();
 
         (*m_handle) = val;
     }
@@ -136,7 +162,7 @@ public:
     }
 
 private:
-    Persistent<T>* m_handle;
+    typename WebPrivatePtrPersistentStorageType<T>::type* m_handle;
 };
 
 template<typename T>