Reland: WTF: Simplify 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 64 matching lines @@
     template <typename U> PassRefPtr(RefPtr<U>&&, EnsurePtrConvertibleArgDecl(U, T));
 
     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; }
-
-    // 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; }
+    explicit operator bool() const { return !!m_ptr; }

[Nico, 2016/06/23 16:02:06]

no !! pls

[jbroman, 2016/06/23 16:05:44]

Windows warns (with our flags, errors) about "return m_ptr;"; that's the reason
the previous CL was reverted.
Which pattern would you prefer? I could do "return m_ptr != nullptr;", if that's
better, but this seemed reasonably natural, comparing to the operator!
implementation above.

 
     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 110 matching lines @@
     return p.get();
 }
 
 } // namespace WTF
 
 using WTF::PassRefPtr;
 using WTF::adoptRef;
 using WTF::static_pointer_cast;
 
 #endif // WTF_PassRefPtr_h