Reformat comments in core/layout/line

third_party/WebKit/Source/core/layout/line/RootInlineBox.cpp

 /*
  * Copyright (C) 2003, 2006, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 77 matching lines @@
 LayoutUnit RootInlineBox::lineHeight() const {
   return boxModelObject().lineHeight(
       isFirstLineStyle(), isHorizontal() ? HorizontalLine : VerticalLine,
       PositionOfInteriorLineBoxes);
 }
 
 bool RootInlineBox::lineCanAccommodateEllipsis(bool ltr,
                                                int blockEdge,
                                                int lineBoxEdge,
                                                int ellipsisWidth) {
-  // First sanity-check the unoverflowed width of the whole line to see if there is sufficient room.
+  // First sanity-check the unoverflowed width of the whole line to see if there
+  // is sufficient room.
   int delta = ltr ? lineBoxEdge - blockEdge : blockEdge - lineBoxEdge;
   if (logicalWidth() - delta < ellipsisWidth)
     return false;
 
-  // Next iterate over all the line boxes on the line.  If we find a replaced element that intersects
-  // then we refuse to accommodate the ellipsis.  Otherwise we're ok.
+  // Next iterate over all the line boxes on the line. If we find a replaced
+  // element that intersects then we refuse to accommodate the ellipsis.
+  // Otherwise we're ok.
   return InlineFlowBox::canAccommodateEllipsis(ltr, blockEdge, ellipsisWidth);
 }
 
 LayoutUnit RootInlineBox::placeEllipsis(const AtomicString& ellipsisStr,
                                         bool ltr,
                                         LayoutUnit blockLeftEdge,
                                         LayoutUnit blockRightEdge,
                                         LayoutUnit ellipsisWidth) {
   // Create an ellipsis box.
   EllipsisBox* ellipsisBox =
       new EllipsisBox(getLineLayoutItem(), ellipsisStr, this, ellipsisWidth,
                       logicalHeight().toFloat(), x().toInt(), y().toInt(),
                       !prevRootBox(), isHorizontal());
 
   if (!gEllipsisBoxMap)
     gEllipsisBoxMap = new EllipsisBoxMap();
   gEllipsisBoxMap->add(this, ellipsisBox);
   setHasEllipsisBox(true);
 
   // FIXME: Do we need an RTL version of this?
   if (ltr &&
       (logicalLeft() + logicalWidth() + ellipsisWidth) <= blockRightEdge) {
     ellipsisBox->setLogicalLeft(logicalLeft() + logicalWidth());
     return logicalWidth() + ellipsisWidth;
   }
 
-  // Now attempt to find the nearest glyph horizontally and place just to the right (or left in RTL)
-  // of that glyph.  Mark all of the objects that intersect the ellipsis box as not painting (as being
-  // truncated).
+  // Now attempt to find the nearest glyph horizontally and place just to the
+  // right (or left in RTL) of that glyph.  Mark all of the objects that
+  // intersect the ellipsis box as not painting (as being truncated).
   bool foundBox = false;
   LayoutUnit truncatedWidth;
   LayoutUnit position =
       placeEllipsisBox(ltr, blockLeftEdge, blockRightEdge, ellipsisWidth,
                        truncatedWidth, foundBox);
   ellipsisBox->setLogicalLeft(position);
   return truncatedWidth;
 }
 
 LayoutUnit RootInlineBox::placeEllipsisBox(bool ltr,
@@ skipping 140 matching lines @@
   m_hasAnnotationsBefore = hasAnnotationsBefore;
   m_hasAnnotationsAfter = hasAnnotationsAfter;
 
   maxHeight = maxHeight.clampNegativeToZero();
 
   setLineTopBottomPositions(lineTop, lineBottom, heightOfBlock,
                             heightOfBlock + maxHeight, selectionBottom);
 
   LayoutUnit annotationsAdjustment = beforeAnnotationsAdjustment();
   if (annotationsAdjustment) {
-    // FIXME: Need to handle pagination here. We might have to move to the next page/column as a result of the
-    // ruby expansion.
+    // FIXME: Need to handle pagination here. We might have to move to the next
+    // page/column as a result of the ruby expansion.
     moveInBlockDirection(annotationsAdjustment);
     heightOfBlock += annotationsAdjustment;
   }
 
   return heightOfBlock + maxHeight;
 }
 
 LayoutUnit RootInlineBox::maxLogicalTop() const {
   LayoutUnit maxLogicalTop;
   computeMaxLogicalTop(maxLogicalTop);
@@ skipping 20 matching lines @@
   } else {
     // Annotations under this line may push us up.
     if (hasAnnotationsBefore())
       result = computeUnderAnnotationAdjustment(
           prevRootBox() ? prevRootBox()->lineBottom()
                         : static_cast<LayoutUnit>(block().borderBefore()));
 
     if (!prevRootBox() || !prevRootBox()->hasAnnotationsAfter())
       return result;
 
-    // We have to compute the expansion for annotations over the previous line to see how much we should move.
+    // We have to compute the expansion for annotations over the previous line
+    // to see how much we should move.
     LayoutUnit lowestAllowedPosition =
         std::max(prevRootBox()->lineBottom(), lineTop()) - result;
     result =
         prevRootBox()->computeOverAnnotationAdjustment(lowestAllowedPosition);
   }
 
   return result;
 }
 
 SelectionState RootInlineBox::getSelectionState() const {
@@ skipping 44 matching lines @@
     selectionTop -= !getLineLayoutItem().style()->isFlippedLinesWritingMode()
                         ? computeOverAnnotationAdjustment(m_lineTop)
                         : computeUnderAnnotationAdjustment(m_lineTop);
 
   if (getLineLayoutItem().style()->isFlippedLinesWritingMode() ||
       !prevRootBox())
     return selectionTop;
 
   LayoutUnit prevBottom = prevRootBox()->selectionBottom();
   if (prevBottom < selectionTop && block().containsFloats()) {
-    // This line has actually been moved further down, probably from a large line-height, but possibly because the
-    // line was forced to clear floats.  If so, let's check the offsets, and only be willing to use the previous
+    // This line has actually been moved further down, probably from a large
+    // line-height, but possibly because the line was forced to clear floats.
+    // If so, let's check the offsets, and only be willing to use the previous
     // line's bottom if the offsets are greater on both sides.
     LayoutUnit prevLeft =
         block().logicalLeftOffsetForLine(prevBottom, DoNotIndentText);
     LayoutUnit prevRight =
         block().logicalRightOffsetForLine(prevBottom, DoNotIndentText);
     LayoutUnit newLeft =
         block().logicalLeftOffsetForLine(selectionTop, DoNotIndentText);
     LayoutUnit newRight =
         block().logicalRightOffsetForLine(selectionTop, DoNotIndentText);
     if (prevLeft > newLeft || prevRight < newRight)
@@ skipping 12 matching lines @@
     selectionBottom += !getLineLayoutItem().style()->isFlippedLinesWritingMode()
                            ? computeUnderAnnotationAdjustment(m_lineBottom)
                            : computeOverAnnotationAdjustment(m_lineBottom);
 
   if (!getLineLayoutItem().style()->isFlippedLinesWritingMode() ||
       !nextRootBox())
     return selectionBottom;
 
   LayoutUnit nextTop = nextRootBox()->selectionTop();
   if (nextTop > selectionBottom && block().containsFloats()) {
-    // The next line has actually been moved further over, probably from a large line-height, but possibly because the
-    // line was forced to clear floats.  If so, let's check the offsets, and only be willing to use the next
+    // The next line has actually been moved further over, probably from a large
+    // line-height, but possibly because the line was forced to clear floats.
+    // If so, let's check the offsets, and only be willing to use the next
     // line's top if the offsets are greater on both sides.
     LayoutUnit nextLeft =
         block().logicalLeftOffsetForLine(nextTop, DoNotIndentText);
     LayoutUnit nextRight =
         block().logicalRightOffsetForLine(nextTop, DoNotIndentText);
     LayoutUnit newLeft =
         block().logicalLeftOffsetForLine(selectionBottom, DoNotIndentText);
     LayoutUnit newRight =
         block().logicalRightOffsetForLine(selectionBottom, DoNotIndentText);
     if (nextLeft > newLeft || nextRight < newRight)
@@ skipping 41 matching lines @@
   }
 
   if (firstLeaf == lastLeaf &&
       (!onlyEditableLeaves || isEditableLeaf(firstLeaf)))
     return firstLeaf;
 
   // Avoid returning a list marker when possible.
   if (leftPosition <= firstLeaf->logicalLeft() &&
       !firstLeaf->getLineLayoutItem().isListMarker() &&
       (!onlyEditableLeaves || isEditableLeaf(firstLeaf))) {
-    // The leftPosition coordinate is less or equal to left edge of the firstLeaf.
-    // Return it.
+    // The leftPosition coordinate is less or equal to left edge of the
+    // firstLeaf. Return it.
     return firstLeaf;
   }
 
   if (leftPosition >= lastLeaf->logicalRight() &&
       !lastLeaf->getLineLayoutItem().isListMarker() &&
       (!onlyEditableLeaves || isEditableLeaf(lastLeaf))) {
-    // The leftPosition coordinate is greater or equal to right edge of the lastLeaf.
-    // Return it.
+    // The leftPosition coordinate is greater or equal to right edge of the
+    // lastLeaf. Return it.
     return lastLeaf;
   }
 
   InlineBox* closestLeaf = nullptr;
   for (InlineBox* leaf = firstLeaf; leaf;
        leaf = leaf->nextLeafChildIgnoringLineBreak()) {
     if (!leaf->getLineLayoutItem().isListMarker() &&
         (!onlyEditableLeaves || isEditableLeaf(leaf))) {
       closestLeaf = leaf;
       if (leftPosition < leaf->logicalRight()) {
@@ skipping 13 matching lines @@
       static_cast<WTF::Unicode::CharDirection>(m_lineBreakBidiStatusLastStrong),
       static_cast<WTF::Unicode::CharDirection>(m_lineBreakBidiStatusLast),
       m_lineBreakContext);
 }
 
 void RootInlineBox::setLineBreakInfo(LineLayoutItem obj,
                                      unsigned breakPos,
                                      const BidiStatus& status) {
   // When setting lineBreakObj, the LayoutObject must not be a LayoutInline
   // with no line boxes, otherwise all sorts of invariants are broken later.
-  // This has security implications because if the LayoutObject does not
-  // point to at least one line box, then that LayoutInline can be deleted
-  // later without resetting the lineBreakObj, leading to use-after-free.
+  // This has security implications because if the LayoutObject does not point
+  // to at least one line box, then that LayoutInline can be deleted later
+  // without resetting the lineBreakObj, leading to use-after-free.
   ASSERT_WITH_SECURITY_IMPLICATION(!obj || obj.isText() ||
                                    !(obj.isLayoutInline() && obj.isBox() &&
                                      !LineLayoutBox(obj).inlineBoxWrapper()));
 
   m_lineBreakObj = obj;
   m_lineBreakPos = breakPos;
   m_lineBreakBidiStatusEor = status.eor;
   m_lineBreakBidiStatusLastStrong = status.lastStrong;
   m_lineBreakBidiStatusLast = status.last;
   m_lineBreakContext = status.context;
@@ skipping 115 matching lines @@
     }
   }
 
   // If leading is included for the box, then we compute that box.
   if (includeLeading && !setUsedFontWithLeading) {
     int ascentWithLeading = box->baselinePosition(baselineType());
     int descentWithLeading = (box->lineHeight() - ascentWithLeading).toInt();
     setAscentAndDescent(ascent, descent, ascentWithLeading, descentWithLeading,
                         ascentDescentSet);
 
-    // Examine the font box for inline flows and text boxes to see if any part of it is above the baseline.
-    // If the top of our font box relative to the root box baseline is above the root box baseline, then
-    // we are contributing to the maxAscent value. Descent is similar. If any part of our font box is below
-    // the root box's baseline, then we contribute to the maxDescent value.
+    // Examine the font box for inline flows and text boxes to see if any part
+    // of it is above the baseline. If the top of our font box relative to the
+    // root box baseline is above the root box baseline, then we are
+    // contributing to the maxAscent value. Descent is similar. If any part of
+    // our font box is below the root box's baseline, then we contribute to the
+    // maxDescent value.
     affectsAscent = ascentWithLeading - box->logicalTop() > 0;
     affectsDescent = descentWithLeading + box->logicalTop() > 0;
   }
 }
 
 LayoutUnit RootInlineBox::verticalPositionForBox(
     InlineBox* box,
     VerticalPositionCache& verticalPositionCache) {
   if (box->getLineLayoutItem().isText())
     return box->parent()->logicalTop();
@@ skipping 45 matching lines @@
           boxModel.baselinePosition(baselineType(), firstLine, lineDirection) -
           fontMetrics.ascent(baselineType());
     } else if (verticalAlign == VerticalAlignMiddle) {
       verticalPosition = LayoutUnit(
           (verticalPosition - LayoutUnit(fontMetrics.xHeight() / 2) -
            boxModel.lineHeight(firstLine, lineDirection) / 2 +
            boxModel.baselinePosition(baselineType(), firstLine, lineDirection))
               .round());
     } else if (verticalAlign == VerticalAlignTextBottom) {
       verticalPosition += fontMetrics.descent(baselineType());
-      // lineHeight - baselinePosition is always 0 for replaced elements (except inline blocks), so don't bother wasting time in that case.
+      // lineHeight - baselinePosition is always 0 for replaced elements (except
+      // inline blocks), so don't bother wasting time in that case.
       if (!boxModel.isAtomicInlineLevel() ||
           boxModel.isInlineBlockOrInlineTable())
         verticalPosition -= (boxModel.lineHeight(firstLine, lineDirection) -
                              boxModel.baselinePosition(
                                  baselineType(), firstLine, lineDirection));
     } else if (verticalAlign == VerticalAlignBaselineMiddle) {
       verticalPosition +=
           -boxModel.lineHeight(firstLine, lineDirection) / 2 +
           boxModel.baselinePosition(baselineType(), firstLine, lineDirection);
     } else if (verticalAlign == VerticalAlignLength) {
       LayoutUnit lineHeight;
-      // Per http://www.w3.org/TR/CSS21/visudet.html#propdef-vertical-align: 'Percentages: refer to the 'line-height' of the element itself'.
+      // Per http://www.w3.org/TR/CSS21/visudet.html#propdef-vertical-align:
+      // 'Percentages: refer to the 'line-height' of the element itself'.
       if (boxModel.style()->getVerticalAlignLength().isPercentOrCalc())
         lineHeight = LayoutUnit(boxModel.style()->computedLineHeight());
       else
         lineHeight = boxModel.lineHeight(firstLine, lineDirection);
       verticalPosition -= valueForLength(
           boxModel.style()->getVerticalAlignLength(), lineHeight);
     }
   }
 
   // Store the cached value.
@@ skipping 33 matching lines @@
   }
   endBox = nullptr;
   return nullptr;
 }
 
 const char* RootInlineBox::boxName() const {
   return "RootInlineBox";
 }
 
 }  // namespace blink