wtf reformat test

third_party/WebKit/Source/wtf/RefCounted.h

Index: third_party/WebKit/Source/wtf/RefCounted.h
diff --git a/third_party/WebKit/Source/wtf/RefCounted.h b/third_party/WebKit/Source/wtf/RefCounted.h
index 247962c3d246f2e23c1be4a81a35d380f22d5698..e82b24fe83a92848291e1aa961d44cc05ceda5d6 100644
--- a/third_party/WebKit/Source/wtf/RefCounted.h
+++ b/third_party/WebKit/Source/wtf/RefCounted.h
@@ -40,162 +40,146 @@ namespace WTF {
 // The RefCounted class inherits from it reducing the template bloat
 // generated by the compiler (technique called template hoisting).
 class WTF_EXPORT RefCountedBase {
-public:
-    void ref()
-    {
+ public:
+  void ref() {
 #if CHECK_REF_COUNTED_LIFECYCLE
-        // Start thread verification as soon as the ref count gets to 2. This
-        // heuristic reflects the fact that items are often created on one thread
-        // and then given to another thread to be used.
-        // FIXME: Make this restriction tigher. Especially as we move to more
-        // common methods for sharing items across threads like CrossThreadCopier.h
-        // We should be able to add a "detachFromThread" method to make this explicit.
-        if (m_refCount == 1)
-            m_verifier.setShared(true);
-        // If this assert fires, it either indicates a thread safety issue or
-        // that the verification needs to change. See ThreadRestrictionVerifier for
-        // the different modes.
-        ASSERT(m_verifier.isSafeToUse());
-        ASSERT(!m_adoptionIsRequired);
-#endif
-        ASSERT_WITH_SECURITY_IMPLICATION(!m_deletionHasBegun);
-        ++m_refCount;
-    }
-
-    bool hasOneRef() const
-    {
-        ASSERT_WITH_SECURITY_IMPLICATION(!m_deletionHasBegun);
+    // Start thread verification as soon as the ref count gets to 2. This
+    // heuristic reflects the fact that items are often created on one thread
+    // and then given to another thread to be used.
+    // FIXME: Make this restriction tigher. Especially as we move to more
+    // common methods for sharing items across threads like CrossThreadCopier.h
+    // We should be able to add a "detachFromThread" method to make this explicit.
+    if (m_refCount == 1)
+      m_verifier.setShared(true);
+    // If this assert fires, it either indicates a thread safety issue or
+    // that the verification needs to change. See ThreadRestrictionVerifier for
+    // the different modes.
+    ASSERT(m_verifier.isSafeToUse());
+    ASSERT(!m_adoptionIsRequired);
+#endif
+    ASSERT_WITH_SECURITY_IMPLICATION(!m_deletionHasBegun);
+    ++m_refCount;
+  }
+
+  bool hasOneRef() const {
+    ASSERT_WITH_SECURITY_IMPLICATION(!m_deletionHasBegun);
 #if CHECK_REF_COUNTED_LIFECYCLE
-        ASSERT(m_verifier.isSafeToUse());
+    ASSERT(m_verifier.isSafeToUse());
 #endif
-        return m_refCount == 1;
-    }
+    return m_refCount == 1;
+  }
 
-    int refCount() const
-    {
+  int refCount() const {
 #if CHECK_REF_COUNTED_LIFECYCLE
-        ASSERT(m_verifier.isSafeToUse());
+    ASSERT(m_verifier.isSafeToUse());
 #endif
-        return m_refCount;
-    }
+    return m_refCount;
+  }
 
-protected:
-    RefCountedBase()
-        : m_refCount(1)
+ protected:
+  RefCountedBase()
+      : m_refCount(1)
 #if ENABLE(SECURITY_ASSERT)
-        , m_deletionHasBegun(false)
+        ,
+        m_deletionHasBegun(false)
 #endif
 #if CHECK_REF_COUNTED_LIFECYCLE
-        , m_adoptionIsRequired(true)
+        ,
+        m_adoptionIsRequired(true)
 #endif
-    {
-    }
+  {
+  }
 
-    ~RefCountedBase()
-    {
-        ASSERT_WITH_SECURITY_IMPLICATION(m_deletionHasBegun);
+  ~RefCountedBase() {
+    ASSERT_WITH_SECURITY_IMPLICATION(m_deletionHasBegun);
 #if CHECK_REF_COUNTED_LIFECYCLE
-        ASSERT(!m_adoptionIsRequired);
+    ASSERT(!m_adoptionIsRequired);
 #endif
-    }
+  }
 
-    // Returns whether the pointer should be freed or not.
-    bool derefBase()
-    {
-        ASSERT_WITH_SECURITY_IMPLICATION(!m_deletionHasBegun);
+  // Returns whether the pointer should be freed or not.
+  bool derefBase() {
+    ASSERT_WITH_SECURITY_IMPLICATION(!m_deletionHasBegun);
 #if CHECK_REF_COUNTED_LIFECYCLE
-        ASSERT(m_verifier.isSafeToUse());
-        ASSERT(!m_adoptionIsRequired);
+    ASSERT(m_verifier.isSafeToUse());
+    ASSERT(!m_adoptionIsRequired);
 #endif
 
-        ASSERT(m_refCount > 0);
-        --m_refCount;
-        if (!m_refCount) {
+    ASSERT(m_refCount > 0);
+    --m_refCount;
+    if (!m_refCount) {
 #if ENABLE(SECURITY_ASSERT)
-            m_deletionHasBegun = true;
+      m_deletionHasBegun = true;
 #endif
-            return true;
-        }
+      return true;
+    }
 
 #if CHECK_REF_COUNTED_LIFECYCLE
-        // Stop thread verification when the ref goes to 1 because it
-        // is safe to be passed to another thread at this point.
-        if (m_refCount == 1)
-            m_verifier.setShared(false);
+    // Stop thread verification when the ref goes to 1 because it
+    // is safe to be passed to another thread at this point.
+    if (m_refCount == 1)
+      m_verifier.setShared(false);
 #endif
-        return false;
-    }
+    return false;
+  }
 
 #if CHECK_REF_COUNTED_LIFECYCLE
-    bool deletionHasBegun() const
-    {
-        return m_deletionHasBegun;
-    }
+  bool deletionHasBegun() const { return m_deletionHasBegun; }
 #endif
 
-private:
-
+ private:
 #if CHECK_REF_COUNTED_LIFECYCLE || ENABLE(SECURITY_ASSERT)
-    friend void adopted(RefCountedBase*);
+  friend void adopted(RefCountedBase*);
 #endif
 
-    int m_refCount;
+  int m_refCount;
 #if ENABLE(SECURITY_ASSERT)
-    bool m_deletionHasBegun;
+  bool m_deletionHasBegun;
 #endif
 #if CHECK_REF_COUNTED_LIFECYCLE
-    bool m_adoptionIsRequired;
-    ThreadRestrictionVerifier m_verifier;
+  bool m_adoptionIsRequired;
+  ThreadRestrictionVerifier m_verifier;
 #endif
 };
 
 #if CHECK_REF_COUNTED_LIFECYCLE || ENABLE(SECURITY_ASSERT)
-inline void adopted(RefCountedBase* object)
-{
-    if (!object)
-        return;
-    ASSERT_WITH_SECURITY_IMPLICATION(!object->m_deletionHasBegun);
+inline void adopted(RefCountedBase* object) {
+  if (!object)
+    return;
+  ASSERT_WITH_SECURITY_IMPLICATION(!object->m_deletionHasBegun);
 #if CHECK_REF_COUNTED_LIFECYCLE
-    object->m_adoptionIsRequired = false;
+  object->m_adoptionIsRequired = false;
 #endif
 }
 #endif
 
-template<typename T> class RefCounted : public RefCountedBase {
-    WTF_MAKE_NONCOPYABLE(RefCounted);
+template <typename T>
+class RefCounted : public RefCountedBase {
+  WTF_MAKE_NONCOPYABLE(RefCounted);
 
-    // Put |T| in here instead of |RefCounted| so the heap profiler reports |T|
-    // instead of |RefCounted<T>|. This does not affect overloading of operator
-    // new.
-    USING_FAST_MALLOC(T);
+  // Put |T| in here instead of |RefCounted| so the heap profiler reports |T|
+  // instead of |RefCounted<T>|. This does not affect overloading of operator
+  // new.
+  USING_FAST_MALLOC(T);
 
-public:
-    void deref()
-    {
-        if (derefBase())
-            delete static_cast<T*>(this);
-    }
+ public:
+  void deref() {
+    if (derefBase())
+      delete static_cast<T*>(this);
+  }
 
-protected:
+ protected:
 #ifdef ENABLE_INSTANCE_COUNTER
-    RefCounted()
-    {
-        incrementInstanceCount<T>(static_cast<T*>(this));
-    }
+  RefCounted() { incrementInstanceCount<T>(static_cast<T*>(this)); }
 
-    ~RefCounted()
-    {
-        decrementInstanceCount<T>(static_cast<T*>(this));
-    }
+  ~RefCounted() { decrementInstanceCount<T>(static_cast<T*>(this)); }
 #else
-    RefCounted()
-    {
-    }
+  RefCounted() {}
 #endif
 };
 
-} // namespace WTF
+}  // namespace WTF
 
 using WTF::RefCounted;
 
-#endif // RefCounted_h
+#endif  // RefCounted_h