reflow comments in wtf

third_party/WebKit/Source/wtf/MathExtras.h

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010 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 44 matching lines @@
 
 const double piOverFourDouble = M_PI_4;
 const float piOverFourFloat = static_cast<float>(M_PI_4);
 
 const double twoPiDouble = piDouble * 2.0;
 const float twoPiFloat = piFloat * 2.0f;
 
 #if OS(ANDROID) || COMPILER(MSVC)
 // ANDROID and MSVC's math.h does not currently supply log2 or log2f.
 inline double log2(double num) {
-  // This constant is roughly M_LN2, which is not provided by default on Windows and Android.
+  // This constant is roughly M_LN2, which is not provided by default on Windows
+  // and Android.
   return log(num) / 0.693147180559945309417232121458176568;
 }
 
 inline float log2f(float num) {
-  // This constant is roughly M_LN2, which is not provided by default on Windows and Android.
+  // This constant is roughly M_LN2, which is not provided by default on Windows
+  // and Android.
   return logf(num) / 0.693147180559945309417232121458176568f;
 }
 #endif
 
 #if COMPILER(MSVC)
 
 // VS2013 has most of the math functions now, but we still need to work
 // around various differences in behavior of Inf.
 
-// Work around a bug in Win, where atan2(+-infinity, +-infinity) yields NaN instead of specific values.
+// Work around a bug in Win, where atan2(+-infinity, +-infinity) yields NaN
+// instead of specific values.
 inline double wtf_atan2(double x, double y) {
   double posInf = std::numeric_limits<double>::infinity();
   double negInf = -std::numeric_limits<double>::infinity();
   double nan = std::numeric_limits<double>::quiet_NaN();
 
   double result = nan;
 
   if (x == posInf && y == posInf)
     result = piOverFourDouble;
   else if (x == posInf && y == negInf)
     result = 3 * piOverFourDouble;
   else if (x == negInf && y == posInf)
     result = -piOverFourDouble;
   else if (x == negInf && y == negInf)
     result = -3 * piOverFourDouble;
   else
     result = ::atan2(x, y);
 
   return result;
 }
 
-// Work around a bug in the Microsoft CRT, where fmod(x, +-infinity) yields NaN instead of x.
+// Work around a bug in the Microsoft CRT, where fmod(x, +-infinity) yields NaN
+// instead of x.
 inline double wtf_fmod(double x, double y) {
   return (!std::isinf(x) && std::isinf(y)) ? x : fmod(x, y);
 }
 
-// Work around a bug in the Microsoft CRT, where pow(NaN, 0) yields NaN instead of 1.
+// Work around a bug in the Microsoft CRT, where pow(NaN, 0) yields NaN instead
+// of 1.
 inline double wtf_pow(double x, double y) {
   return y == 0 ? 1 : pow(x, y);
 }
 
 #define atan2(x, y) wtf_atan2(x, y)
 #define fmod(x, y) wtf_fmod(x, y)
 #define pow(x, y) wtf_pow(x, y)
 
 #endif  // COMPILER(MSVC)
 
@@ skipping 286 matching lines @@
         fmod(trunc(d), std::numeric_limits<unsigned long long>::max() + 1.0);
     if (fmodValue >= 0) {
       // 0 <= fmodValue < 2^{64}.
       // 0 <= value < 2^{64}. This cast causes no loss.
       value = static_cast<unsigned long long>(fmodValue);
     } else {
       // -2^{64} < fmodValue < 0.
       // 0 < fmodValueInUnsignedLongLong < 2^{64}. This cast causes no loss.
       unsigned long long fmodValueInUnsignedLongLong =
           static_cast<unsigned long long>(-fmodValue);
-      // -1 < (std::numeric_limits<unsigned long long>::max() - fmodValueInUnsignedLongLong) < 2^{64} - 1.
+      // -1 < (std::numeric_limits<unsigned long long>::max() -
+      //       fmodValueInUnsignedLongLong)
+      //    < 2^{64} - 1.
       // 0 < value < 2^{64}.
       value = std::numeric_limits<unsigned long long>::max() -
               fmodValueInUnsignedLongLong + 1;
     }
   }
 }
 
 namespace WTF {
 
 inline unsigned fastLog2(unsigned i) {
   unsigned log2 = 0;
   if (i & (i - 1))
     log2 += 1;
   if (i >> 16)
     log2 += 16, i >>= 16;
   if (i >> 8)
     log2 += 8, i >>= 8;
   if (i >> 4)
     log2 += 4, i >>= 4;
   if (i >> 2)
     log2 += 2, i >>= 2;
   if (i >> 1)
     log2 += 1;
   return log2;
 }
 
 }  // namespace WTF
 
 #endif  // #ifndef WTF_MathExtras_h