wtf reformat test

third_party/WebKit/Source/wtf/Optional.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef Optional_h
 #define Optional_h
 
 #include "wtf/Alignment.h"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
@@ skipping 15 matching lines @@
 //   Optional<DrawingRecorder> recorder;
 //   if (shouldDraw)
 //       recorder.emplace(constructor, args, here);
 //   // recorder destroyed at end of scope
 //
 // Note in particular that unlike a pointer, though, dereferencing a const
 // optional yields a const reference.
 
 template <typename T>
 class Optional final {
-    DISALLOW_NEW();
-    WTF_MAKE_NONCOPYABLE(Optional);
-public:
-    Optional() : m_ptr(nullptr) { }
-    ~Optional()
-    {
-        if (m_ptr)
-            m_ptr->~T();
-    }
+  DISALLOW_NEW();
+  WTF_MAKE_NONCOPYABLE(Optional);
 
-    typedef T* Optional::*UnspecifiedBoolType;
-    operator UnspecifiedBoolType() const { return m_ptr ? &Optional::m_ptr : nullptr; }
+ public:
+  Optional() : m_ptr(nullptr) {}
+  ~Optional() {
+    if (m_ptr)
+      m_ptr->~T();
+  }
 
-    T& operator*() { ASSERT_WITH_SECURITY_IMPLICATION(m_ptr); return *m_ptr; }
-    const T& operator*() const { ASSERT_WITH_SECURITY_IMPLICATION(m_ptr); return *m_ptr; }
-    T* operator->() { ASSERT_WITH_SECURITY_IMPLICATION(m_ptr); return m_ptr; }
-    const T* operator->() const { ASSERT_WITH_SECURITY_IMPLICATION(m_ptr); return m_ptr; }
+  typedef T* Optional::*UnspecifiedBoolType;
+  operator UnspecifiedBoolType() const {
+    return m_ptr ? &Optional::m_ptr : nullptr;
+  }
 
-    template <typename... Args>
-    void emplace(Args&&... args)
-    {
-        RELEASE_ASSERT(!m_ptr);
-        m_ptr = reinterpret_cast_ptr<T*>(&m_storage.buffer);
-        new (m_ptr) T(std::forward<Args>(args)...);
-    }
+  T& operator*() {
+    ASSERT_WITH_SECURITY_IMPLICATION(m_ptr);
+    return *m_ptr;
+  }
+  const T& operator*() const {
+    ASSERT_WITH_SECURITY_IMPLICATION(m_ptr);
+    return *m_ptr;
+  }
+  T* operator->() {
+    ASSERT_WITH_SECURITY_IMPLICATION(m_ptr);
+    return m_ptr;
+  }
+  const T* operator->() const {
+    ASSERT_WITH_SECURITY_IMPLICATION(m_ptr);
+    return m_ptr;
+  }
 
-private:
-    T* m_ptr;
-    AlignedBuffer<sizeof(T), WTF_ALIGN_OF(T)> m_storage;
+  template <typename... Args>
+  void emplace(Args&&... args) {
+    RELEASE_ASSERT(!m_ptr);
+    m_ptr = reinterpret_cast_ptr<T*>(&m_storage.buffer);
+    new (m_ptr) T(std::forward<Args>(args)...);
+  }
+
+ private:
+  T* m_ptr;
+  AlignedBuffer<sizeof(T), WTF_ALIGN_OF(T)> m_storage;
 };
 
-} // namespace WTF
+}  // namespace WTF
 
 using WTF::Optional;
 
-#endif // Optional_h
+#endif  // Optional_h