reflow comments in wtf

third_party/WebKit/Source/wtf/StdLibExtras.h

 /*
  * Copyright (C) 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 63 matching lines @@
   static T& unwrap(T* singleton) { return *singleton; }
 };
 
 template <typename T>
 class StaticLocalWrapper<T, true> {
  public:
   using WrapType = blink::Persistent<T>;
 
   static T& unwrap(blink::Persistent<T>* singleton) {
     ASSERT(singleton);
-    // If this assert triggers, you're supplying an empty ("()") 'Arguments' argument
-    // to DEFINE_STATIC_LOCAL() - it must be the heap object you wish to create
-    // as a static singleton and wrapped up with a Persistent reference.
+    // If this assert triggers, you're supplying an empty ("()") 'Arguments'
+    // argument to DEFINE_STATIC_LOCAL() - it must be the heap object you wish
+    // to create as a static singleton and wrapped up with a Persistent
+    // reference.
     ASSERT(*singleton);
     return **singleton;
   }
 };
 
 #if ENABLE(ASSERT)
 #define DEFINE_STATIC_LOCAL_CHECK_THREADSAFE_ACCESS(Name) \
   static StaticLocalVerifier Name##StaticLocalVerifier;   \
   ASSERT(Name##StaticLocalVerifier.isNotRacy())
 #else
@@ skipping 14 matching lines @@
 // details.
 //
 #define DEFINE_STATIC_LOCAL(Type, Name, Arguments)                   \
   DEFINE_STATIC_LOCAL_CHECK_THREADSAFE_ACCESS(Name);                 \
   using WrappedTypeFor##Name = StaticLocalWrapper<Type>::WrapType;   \
   static WrappedTypeFor##Name* WrappedInstanceFor##Name =            \
       LEAK_SANITIZER_REGISTER_STATIC_LOCAL(                          \
           WrappedTypeFor##Name, new WrappedTypeFor##Name Arguments); \
   Type& Name = StaticLocalWrapper<Type>::unwrap(WrappedInstanceFor##Name);
 
-// Use this to declare and define a static local pointer to a ref-counted object so that
-// it is leaked so that the object's destructors are not called at exit.
-// This macro should be used with ref-counted objects rather than DEFINE_STATIC_LOCAL macro,
-// as this macro does not lead to an extra memory allocation.
+// Use this to declare and define a static local pointer to a ref-counted object
+// so that it is leaked so that the object's destructors are not called at
+// exit.  This macro should be used with ref-counted objects rather than
+// DEFINE_STATIC_LOCAL macro, as this macro does not lead to an extra memory
+// allocation.
 #define DEFINE_STATIC_REF(type, name, arguments) \
   static type* name = PassRefPtr<type>(arguments).leakRef();
 
 /*
  * The reinterpret_cast<Type1*>([pointer to Type2]) expressions - where
  * sizeof(Type1) > sizeof(Type2) - cause the following warning on ARM with GCC:
  * increases required alignment of target type.
  *
  * An implicit or an extra static_cast<void*> bypasses the warning.
  * For more info see the following bugzilla entries:
@@ skipping 77 matching lines @@
                 "Truncating conversions not allowed.");                     \
   static_assert(!std::numeric_limits<ActualArgType>::is_signed ||           \
                     std::numeric_limits<ExpectedArgType>::is_signed,        \
                 "Signed to unsigned conversion not allowed.");              \
   static_assert((sizeof(ExpectedArgType) != sizeof(ActualArgType)) ||       \
                     (std::numeric_limits<ActualArgType>::is_signed ==       \
                      std::numeric_limits<ExpectedArgType>::is_signed),      \
                 "Unsigned to signed conversion not allowed for types with " \
                 "identical size (could overflow).");
 
-// Macro that returns a compile time constant with the length of an array, but gives an error if passed a non-array.
+// Macro that returns a compile time constant with the length of an array, but
+// gives an error if passed a non-array.
 template <typename T, size_t Size>
 char (&ArrayLengthHelperFunction(T (&)[Size]))[Size];
 // GCC needs some help to deduce a 0 length array.
 #if COMPILER(GCC)
 template <typename T>
 char (&ArrayLengthHelperFunction(T (&)[0]))[0];
 #endif
 #define WTF_ARRAY_LENGTH(array) sizeof(::WTF::ArrayLengthHelperFunction(array))
 
 }  // namespace WTF
 
 // This version of placement new omits a 0 check.
 enum NotNullTag { NotNull };
 inline void* operator new(size_t, NotNullTag, void* location) {
   ASSERT(location);
   return location;
 }
 
 using WTF::bitwiseCast;
 using WTF::safeCast;
 
 #endif  // WTF_StdLibExtras_h