reflow comments in platform/

third_party/WebKit/Source/platform/LayoutUnit.h

 /*
  * Copyright (c) 2012, 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 103 matching lines @@
       return floatValue;
     if (floatValue > 0)
       return nextafterf(floatValue, std::numeric_limits<float>::max());
     return nextafterf(floatValue, std::numeric_limits<float>::min());
   }
   unsigned toUnsigned() const {
     REPORT_OVERFLOW(m_value >= 0);
     return toInt();
   }
 
-  // Conversion to int or unsigned is lossy. 'explicit' on these operators won't work because
-  // there are also other implicit conversion paths (e.g. operator bool then to int which would
-  // generate wrong result). Use toInt() and toUnsigned() instead.
+  // Conversion to int or unsigned is lossy. 'explicit' on these operators won't
+  // work because there are also other implicit conversion paths (e.g. operator
+  // bool then to int which would generate wrong result). Use toInt() and
+  // toUnsigned() instead.
   operator int() const = delete;
   operator unsigned() const = delete;
 
   operator double() const { return toDouble(); }
   operator float() const { return toFloat(); }
   operator bool() const { return m_value; }
 
   LayoutUnit operator++(int) {
     m_value += kFixedPointDenominator;
     return *this;
@@ skipping 34 matching lines @@
 
   LayoutUnit clampNegativeToZero() const {
     return std::max(*this, LayoutUnit());
   }
 
   LayoutUnit clampPositiveToZero() const {
     return std::min(*this, LayoutUnit());
   }
 
   LayoutUnit fraction() const {
-    // Add the fraction to the size (as opposed to the full location) to avoid overflows.
-    // Compute fraction using the mod operator to preserve the sign of the value as it may affect rounding.
+    // Add the fraction to the size (as opposed to the full location) to avoid
+    // overflows.  Compute fraction using the mod operator to preserve the sign
+    // of the value as it may affect rounding.
     LayoutUnit fraction;
     fraction.setRawValue(rawValue() % kFixedPointDenominator);
     return fraction;
   }
 
   bool mightBeSaturated() const {
     return rawValue() == std::numeric_limits<int>::max() ||
            rawValue() == std::numeric_limits<int>::min();
   }
 
   static float epsilon() { return 1.0f / kFixedPointDenominator; }
 
   static const LayoutUnit max() {
     LayoutUnit m;
     m.m_value = std::numeric_limits<int>::max();
     return m;
   }
   static const LayoutUnit min() {
     LayoutUnit m;
     m.m_value = std::numeric_limits<int>::min();
     return m;
   }
 
-  // Versions of max/min that are slightly smaller/larger than max/min() to allow for roinding without overflowing.
+  // Versions of max/min that are slightly smaller/larger than max/min() to
+  // allow for roinding without overflowing.
   static const LayoutUnit nearlyMax() {
     LayoutUnit m;
     m.m_value = std::numeric_limits<int>::max() - kFixedPointDenominator / 2;
     return m;
   }
   static const LayoutUnit nearlyMin() {
     LayoutUnit m;
     m.m_value = std::numeric_limits<int>::min() + kFixedPointDenominator / 2;
     return m;
   }
@@ skipping 150 matching lines @@
 }
 
 inline bool operator==(const LayoutUnit& a, float b) {
   return a.toFloat() == b;
 }
 
 inline bool operator==(const float a, const LayoutUnit& b) {
   return a == b.toFloat();
 }
 
-// For multiplication that's prone to overflow, this bounds it to LayoutUnit::max() and ::min()
+// For multiplication that's prone to overflow, this bounds it to
+// LayoutUnit::max() and ::min()
 inline LayoutUnit boundedMultiply(const LayoutUnit& a, const LayoutUnit& b) {
   int64_t result = static_cast<int64_t>(a.rawValue()) *
                    static_cast<int64_t>(b.rawValue()) / kFixedPointDenominator;
   int32_t high = static_cast<int32_t>(result >> 32);
   int32_t low = static_cast<int32_t>(result);
   uint32_t saturated =
       (static_cast<uint32_t>(a.rawValue() ^ b.rawValue()) >> 31) +
       std::numeric_limits<int>::max();
-  // If the higher 32 bits does not match the lower 32 with sign extension the operation overflowed.
+  // If the higher 32 bits does not match the lower 32 with sign extension the
+  // operation overflowed.
   if (high != low >> 31)
     result = saturated;
 
   LayoutUnit returnVal;
   returnVal.setRawValue(static_cast<int>(result));
   return returnVal;
 }
 
 inline LayoutUnit operator*(const LayoutUnit& a, const LayoutUnit& b) {
   return boundedMultiply(a, b);
@@ skipping 180 matching lines @@
 }
 
 inline LayoutUnit operator-(const LayoutUnit& a) {
   LayoutUnit returnVal;
   returnVal.setRawValue(saturatedNegative(a.rawValue()));
   return returnVal;
 }
 
 // For returning the remainder after a division with integer results.
 inline LayoutUnit intMod(const LayoutUnit& a, const LayoutUnit& b) {
-  // This calculates the modulo so that: a = static_cast<int>(a / b) * b + intMod(a, b).
+  // This calculates the modulo so that: a = static_cast<int>(a / b) * b +
+  // intMod(a, b).
   LayoutUnit returnVal;
   returnVal.setRawValue(a.rawValue() % b.rawValue());
   return returnVal;
 }
 
 inline LayoutUnit operator%(const LayoutUnit& a, const LayoutUnit& b) {
   // This calculates the modulo so that: a = (a / b) * b + a % b.
   LayoutUnit returnVal;
   long long rawVal =
       (static_cast<long long>(kFixedPointDenominator) * a.rawValue()) %
@@ skipping 120 matching lines @@
   return value;
 }
 
 inline std::ostream& operator<<(std::ostream& stream, const LayoutUnit& value) {
   return stream << value.toString();
 }
 
 }  // namespace blink
 
 #endif  // LayoutUnit_h