Reland: WTF: Implement explicit RefPtr::operator bool.

third_party/WebKit/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
@@ skipping 65 matching lines @@
 
     T* get() const { return m_ptr; }
 
     T* leakRef() const WARN_UNUSED_RETURN;
 
     T& operator*() const { return *m_ptr; }
     T* operator->() const { return m_ptr; }
 
     bool operator!() const { return !m_ptr; }
 
-    // This conversion operator allows implicit conversion to bool but not to
-    // other integer types.
-    typedef T* (PassRefPtr::*UnspecifiedBoolType);
-    operator UnspecifiedBoolType() const { return m_ptr ? &PassRefPtr::m_ptr : 0; }
+    // TODO(jbroman): Simplifying this in the obvious way causes a massive
+    // regression in a perf test on ARM. http://crbug.com/607208
+    explicit operator bool() const { return m_ptr ? &PassRefPtr::m_ptr : 0; }
 
     friend PassRefPtr adoptRef<T>(T*);
 
 private:
     enum AdoptRefTag { AdoptRef };
     PassRefPtr(T* ptr, AdoptRefTag) : m_ptr(ptr) {}
 
     PassRefPtr& operator=(const PassRefPtr&)
     {
         static_assert(!sizeof(T*), "PassRefPtr should never be assigned to");
@@ skipping 42 matching lines @@
 template <typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, U* b)
 {
     return a.get() == b;
 }
 
 template <typename T, typename U> inline bool operator==(T* a, const PassRefPtr<U>& b)
 {
     return a == b.get();
 }
 
+template <typename T> inline bool operator==(const PassRefPtr<T>& a, std::nullptr_t)
+{
+    return !a.get();
+}
+
+template <typename T> inline bool operator==(std::nullptr_t, const PassRefPtr<T>& b)
+{
+    return !b.get();
+}
+
 template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, const PassRefPtr<U>& b)
 {
     return a.get() != b.get();
 }
 
 template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, const RefPtr<U>& b)
 {
     return a.get() != b.get();
 }
 
 template <typename T, typename U> inline bool operator!=(const RefPtr<T>& a, const PassRefPtr<U>& b)
 {
     return a.get() != b.get();
 }
 
 template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, U* b)
 {
     return a.get() != b;
 }
 
 template <typename T, typename U> inline bool operator!=(T* a, const PassRefPtr<U>& b)
 {
     return a != b.get();
 }
 
+template <typename T> inline bool operator!=(const PassRefPtr<T>& a, std::nullptr_t)
+{
+    return a.get();
+}
+
+template <typename T> inline bool operator!=(std::nullptr_t, const PassRefPtr<T>& b)
+{
+    return b.get();
+}
+
 template <typename T> PassRefPtr<T> adoptRef(T* p)
 {
     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