reflow comments in wtf

third_party/WebKit/Source/wtf/VectorTraits.h

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 37 matching lines @@
   static const bool canMoveWithMemcpy = IsTriviallyMoveAssignable<T>::value;
   static const bool canCopyWithMemcpy = IsTriviallyCopyAssignable<T>::value;
   static const bool canFillWithMemset =
       IsTriviallyDefaultConstructible<T>::value && (sizeof(T) == sizeof(char));
   static const bool canCompareWithMemcmp =
       std::is_scalar<T>::value;  // Types without padding.
   template <typename U = void>
   struct IsTraceableInCollection {
     static const bool value = IsTraceable<T>::value;
   };
-  static const WeakHandlingFlag weakHandlingFlag =
-      NoWeakHandlingInCollections;  // We don't support weak handling in vectors.
+  // We don't support weak handling in vectors.
+  static const WeakHandlingFlag weakHandlingFlag = NoWeakHandlingInCollections;
 };
 
 template <typename T>
 struct VectorTraits : VectorTraitsBase<T> {};
 
 // Classes marked with SimpleVectorTraits will use memmov, memcpy, memcmp
 // instead of constructors, copy operators, etc for initialization, move and
 // comparison.
 template <typename T>
 struct SimpleClassVectorTraits : VectorTraitsBase<T> {
   static const bool canInitializeWithMemset = true;
   static const bool canClearUnusedSlotsWithMemset = true;
   static const bool canMoveWithMemcpy = true;
   static const bool canCompareWithMemcmp = true;
 };
 
-// We know std::unique_ptr and RefPtr are simple enough that initializing to 0 and moving
-// with memcpy (and then not destructing the original) will totally work.
+// We know std::unique_ptr and RefPtr are simple enough that initializing to 0
+// and moving with memcpy (and then not destructing the original) will totally
+// work.
 template <typename P>
 struct VectorTraits<RefPtr<P>> : SimpleClassVectorTraits<RefPtr<P>> {};
 
 template <typename P>
 struct VectorTraits<std::unique_ptr<P>>
     : SimpleClassVectorTraits<std::unique_ptr<P>> {
-  // std::unique_ptr -> std::unique_ptr has a very particular structure that tricks the
-  // normal type traits into thinking that the class is "trivially copyable".
+  // std::unique_ptr -> std::unique_ptr has a very particular structure that
+  // tricks the normal type traits into thinking that the class is "trivially
+  // copyable".
   static const bool canCopyWithMemcpy = false;
 };
 static_assert(VectorTraits<RefPtr<int>>::canInitializeWithMemset,
               "inefficient RefPtr Vector");
 static_assert(VectorTraits<RefPtr<int>>::canMoveWithMemcpy,
               "inefficient RefPtr Vector");
 static_assert(VectorTraits<RefPtr<int>>::canCompareWithMemcmp,
               "inefficient RefPtr Vector");
 static_assert(VectorTraits<std::unique_ptr<int>>::canInitializeWithMemset,
               "inefficient std::unique_ptr Vector");
@@ skipping 21 matching lines @@
       FirstTraits::canCompareWithMemcmp && SecondTraits::canCompareWithMemcmp;
   static const bool canClearUnusedSlotsWithMemset =
       FirstTraits::canClearUnusedSlotsWithMemset &&
       SecondTraits::canClearUnusedSlotsWithMemset;
   template <typename U = void>
   struct IsTraceableInCollection {
     static const bool value =
         IsTraceableInCollectionTrait<FirstTraits>::value ||
         IsTraceableInCollectionTrait<SecondTraits>::value;
   };
-  static const WeakHandlingFlag weakHandlingFlag =
-      NoWeakHandlingInCollections;  // We don't support weak handling in vectors.
+  // We don't support weak handling in vectors.
+  static const WeakHandlingFlag weakHandlingFlag = NoWeakHandlingInCollections;
 };
 
 }  // namespace WTF
 
 #define WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(ClassName)     \
   namespace WTF {                                                         \
   static_assert(!IsTriviallyDefaultConstructible<ClassName>::value ||     \
                     !IsTriviallyMoveAssignable<ClassName>::value ||       \
                     !std::is_scalar<ClassName>::value,                    \
                 "macro not needed");                                      \
@@ skipping 32 matching lines @@
   template <>                                                       \
   struct VectorTraits<ClassName> : VectorTraitsBase<ClassName> {    \
     static const bool canClearUnusedSlotsWithMemset = true;         \
   };                                                                \
   }
 
 using WTF::VectorTraits;
 using WTF::SimpleClassVectorTraits;
 
 #endif  // WTF_VectorTraits_h