wtf reformat test

third_party/WebKit/Source/wtf/PassOwnPtr.h

Index: third_party/WebKit/Source/wtf/PassOwnPtr.h
diff --git a/third_party/WebKit/Source/wtf/PassOwnPtr.h b/third_party/WebKit/Source/wtf/PassOwnPtr.h
index ad3190d3b7027559486b9bdf06305a31356f03b3..cfd5386209333dcab8c2566aef040022751ab106 100644
--- a/third_party/WebKit/Source/wtf/PassOwnPtr.h
+++ b/third_party/WebKit/Source/wtf/PassOwnPtr.h
@@ -33,123 +33,148 @@
 
 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 PassOwnPtr {
-    DISALLOW_NEW();
-public:
-    typedef typename std::remove_extent<T>::type ValueType;
-    typedef ValueType* PtrType;
-
-    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));
-
-    ~PassOwnPtr() { OwnedPtrDeleter<T>::deletePtr(m_ptr); }
-
-    PtrType get() const { return m_ptr; }
-
-    PtrType leakPtr() const WARN_UNUSED_RETURN;
-
-    ValueType& operator*() const { ASSERT(m_ptr); return *m_ptr; }
-    PtrType operator->() const { ASSERT(m_ptr); 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; }
-
-    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) {}
-
-    PassOwnPtr& operator=(const PassOwnPtr&) = delete;
-
-    // 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 = delete;
-    template <typename U> bool operator!=(const PassOwnPtr<U>&) const = delete;
-    template <typename U> bool operator==(const OwnPtr<U>&) const = delete;
-    template <typename U> bool operator!=(const OwnPtr<U>&) const = delete;
+template <typename T>
+class OwnPtr;
+template <typename T>
+class PassOwnPtr;
+template <typename T>
+PassOwnPtr<T> adoptPtr(T*);
+template <typename T>
+PassOwnPtr<T[]> adoptArrayPtr(T*);
 
-    mutable PtrType m_ptr;
+template <typename T>
+class PassOwnPtr {
+  DISALLOW_NEW();
+
+ public:
+  typedef typename std::remove_extent<T>::type ValueType;
+  typedef ValueType* PtrType;
+
+  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));
+
+  ~PassOwnPtr() { OwnedPtrDeleter<T>::deletePtr(m_ptr); }
+
+  PtrType get() const { return m_ptr; }
+
+  PtrType leakPtr() const WARN_UNUSED_RETURN;
+
+  ValueType& operator*() const {
+    ASSERT(m_ptr);
+    return *m_ptr;
+  }
+  PtrType operator->() const {
+    ASSERT(m_ptr);
+    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;
+  }
+
+  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) {}
+
+  PassOwnPtr& operator=(const PassOwnPtr&) = delete;
+
+  // 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 = delete;
+  template <typename U>
+  bool operator!=(const PassOwnPtr<U>&) const = delete;
+  template <typename U>
+  bool operator==(const OwnPtr<U>&) const = delete;
+  template <typename U>
+  bool operator!=(const OwnPtr<U>&) const = delete;
+
+  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(!std::is_array<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(!std::is_array<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(!std::is_array<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(!std::is_array<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