Apply clang-format with Chromium-style without column limit.

third_party/WebKit/Source/wtf/PassOwnPtr.h

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 13 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WTF_PassOwnPtr_h
 #define WTF_PassOwnPtr_h
 
 #include "wtf/OwnPtrCommon.h"
 
 namespace WTF {
 
-template <typename T> class OwnPtr;
-template <typename T> class PassOwnPtr;
-template <typename T> PassOwnPtr<T> adoptPtr(T*);
-template <typename T> PassOwnPtr<T[]> adoptArrayPtr(T*);
+template <typename T>
+class OwnPtr;
+template <typename T>
+class PassOwnPtr;
+template <typename T>
+PassOwnPtr<T> adoptPtr(T*);
+template <typename T>
+PassOwnPtr<T[]> adoptArrayPtr(T*);
 
-template <typename T> class PassOwnPtr {
-public:
-    typedef typename RemoveExtent<T>::Type ValueType;
-    typedef ValueType* PtrType;
+template <typename T>
+class PassOwnPtr {
+ public:
+  typedef typename RemoveExtent<T>::Type ValueType;
+  typedef ValueType* PtrType;
 
-    PassOwnPtr() : m_ptr(nullptr) {}
-    PassOwnPtr(std::nullptr_t) : m_ptr(nullptr) {}
+  PassOwnPtr()
+      : m_ptr(nullptr) {}
+  PassOwnPtr(std::nullptr_t)
+      : m_ptr(nullptr) {}
 
-    // It somewhat breaks the type system to allow transfer of ownership out of
-    // a const PassOwnPtr. However, it makes it much easier to work with
-    // PassOwnPtr temporaries, and we don't have a need to use real const
-    // PassOwnPtrs anyway.
-    PassOwnPtr(const PassOwnPtr& o) : m_ptr(o.leakPtr()) {}
-    template <typename U> PassOwnPtr(const PassOwnPtr<U>&, EnsurePtrConvertibleArgDecl(U, T));
+  // It somewhat breaks the type system to allow transfer of ownership out of
+  // a const PassOwnPtr. However, it makes it much easier to work with
+  // PassOwnPtr temporaries, and we don't have a need to use real const
+  // PassOwnPtrs anyway.
+  PassOwnPtr(const PassOwnPtr& o)
+      : m_ptr(o.leakPtr()) {}
+  template <typename U>
+  PassOwnPtr(const PassOwnPtr<U>&, EnsurePtrConvertibleArgDecl(U, T));
 
-    ~PassOwnPtr() { OwnedPtrDeleter<T>::deletePtr(m_ptr); }
+  ~PassOwnPtr() { OwnedPtrDeleter<T>::deletePtr(m_ptr); }
 
-    PtrType get() const { return m_ptr; }
+  PtrType get() const { return m_ptr; }
 
-    PtrType leakPtr() const WARN_UNUSED_RETURN;
+  PtrType leakPtr() const WARN_UNUSED_RETURN;
 
-    ValueType& operator*() const { ASSERT(m_ptr); return *m_ptr; }
-    PtrType operator->() const { ASSERT(m_ptr); return m_ptr; }
+  ValueType& operator*() const {
+    ASSERT(m_ptr);
+    return *m_ptr;
+  }
+  PtrType operator->() const {
+    ASSERT(m_ptr);
+    return m_ptr;
+  }
 
-    bool 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 PtrType PassOwnPtr::*UnspecifiedBoolType;
-    operator UnspecifiedBoolType() const { return m_ptr ? &PassOwnPtr::m_ptr : 0; }
+  // This conversion operator allows implicit conversion to bool but not to
+  // other integer types.
+  typedef PtrType PassOwnPtr::*UnspecifiedBoolType;
+  operator UnspecifiedBoolType() const { return m_ptr ? &PassOwnPtr::m_ptr : 0; }
 
-    template <typename U> friend PassOwnPtr<U> adoptPtr(U*);
-    template <typename U> friend PassOwnPtr<U[]> adoptArrayPtr(U*);
-    template <typename U> friend class OwnPtr;
+  template <typename U>
+  friend PassOwnPtr<U> adoptPtr(U*);
+  template <typename U>
+  friend PassOwnPtr<U[]> adoptArrayPtr(U*);
+  template <typename U>
+  friend class OwnPtr;
 
-private:
-    explicit PassOwnPtr(PtrType ptr) : m_ptr(ptr) {}
+ private:
+  explicit PassOwnPtr(PtrType ptr)
+      : m_ptr(ptr) {}
 
-    PassOwnPtr& operator=(const PassOwnPtr&)
-    {
-        static_assert(!sizeof(T*), "PassOwnPtr should never be assigned to");
-        return *this;
-    }
+  PassOwnPtr& operator=(const PassOwnPtr&) {
+    static_assert(!sizeof(T*), "PassOwnPtr should never be assigned to");
+    return *this;
+  }
 
-    // We should never have two OwnPtrs for the same underlying object
-    // (otherwise we'll get double-destruction), so these equality operators
-    // should never be needed.
-    template <typename U> bool operator==(const PassOwnPtr<U>&) const
-    {
-        static_assert(!sizeof(U*), "OwnPtrs should never be equal");
-        return false;
-    }
-    template <typename U> bool operator!=(const PassOwnPtr<U>&) const
-    {
-        static_assert(!sizeof(U*), "OwnPtrs should never be equal");
-        return false;
-    }
-    template <typename U> bool operator==(const OwnPtr<U>&) const
-    {
-        static_assert(!sizeof(U*), "OwnPtrs should never be equal");
-        return false;
-    }
-    template <typename U> bool operator!=(const OwnPtr<U>&) const
-    {
-        static_assert(!sizeof(U*), "OwnPtrs should never be equal");
-        return false;
-    }
+  // We should never have two OwnPtrs for the same underlying object
+  // (otherwise we'll get double-destruction), so these equality operators
+  // should never be needed.
+  template <typename U>
+  bool operator==(const PassOwnPtr<U>&) const {
+    static_assert(!sizeof(U*), "OwnPtrs should never be equal");
+    return false;
+  }
+  template <typename U>
+  bool operator!=(const PassOwnPtr<U>&) const {
+    static_assert(!sizeof(U*), "OwnPtrs should never be equal");
+    return false;
+  }
+  template <typename U>
+  bool operator==(const OwnPtr<U>&) const {
+    static_assert(!sizeof(U*), "OwnPtrs should never be equal");
+    return false;
+  }
+  template <typename U>
+  bool operator!=(const OwnPtr<U>&) const {
+    static_assert(!sizeof(U*), "OwnPtrs should never be equal");
+    return false;
+  }
 
-    mutable PtrType m_ptr;
+  mutable PtrType m_ptr;
 };
 
 template <typename T>
-template <typename U> inline PassOwnPtr<T>::PassOwnPtr(const PassOwnPtr<U>& o, EnsurePtrConvertibleArgDefn(U, T))
-    : m_ptr(o.leakPtr())
-{
-    static_assert(!IsArray<T>::value, "pointers to array must never be converted");
+template <typename U>
+inline PassOwnPtr<T>::PassOwnPtr(const PassOwnPtr<U>& o, EnsurePtrConvertibleArgDefn(U, T))
+    : m_ptr(o.leakPtr()) {
+  static_assert(!IsArray<T>::value, "pointers to array must never be converted");
 }
 
-template <typename T> inline typename PassOwnPtr<T>::PtrType PassOwnPtr<T>::leakPtr() const
-{
-    PtrType ptr = m_ptr;
-    m_ptr = nullptr;
-    return ptr;
+template <typename T>
+inline typename PassOwnPtr<T>::PtrType PassOwnPtr<T>::leakPtr() const {
+  PtrType ptr = m_ptr;
+  m_ptr = nullptr;
+  return ptr;
 }
 
-template <typename T, typename U> inline bool operator==(const PassOwnPtr<T>& a, U* b)
-{
-    return a.get() == b;
+template <typename T, typename U>
+inline bool operator==(const PassOwnPtr<T>& a, U* b) {
+  return a.get() == b;
 }
 
-template <typename T, typename U> inline bool operator==(T* a, const PassOwnPtr<U>& b)
-{
-    return a == b.get();
+template <typename T, typename U>
+inline bool operator==(T* a, const PassOwnPtr<U>& b) {
+  return a == b.get();
 }
 
-template <typename T, typename U> inline bool operator!=(const PassOwnPtr<T>& a, U* b)
-{
-    return a.get() != b;
+template <typename T, typename U>
+inline bool operator!=(const PassOwnPtr<T>& a, U* b) {
+  return a.get() != b;
 }
 
-template <typename T, typename U> inline bool operator!=(T* a, const PassOwnPtr<U>& b)
-{
-    return a != b.get();
+template <typename T, typename U>
+inline bool operator!=(T* a, const PassOwnPtr<U>& b) {
+  return a != b.get();
 }
 
-template <typename T> inline PassOwnPtr<T> adoptPtr(T* ptr)
-{
-    return PassOwnPtr<T>(ptr);
+template <typename T>
+inline PassOwnPtr<T> adoptPtr(T* ptr) {
+  return PassOwnPtr<T>(ptr);
 }
 
-template <typename T> inline PassOwnPtr<T[]> adoptArrayPtr(T* ptr)
-{
-    return PassOwnPtr<T[]>(ptr);
+template <typename T>
+inline PassOwnPtr<T[]> adoptArrayPtr(T* ptr) {
+  return PassOwnPtr<T[]>(ptr);
 }
 
-template <typename T, typename U> inline PassOwnPtr<T> static_pointer_cast(const PassOwnPtr<U>& p)
-{
-    static_assert(!IsArray<T>::value, "pointers to array must never be converted");
-    return adoptPtr(static_cast<T*>(p.leakPtr()));
+template <typename T, typename U>
+inline PassOwnPtr<T> static_pointer_cast(const PassOwnPtr<U>& p) {
+  static_assert(!IsArray<T>::value, "pointers to array must never be converted");
+  return adoptPtr(static_cast<T*>(p.leakPtr()));
 }
 
-template <typename T> inline T* getPtr(const PassOwnPtr<T>& p)
-{
-    return p.get();
+template <typename T>
+inline T* getPtr(const PassOwnPtr<T>& p) {
+  return p.get();
 }
 
-} // namespace WTF
+}  // namespace WTF
 
 using WTF::PassOwnPtr;
 using WTF::adoptPtr;
 using WTF::adoptArrayPtr;
 using WTF::static_pointer_cast;
 
-#endif // WTF_PassOwnPtr_h
+#endif  // WTF_PassOwnPtr_h