Make ContentDecryptionModuleResult cross-thread destructible.

public/platform/WebPrivatePtr.h

 /*
  * Copyright (C) 2010 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 81 matching lines @@
     void release()
     {
         WTF::derefIfNotNull(m_ptr);
         m_ptr = 0;
     }
 
 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:
     void assign(const RawPtr<T>& val)
     {
         if (!val) {
             release();
             return;
         }
 
         if (!m_handle)
-            m_handle = new Persistent<T>();
+            m_handle = new (typename WebPrivatePtrPersistentStorageType<T>::type)();
 
         (*m_handle) = val;
     }
 
     void assign(T* ptr) { assign(RawPtr<T>(ptr)); }
     template<typename U> void assign(const RawPtr<U>& val) { assign(RawPtr<T>(val)); }
 
     void assign(const PtrStorageImpl& other) { assign(other.get()); }
 
     void moveFrom(PtrStorageImpl& other)
     {
         release();
         m_handle = other.m_handle;
         other.m_handle = 0;
     }
 
     T* get() const { return m_handle ? m_handle->get() : 0; }
 
     void release()
     {
         delete m_handle;
         m_handle = 0;
     }
 
 private:
-    Persistent<T>* m_handle;
+    typename WebPrivatePtrPersistentStorageType<T>::type* m_handle;
 };
 
 template<typename T>
 class PtrStorageImpl<T, RefCountedGarbageCollectedLifetime> : public PtrStorageImpl<T, GarbageCollectedLifetime> {
 public:
     void assign(const PassRefPtrWillBeRawPtr<T>& val) { PtrStorageImpl<T, GarbageCollectedLifetime>::assign(val.get()); }
 
     void assign(const PtrStorageImpl& other) { PtrStorageImpl<T, GarbageCollectedLifetime>::assign(other.get()); }
 };
 
@@ skipping 131 matching lines @@
     // Disable the copy constructor; classes that contain a WebPrivatePtr
     // should implement their copy constructor using assign().
     WebPrivatePtr(const WebPrivatePtr<T>&);
 
     void* m_storage;
 };
 
 } // namespace blink
 
 #endif