Reflow comments in core/css

third_party/WebKit/Source/core/css/CSSMatrix.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 81 matching lines @@
   void setM41(double f) { m_matrix->setM41(f); }
   void setM42(double f) { m_matrix->setM42(f); }
   void setM43(double f) { m_matrix->setM43(f); }
   void setM44(double f) { m_matrix->setM44(f); }
 
   void setMatrixValue(const String&, ExceptionState&);
 
   // The following math function return a new matrix with the
   // specified operation applied. The this value is not modified.
 
-  // Multiply this matrix by secondMatrix, on the right (result = this * secondMatrix)
+  // Multiply this matrix by secondMatrix, on the right
+  // (result = this * secondMatrix)
   CSSMatrix* multiply(CSSMatrix* secondMatrix) const;
 
-  // Return the inverse of this matrix. Throw an exception if the matrix is not invertible
+  // Return the inverse of this matrix. Throw an exception if the matrix is not
+  // invertible.
   CSSMatrix* inverse(ExceptionState&) const;
 
   // Return this matrix translated by the passed values.
-  // Passing a NaN will use a value of 0. This allows the 3D form to used for 2D operations
-  // Operation is performed as though the this matrix is multiplied by a matrix with
-  // the translation values on the left (result = translation(x,y,z) * this)
+  // Passing a NaN will use a value of 0. This allows the 3D form to used for 2D
+  // operations.
+  // Operation is performed as though the this matrix is multiplied by a matrix
+  // with the translation values on the left
+  // (result = translation(x,y,z) * this)
   CSSMatrix* translate(double x, double y, double z) const;
 
   // Returns this matrix scaled by the passed values.
-  // Passing scaleX or scaleZ as NaN uses a value of 1, but passing scaleY of NaN
-  // makes it the same as scaleX. This allows the 3D form to used for 2D operations
-  // Operation is performed as though the this matrix is multiplied by a matrix with
-  // the scale values on the left (result = scale(x,y,z) * this)
+  // Passing scaleX or scaleZ as NaN uses a value of 1, but passing scaleY of
+  // NaN makes it the same as scaleX. This allows the 3D form to used for 2D
+  // operations Operation is performed as though the this matrix is multiplied
+  // by a matrix with the scale values on the left
+  // (result = scale(x,y,z) * this)
   CSSMatrix* scale(double scaleX, double scaleY, double scaleZ) const;
 
   // Returns this matrix rotated by the passed values.
   // If rotY and rotZ are NaN, rotate about Z (rotX=0, rotateY=0, rotateZ=rotX).
   // Otherwise use a rotation value of 0 for any passed NaN.
-  // Operation is performed as though the this matrix is multiplied by a matrix with
-  // the rotation values on the left (result = rotation(x,y,z) * this)
+  // Operation is performed as though the this matrix is multiplied by a matrix
+  // with the rotation values on the left (result = rotation(x,y,z) * this)
   CSSMatrix* rotate(double rotX, double rotY, double rotZ) const;
 
   // Returns this matrix rotated about the passed axis by the passed angle.
   // Passing a NaN will use a value of 0. If the axis is (0,0,0) use a value
-  // Operation is performed as though the this matrix is multiplied by a matrix with
-  // the rotation values on the left (result = rotation(x,y,z,angle) * this)
+  // Operation is performed as though the this matrix is multiplied by a matrix
+  // with the rotation values on the left
+  // (result = rotation(x,y,z,angle) * this)
   CSSMatrix* rotateAxisAngle(double x, double y, double z, double angle) const;
 
   // Return this matrix skewed along the X axis by the passed values.
   // Passing a NaN will use a value of 0.
-  // Operation is performed as though the this matrix is multiplied by a matrix with
-  // the skew values on the left (result = skewX(angle) * this)
+  // Operation is performed as though the this matrix is multiplied by a matrix
+  // with the skew values on the left (result = skewX(angle) * this)
   CSSMatrix* skewX(double angle) const;
 
   // Return this matrix skewed along the Y axis by the passed values.
   // Passing a NaN will use a value of 0.
-  // Operation is performed as though the this matrix is multiplied by a matrix with
-  // the skew values on the left (result = skewY(angle) * this)
+  // Operation is performed as though the this matrix is multiplied by a matrix
+  // with the skew values on the left (result = skewY(angle) * this)
   CSSMatrix* skewY(double angle) const;
 
   const TransformationMatrix& transform() const { return *m_matrix; }
 
   String toString() const;
 
   DEFINE_INLINE_TRACE() {}
 
  protected:
   CSSMatrix(const TransformationMatrix&);
   CSSMatrix(const String&, ExceptionState&);
 
   // TransformationMatrix needs to be 16-byte aligned. PartitionAlloc
   // supports 16-byte alignment but Oilpan doesn't. So we use an std::unique_ptr
   // to allocate TransformationMatrix on PartitionAlloc.
   // TODO(oilpan): Oilpan should support 16-byte aligned allocations.
   std::unique_ptr<TransformationMatrix> m_matrix;
 };
 
 }  // namespace blink
 
 #endif  // CSSMatrix_h