reflow comments in wtf

third_party/WebKit/Source/wtf/TypeTraits.h

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009, 2010 Google 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,
@@ skipping 28 matching lines @@
 template <typename T>
 struct IsWeak {
   static const bool value = false;
 };
 
 enum WeakHandlingFlag {
   NoWeakHandlingInCollections,
   WeakHandlingInCollections
 };
 
-// Compilers behave differently on __has_trivial_assign(T) if T has a user-deleted copy assignment operator:
+// Compilers behave differently on __has_trivial_assign(T) if T has a
+// user-deleted copy assignment operator:
 //
 //     * MSVC returns false; but
 //     * The others return true.
 //
-// To workaround that, here we have IsAssignable<T, From> class template, but unfortunately, MSVC 2013 cannot compile
-// it due to the lack of expression SFINAE.
+// To workaround that, here we have IsAssignable<T, From> class template, but
+// unfortunately, MSVC 2013 cannot compile it due to the lack of expression
+// SFINAE.
 //
 // Thus, IsAssignable is only defined on non-MSVC compilers.
 #if !COMPILER(MSVC) || COMPILER(CLANG)
 template <typename T, typename From>
 class IsAssignable {
   typedef char YesType;
   struct NoType {
     char padding[8];
   };
 
@@ skipping 27 matching lines @@
 #if COMPILER(MSVC) && !COMPILER(CLANG)
   static const bool value = __has_trivial_assign(T);
 #else
   static const bool value =
       __has_trivial_assign(T) && IsCopyAssignable<T>::value;
 #endif
 };
 
 template <typename T>
 struct IsTriviallyMoveAssignable {
-  // TODO(yutak): This isn't really correct, because __has_trivial_assign appears to look only at copy assignment.
-  // However, std::is_trivially_move_assignable isn't available at this moment, and there isn't a good way to
-  // write that ourselves.
+  // TODO(yutak): This isn't really correct, because __has_trivial_assign
+  // appears to look only at copy assignment.  However,
+  // std::is_trivially_move_assignable isn't available at this moment, and
+  // there isn't a good way to write that ourselves.
   //
-  // Here we use IsTriviallyCopyAssignable as a conservative approximation: if T is trivially copy assignable,
-  // T is trivially move assignable, too. This definition misses a case where T is trivially move-only assignable,
-  // but such cases should be rare.
+  // Here we use IsTriviallyCopyAssignable as a conservative approximation: if T
+  // is trivially copy assignable, T is trivially move assignable, too. This
+  // definition misses a case where T is trivially move-only assignable, but
+  // such cases should be rare.
   static const bool value = IsTriviallyCopyAssignable<T>::value;
 };
 
-// Same as above, but for __has_trivial_constructor and __has_trivial_destructor. For IsTriviallyDefaultConstructible,
-// we don't have to write IsDefaultConstructible ourselves since we can use std::is_constructible<T>. For
-// IsTriviallyDestructible, though, we can't rely on std::is_destructible<T> right now.
+// Same as above, but for __has_trivial_constructor and
+// __has_trivial_destructor. For IsTriviallyDefaultConstructible, we don't have
+// to write IsDefaultConstructible ourselves since we can use
+// std::is_constructible<T>. For IsTriviallyDestructible, though, we can't rely
+// on std::is_destructible<T> right now.
 #if !COMPILER(MSVC) || COMPILER(CLANG)
 template <typename T>
 class IsDestructible {
   typedef char YesType;
   struct NoType {
     char padding[8];
   };
 
   template <typename T2, typename = decltype(std::declval<T2>().~T2())>
   static YesType checkDestructibility(int);
@@ skipping 274 matching lines @@
 class IsPointerToGarbageCollectedType<T*, false> {
  public:
   static const bool value = IsGarbageCollectedType<T>::value;
 };
 
 }  // namespace WTF
 
 using WTF::IsGarbageCollectedType;
 
 #endif  // TypeTraits_h