Oilpan: cleanup based on review comments after removal of TreeShared.

Source/wtf/RefPtr.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2013 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
@@ skipping 145 matching lines @@
     template<typename T, typename U> inline bool operator==(const RefPtr<T>& a, U* b)
     {
         return a.get() == b;
     }
 
     template<typename T, typename U> inline bool operator==(T* a, const RefPtr<U>& b)
     {
         return a == b.get();
     }
 
+    template<typename T, typename U> inline bool operator==(const RefPtr<T>& a, const U& b)

[Mikhail, 2014/05/07 12:34:28]

I would not like us to implicitly compare RefPtr with any other object, this
might cause to various bugs (e.g. how would "if (refPtr == 0)" or "if (refPtr ==
nullptr)" work now?)

[Mads Ager (chromium), 2014/05/07 12:40:09]

It will not (compile-time error because of ambiguity) and you shouldn't do it
according to the code style anyway. You should do "if (!refPtr)".

There operators were explicitly added in Node.h for (Pass)RefPtr<Node> which
seems strange and therefore I am putting it down here where it belongs if we
want it.

I would honestly prefer that people wrote the explicit '&' when using a
reference:

void foo(Document& doc) {
   if (m_refPtr == &doc)
       doStuff();
}

However, that is not the approach currently taken in the Blink code base.
Instead these comparison operators have been defined for the rather large Node
subset of types.

[tkent, 2014/05/07 14:11:05]

I also have a concern about adding the generic version of operator==.
Node is exceptional because
 - WTF_MAKE_NONCOPYABLE
 - Node-comparison is always address-comparison.

We might have a RefCounted class of which operator== should compare its content,
not address.  I don't know if we have such class at this moment.

+    {
+        return a.get() == &b;
+    }
+
+    template<typename T, typename U> inline bool operator==(const T& a, const RefPtr<U>& b)
+    {
+        return &a == b.get();
+    }
+
     template<typename T, typename U> inline bool operator!=(const RefPtr<T>& a, const RefPtr<U>& b)
     {
         return a.get() != b.get();
     }
 
     template<typename T, typename U> inline bool operator!=(const RefPtr<T>& a, U* b)
     {
         return a.get() != b;
     }
 
     template<typename T, typename U> inline bool operator!=(T* a, const RefPtr<U>& b)
     {
         return a != b.get();
     }
 
+    template<typename T, typename U> inline bool operator!=(const RefPtr<T>& a, const U& b)
+    {
+        return a.get() != &b;
+    }
+
+    template<typename T, typename U> inline bool operator!=(const T& a, const RefPtr<U>& b)
+    {
+        return &a != b.get();
+    }
+
     template<typename T, typename U> inline RefPtr<T> static_pointer_cast(const RefPtr<U>& p)
     {
         return RefPtr<T>(static_cast<T*>(p.get()));
     }
 
     template<typename T> inline T* getPtr(const RefPtr<T>& p)
     {
         return p.get();
     }
 
     template<typename T> class RefPtrValuePeeker {
     public:
         ALWAYS_INLINE RefPtrValuePeeker(T* p): m_ptr(p) { }
         ALWAYS_INLINE RefPtrValuePeeker(std::nullptr_t): m_ptr(0) { }
         template<typename U> RefPtrValuePeeker(const RefPtr<U>& p): m_ptr(p.get()) { }
         template<typename U> RefPtrValuePeeker(const PassRefPtr<U>& p): m_ptr(p.get()) { }
 
         ALWAYS_INLINE operator T*() const { return m_ptr; }
     private:
         T* m_ptr;
     };
 
 } // namespace WTF
 
 using WTF::RefPtr;
 using WTF::static_pointer_cast;
 
 #endif // WTF_RefPtr_h