[oilpan] The Node hierarchy should have correct accept method chains

Source/heap/Handle.h

 /*
  * Copyright (C) 2013 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 744 matching lines @@
         return Result<T>(static_cast<T*>(other.releaseRaw()));
     }
 
     typedef T* (Result::*UnspecifiedBoolType);
     operator UnspecifiedBoolType() const
     {
         // See the comment in operator!().
         return releaseRaw() ? &Result::m_raw : 0;
     }
 
-    // FIXME(oilpan): Make this private.
-    T* releaseRaw() const
-    {
-        T* raw = m_raw;
-        m_raw = 0;
-#ifndef NDEBUG
-        m_doNotAllocate.release();
-#endif
-        return raw;
-    }
-
     // FIXME(oilpan): Remove once TreeShared no longer requires reference counting.
     PassRefPtr<T> passRefPtr() const
     {
         return PassRefPtr<T>(releaseRaw());
     }
 
 private:
     explicit Result(T* raw)
         : m_raw(raw)
 #ifndef NDEBUG
         , m_doNotAllocate()
 #endif
     {
     }
 
+    T* releaseRaw() const
+    {
+        T* raw = m_raw;
+        m_raw = 0;
+#ifndef NDEBUG
+        m_doNotAllocate.release();
+#endif
+        return raw;
+    }
+
     // Mutable to allow raw() to steal the pointer when creating a
     // Handle from the Result.
     mutable T* m_raw;
 
 #ifndef NDEBUG
     mutable NoAllocation m_doNotAllocate;
 #endif
 
     template<typename U> friend class Persistent;
     template<typename U> friend class Handle;
@@ skipping 155 matching lines @@
         return *this;
     }
 
     template<typename U>
     bool operator==(const Handle<U>& other) const
     {
         return other.raw() == raw();
     }
 
     template<typename U>
+    bool operator!=(const Handle<U>& other) const
+    {
+        return other.raw() != raw();
+    }
+
+    template<typename U>
     bool operator==(const Persistent<U>& other) const
     {
         return other.raw() == raw();
     }
 
     template<typename U>
     bool operator==(const Member<U>& other) const
     {
         return other.raw() == raw();
     }
@@ skipping 278 matching lines @@
 
 // PtrHash is the default hash for hash tables with members, but you can use
 // HeapObjectHash<T> instead.
 template<typename T> struct DefaultHash<WebCore::Member<T> > {
     typedef PtrHash<WebCore::Member<T> > Hash;
 };
 
 }
 
 #endif