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

Source/wtf/RefPtr.h

Index: Source/wtf/RefPtr.h
diff --git a/Source/wtf/RefPtr.h b/Source/wtf/RefPtr.h
index f640a7713070a8d5afe9dfd7513025056ce8cba7..e8e9940e28ac52e9735573e5bb938c7378d9e739 100644
--- a/Source/wtf/RefPtr.h
+++ b/Source/wtf/RefPtr.h
@@ -163,6 +163,16 @@ namespace WTF {
         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();
@@ -178,6 +188,16 @@ namespace WTF {
         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()));