reflow comments in platform/geometry

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

 /*
  * Copyright (C) 2011 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 58 matching lines @@
 void TransformState::move(const LayoutSize& offset,
                           TransformAccumulation accumulate) {
   if (m_forceAccumulatingTransform)
     accumulate = AccumulateTransform;
 
   if (accumulate == FlattenTransform || !m_accumulatedTransform) {
     m_accumulatedOffset += offset;
   } else {
     applyAccumulatedOffset();
     if (m_accumulatingTransform && m_accumulatedTransform) {
-      // If we're accumulating into an existing transform, apply the translation.
+      // If we're accumulating into an existing transform, apply the
+      // translation.
       translateTransform(offset);
     } else {
       // Just move the point and/or quad.
       translateMappedCoordinates(offset);
     }
   }
   m_accumulatingTransform = accumulate == AccumulateTransform;
 }
 
 void TransformState::applyAccumulatedOffset() {
   LayoutSize offset = m_accumulatedOffset;
   m_accumulatedOffset = LayoutSize();
   if (!offset.isZero()) {
     if (m_accumulatedTransform) {
       translateTransform(offset);
       flatten();
     } else {
       translateMappedCoordinates(offset);
     }
   }
 }
 
-// FIXME: We transform AffineTransform to TransformationMatrix. This is rather inefficient.
+// FIXME: We transform AffineTransform to TransformationMatrix. This is rather
+// inefficient.
 void TransformState::applyTransform(
     const AffineTransform& transformFromContainer,
     TransformAccumulation accumulate,
     bool* wasClamped) {
   applyTransform(transformFromContainer.toTransformationMatrix(), accumulate,
                  wasClamped);
 }
 
 void TransformState::applyTransform(
     const TransformationMatrix& transformFromContainer,
     TransformAccumulation accumulate,
     bool* wasClamped) {
   if (wasClamped)
     *wasClamped = false;
 
   if (transformFromContainer.isIntegerTranslation()) {
     move(LayoutSize(LayoutUnit(transformFromContainer.e()),
                     LayoutUnit(transformFromContainer.f())),
          accumulate);
     return;
   }
 
   applyAccumulatedOffset();
 
-  // If we have an accumulated transform from last time, multiply in this transform
+  // If we have an accumulated transform from last time, multiply in this
+  // transform
   if (m_accumulatedTransform) {
     if (m_direction == ApplyTransformDirection)
       m_accumulatedTransform = TransformationMatrix::create(
           transformFromContainer * *m_accumulatedTransform);
     else
       m_accumulatedTransform->multiply(transformFromContainer);
   } else if (accumulate == AccumulateTransform) {
     // Make one if we started to accumulate
     m_accumulatedTransform =
         TransformationMatrix::create(transformFromContainer);
@@ skipping 84 matching lines @@
 
   // We could throw away m_accumulatedTransform if we wanted to here, but that
   // would cause thrash when traversing hierarchies with alternating
   // preserve-3d and flat elements.
   if (m_accumulatedTransform)
     m_accumulatedTransform->makeIdentity();
   m_accumulatingTransform = false;
 }
 
 }  // namespace blink