reflow comments in wtf

third_party/WebKit/Source/wtf/ThreadRestrictionVerifier.h

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 21 matching lines @@
 #define ThreadRestrictionVerifier_h
 
 #include "wtf/Assertions.h"
 
 #if ENABLE(ASSERT)
 
 #include "wtf/Threading.h"
 
 namespace WTF {
 
-// Verifies that a class is used in a way that respects its lack of thread-safety.
-// The default mode is to verify that the object will only be used on a single thread. The
-// thread gets captured when setShared(true) is called.
-// The mode may be changed by calling useMutexMode (or turnOffVerification).
+// Verifies that a class is used in a way that respects its lack of
+// thread-safety.  The default mode is to verify that the object will only be
+// used on a single thread. The thread gets captured when setShared(true) is
+// called.  The mode may be changed by calling useMutexMode (or
+// turnOffVerification).
 class ThreadRestrictionVerifier {
  public:
   ThreadRestrictionVerifier() : m_shared(false), m_owningThread(0) {}
 
   void checkSafeToUse() const {
     // If this assert fires, it either indicates a thread safety issue or
     // that the verification needs to change.
     ASSERT_WITH_SECURITY_IMPLICATION(isSafeToUse());
   }
 
@@ skipping 25 matching lines @@
  private:
   // Indicates that the object may (or may not) be owned by more than one place.
   void setShared(bool shared) {
     bool previouslyShared = m_shared;
     m_shared = shared;
 
     if (!m_shared)
       return;
 
     ASSERT_UNUSED(previouslyShared, shared != previouslyShared);
-    // Capture the current thread to verify that subsequent ref/deref happen on this thread.
+    // Capture the current thread to verify that subsequent ref/deref happen on
+    // this thread.
     m_owningThread = currentThread();
   }
 
   // Is it OK to use the object at this moment on the current thread?
   bool isSafeToUse() const {
     if (!m_shared)
       return true;
 
     return m_owningThread == currentThread();
   }
 
   bool m_shared;
 
   ThreadIdentifier m_owningThread;
 };
 
 }  // namespace WTF
 
 #endif  // ENABLE(ASSERT)
 #endif  // ThreadRestrictionVerifier_h