Oilpan: Forbid adoptRef(X*) where X is RefCountedGarbageCollected

Source/wtf/PassRefPtr.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef WTF_PassRefPtr_h
 #define WTF_PassRefPtr_h
 
 #include "wtf/Assertions.h"
 #include "wtf/NullPtr.h"
 #include "wtf/RawPtr.h"
 #include "wtf/TypeTraits.h"
 
+namespace blink {
+template<typename T> class RefCountedGarbageCollected;
+}
+
 namespace WTF {
 
     template<typename T> class RefPtr;
     template<typename T> class PassRefPtr;
     template<typename T> PassRefPtr<T> adoptRef(T*);
 
     inline void adopted(const void*) { }
 
     // requireAdoption() is not overloaded for WTF::RefCounted, which has a
     // built-in assumption that adoption is required. requireAdoption() is
@@ skipping 139 matching lines @@
         return a.get() != b.get();
     }
 
     template<typename T, typename U> inline bool operator!=(const RawPtr<T>& a, const PassRefPtr<U>& b)
     {
         return a.get() != b.get();
     }
 
     template<typename T> PassRefPtr<T> adoptRef(T* p)
     {
+        static const bool notRefCountedGarbageCollected = !WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<T>::Type, blink::RefCountedGarbageCollected>::value;
+        COMPILE_ASSERT(notRefCountedGarbageCollected, adoptRefIsNotAllowedForRefCountedGarbageCollected);

[Mikhail, 2014/10/14 11:05:10]

wouldn't smth like 

template<T> void adoptRef(const RefCountedGarbageCollected<T>*)
{
  static_assert(false, ...);
}

be better? 
(btw this can be put together with the RefCountedGarbageCollected declaration)

[tkent, 2014/11/10 06:06:59]

Mikhail's idea looks better.
This patch has a layering violation.  WTF should have no knowledge of
blink::RefCountedGarbageCollected.

[haraken, 2014/11/10 06:41:56]

Hmm, it looks like I need your help.

When I add:

  template<typename T>
  PassRefPtr<T> adoptRef(RefCountedGarbageCollected<T>*)
  {
    COMPILE_ASSERT(false, ...);
  }

to Handle.h, I always hit the assert when including Handle.h, like this:

In file included from
../../third_party/WebKit/Source/web/painting/ContinuousPainter.cpp:33:
In file included from
../../third_party/WebKit/Source/platform/graphics/GraphicsLayer.h:38:
In file included from
../../third_party/WebKit/Source/platform/graphics/GraphicsLayerDebugInfo.h:39:
In file included from
../../third_party/WebKit/public/platform/WebGraphicsLayerDebugInfo.h:34:
In file included from ../../third_party/WebKit/public/platform/WebString.h:35:
In file included from
../../third_party/WebKit/public/platform/WebPrivatePtr.h:37:
../../third_party/WebKit/Source/platform/heap/Handle.h:967:5: error:
static_assert failed "adoptRefIsNotAllowedForRefCountedGarbageCollected"
    COMPILE_ASSERT(false, adoptRefIsNotAllowedForRefCountedGarbageCollected);
    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

How can I avoid hitting the assert?

[Mikhail, 2014/11/10 10:10:57]

yeah, sorry this trick does not work with functions, it's compiled even if it's
not used :( The easy solution which I've on top of my head is

template<typename T>
PassRefPtr<T> adoptRef(RefCountedGarbageCollected<T>*) = delete;

         adopted(p);
         return PassRefPtr<T>(p, PassRefPtr<T>::AdoptRef);
     }
 
     template<typename T, typename U> inline PassRefPtr<T> static_pointer_cast(const PassRefPtr<U>& p)
     {
         return adoptRef(static_cast<T*>(p.leakRef()));
     }
 
     template<typename T> inline T* getPtr(const PassRefPtr<T>& p)
     {
         return p.get();
     }
 
 } // namespace WTF
 
 using WTF::PassRefPtr;
 using WTF::adoptRef;
 using WTF::static_pointer_cast;
 
 #endif // WTF_PassRefPtr_h