reflow comments in platform/geometry

third_party/WebKit/Source/platform/geometry/FloatQuad.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2013 Xidorn Quan (quanxunzhen@gmail.com)
  *
  * 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
@@ skipping 115 matching lines @@
 // Note that we only handle convex quads here.
 bool FloatQuad::containsQuad(const FloatQuad& other) const {
   return containsPoint(other.p1()) && containsPoint(other.p2()) &&
          containsPoint(other.p3()) && containsPoint(other.p4());
 }
 
 static inline FloatPoint rightMostCornerToVector(const FloatRect& rect,
                                                  const FloatSize& vector) {
   // Return the corner of the rectangle that if it is to the left of the vector
   // would mean all of the rectangle is to the left of the vector.
-  // The vector here represents the side between two points in a clockwise convex polygon.
+  // The vector here represents the side between two points in a clockwise
+  // convex polygon.
   //
   //  Q  XXX
-  // QQQ XXX   If the lower left corner of X is left of the vector that goes from the top corner of Q to
-  //  QQQ      the right corner of Q, then all of X is left of the vector, and intersection impossible.
-  //   Q
+  // QQQ XXX   If the lower left corner of X is left of the vector that goes
+  //  QQQ      from the top corner of Q to the right corner of Q, then all of X
+  //   Q       is left of the vector, and intersection impossible.
   //
   FloatPoint point;
   if (vector.width() >= 0)
     point.setY(rect.maxY());
   else
     point.setY(rect.y());
   if (vector.height() >= 0)
     point.setX(rect.x());
   else
     point.setX(rect.maxX());
   return point;
 }
 
 bool FloatQuad::intersectsRect(const FloatRect& rect) const {
-  // For each side of the quad clockwise we check if the rectangle is to the left of it
-  // since only content on the right can onlap with the quad.
-  // This only works if the quad is convex.
+  // For each side of the quad clockwise we check if the rectangle is to the
+  // left of it since only content on the right can onlap with the quad.  This
+  // only works if the quad is convex.
   FloatSize v1, v2, v3, v4;
 
   // Ensure we use clockwise vectors.
   if (!isCounterclockwise()) {
     v1 = m_p2 - m_p1;
     v2 = m_p3 - m_p2;
     v3 = m_p4 - m_p3;
     v4 = m_p1 - m_p4;
   } else {
     v1 = m_p4 - m_p1;
@@ skipping 11 matching lines @@
     return false;
 
   p = rightMostCornerToVector(rect, v3);
   if (determinant(v3, p - m_p3) < 0)
     return false;
 
   p = rightMostCornerToVector(rect, v4);
   if (determinant(v4, p - m_p4) < 0)
     return false;
 
-  // If not all of the rectangle is outside one of the quad's four sides, then that means at least
-  // a part of the rectangle is overlapping the quad.
+  // If not all of the rectangle is outside one of the quad's four sides, then
+  // that means at least a part of the rectangle is overlapping the quad.
   return true;
 }
 
 // Tests whether the line is contained by or intersected with the circle.
 static inline bool lineIntersectsCircle(const FloatPoint& center,
                                         float radius,
                                         const FloatPoint& p0,
                                         const FloatPoint& p1) {
   float x0 = p0.x() - center.x(), y0 = p0.y() - center.y();
   float x1 = p1.x() - center.x(), y1 = p1.y() - center.y();
@@ skipping 24 matching lines @@
   return containsPoint(
              center)  // The circle may be totally contained by the quad.
          || lineIntersectsCircle(center, radius, m_p1, m_p2) ||
          lineIntersectsCircle(center, radius, m_p2, m_p3) ||
          lineIntersectsCircle(center, radius, m_p3, m_p4) ||
          lineIntersectsCircle(center, radius, m_p4, m_p1);
 }
 
 bool FloatQuad::intersectsEllipse(const FloatPoint& center,
                                   const FloatSize& radii) const {
-  // Transform the ellipse to an origin-centered circle whose radius is the product of major radius and minor radius.
-  // Here we apply the same transformation to the quad.
+  // Transform the ellipse to an origin-centered circle whose radius is the
+  // product of major radius and minor radius.  Here we apply the same
+  // transformation to the quad.
   FloatQuad transformedQuad(*this);
   transformedQuad.move(-center.x(), -center.y());
   transformedQuad.scale(radii.height(), radii.width());
 
   FloatPoint originPoint;
   return transformedQuad.intersectsCircle(originPoint,
                                           radii.height() * radii.width());
 }
 
 bool FloatQuad::isCounterclockwise() const {
-  // Return if the two first vectors are turning clockwise. If the quad is convex then all following vectors will turn the same way.
+  // Return if the two first vectors are turning clockwise. If the quad is
+  // convex then all following vectors will turn the same way.
   return determinant(m_p2 - m_p1, m_p3 - m_p2) < 0;
 }
 
 String FloatQuad::toString() const {
   return String::format("%s; %s; %s; %s", m_p1.toString().ascii().data(),
                         m_p2.toString().ascii().data(),
                         m_p3.toString().ascii().data(),
                         m_p4.toString().ascii().data());
 }
 
 }  // namespace blink