Reformat comments in core/layout/line

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

 /*
- * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
@@ skipping 114 matching lines @@
             (parentStyle.verticalAlign() != VerticalAlignBaseline &&
              !isRootInlineBox()) ||
             childStyle.verticalAlign() != VerticalAlignBaseline)
           shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
       }
       if (childStyle.hasTextCombine() ||
           childStyle.getTextEmphasisMark() != TextEmphasisMarkNone)
         shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
     } else {
       if (child->getLineLayoutItem().isBR()) {
-        // FIXME: This is dumb. We only turn off because current layout test results expect the <br> to be 0-height on the baseline.
-        // Other than making a zillion tests have to regenerate results, there's no reason to ditch the optimization here.
+        // FIXME: This is dumb. We only turn off because current layout test
+        // results expect the <br> to be 0-height on the baseline.
+        // Other than making a zillion tests have to regenerate results, there's
+        // no reason to ditch the optimization here.
         shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
       } else {
         ASSERT(isInlineFlowBox());
         InlineFlowBox* childFlowBox = toInlineFlowBox(child);
-        // Check the child's bit, and then also check for differences in font, line-height, vertical-align
+        // Check the child's bit, and then also check for differences in font,
+        // line-height, vertical-align
         if (!childFlowBox->descendantsHaveSameLineHeightAndBaseline() ||
             !parentStyle.font()
                  .getFontMetrics()
                  .hasIdenticalAscentDescentAndLineGap(
                      childStyle.font().getFontMetrics()) ||
             parentStyle.lineHeight() != childStyle.lineHeight() ||
             (parentStyle.verticalAlign() != VerticalAlignBaseline &&
              !isRootInlineBox()) ||
             childStyle.verticalAlign() != VerticalAlignBaseline ||
             childStyle.hasBorder() || childStyle.hasPadding() ||
@@ skipping 112 matching lines @@
   lineBoxes()->attachLineBox(this);
 }
 
 void InlineFlowBox::move(const LayoutSize& delta) {
   InlineBox::move(delta);
   for (InlineBox* child = firstChild(); child; child = child->nextOnLine()) {
     if (child->getLineLayoutItem().isOutOfFlowPositioned())
       continue;
     child->move(delta);
   }
-  if (m_overflow)
-    m_overflow->move(
-        delta.width(),
-        delta
-            .height());  // FIXME: Rounding error here since overflow was pixel snapped, but nobody other than list markers passes non-integral values here.
+  if (m_overflow) {
+    // FIXME: Rounding error here since overflow was pixel snapped, but nobody
+    // other than list markers passes non-integral values here.
+    m_overflow->move(delta.width(), delta.height());
+  }
 }
 
 LineBoxList* InlineFlowBox::lineBoxes() const {
   return LineLayoutInline(getLineLayoutItem()).lineBoxes();
 }
 
 static inline bool isLastChildForLayoutObject(LineLayoutItem ancestor,
                                               LineLayoutItem child) {
   if (!child)
     return false;
@@ skipping 24 matching lines @@
       return true;
     item = item.parent();
   }
   return false;
 }
 
 void InlineFlowBox::determineSpacingForFlowBoxes(
     bool lastLine,
     bool isLogicallyLastRunWrapped,
     LineLayoutItem logicallyLastRunLayoutObject) {
-  // All boxes start off open.  They will not apply any margins/border/padding on
-  // any side.
+  // All boxes start off open.  They will not apply any margins/border/padding
+  // on any side.
   bool includeLeftEdge = false;
   bool includeRightEdge = false;
 
   // The root inline box never has borders/margins/padding.
   if (parent()) {
     bool ltr = getLineLayoutItem().style()->isLeftToRightDirection();
 
     // Check to see if all initial lines are unconstructed.  If so, then
     // we know the inline began on this line (unless we are a continuation).
     LineBoxList* lineBoxList = lineBoxes();
@@ skipping 12 matching lines @@
       LineLayoutInline inlineFlow = LineLayoutInline(getLineLayoutItem());
       LineLayoutItem logicallyLastRunLayoutItem(logicallyLastRunLayoutObject);
       bool isLastObjectOnLine =
           !isAncestorAndWithinBlock(getLineLayoutItem(),
                                     logicallyLastRunLayoutItem) ||
           (isLastChildForLayoutObject(getLineLayoutItem(),
                                       logicallyLastRunLayoutItem) &&
            !isLogicallyLastRunWrapped);
 
       // We include the border under these conditions:
-      // (1) The next line was not created, or it is constructed. We check the previous line for rtl.
+      // (1) The next line was not created, or it is constructed. We check the
+      //     previous line for rtl.
       // (2) The logicallyLastRun is not a descendant of this layout object.
-      // (3) The logicallyLastRun is a descendant of this layout object, but it is the last child of this layout object and it does not wrap to the next line.
-      // (4) The decoration break is set to clone therefore there will be borders on every sides.
+      // (3) The logicallyLastRun is a descendant of this layout object, but it
+      //     is the last child of this layout object and it does not wrap to the
+      //     next line.
+      // (4) The decoration break is set to clone therefore there will be
+      //     borders on every sides.
       if (getLineLayoutItem().style()->boxDecorationBreak() ==
           BoxDecorationBreakClone) {
         includeLeftEdge = includeRightEdge = true;
       } else if (ltr) {
         if (!nextLineBox() &&
             ((lastLine || isLastObjectOnLine) && !inlineFlow.continuation()))
           includeRightEdge = true;
       } else {
         if ((!prevLineBox() || prevLineBox()->isConstructed()) &&
             ((lastLine || isLastObjectOnLine) && !inlineFlow.continuation()))
@@ skipping 29 matching lines @@
   placeBoxRangeInInlineDirection(firstChild(), nullptr, logicalLeft,
                                  minLogicalLeft, maxLogicalRight,
                                  needsWordSpacing);
 
   logicalLeft += borderLogicalRight() + paddingLogicalRight();
   endPlacingBoxRangesInInlineDirection(startLogicalLeft, logicalLeft,
                                        minLogicalLeft, maxLogicalRight);
   return logicalLeft;
 }
 
-// TODO(wkorman): needsWordSpacing may not need to be a reference in the below. Seek a test case.
+// TODO(wkorman): needsWordSpacing may not need to be a reference in the below.
+// Seek a test case.
 void InlineFlowBox::placeBoxRangeInInlineDirection(InlineBox* firstChild,
                                                    InlineBox* lastChild,
                                                    LayoutUnit& logicalLeft,
                                                    LayoutUnit& minLogicalLeft,
                                                    LayoutUnit& maxLogicalRight,
                                                    bool& needsWordSpacing) {
   for (InlineBox* curr = firstChild; curr && curr != lastChild;
        curr = curr->nextOnLine()) {
     if (curr->getLineLayoutItem().isText()) {
       InlineTextBox* text = toInlineTextBox(curr);
@@ skipping 20 matching lines @@
       if (knownToHaveNoOverflow())
         maxLogicalRight = std::max(logicalLeft, maxLogicalRight);
     } else {
       if (curr->getLineLayoutItem().isOutOfFlowPositioned()) {
         if (curr->getLineLayoutItem()
                 .parent()
                 .style()
                 ->isLeftToRightDirection()) {
           curr->setLogicalLeft(logicalLeft);
         } else {
-          // Our offset that we cache needs to be from the edge of the right border box and
-          // not the left border box.  We have to subtract |x| from the width of the block
-          // (which can be obtained from the root line box).
+          // Our offset that we cache needs to be from the edge of the right
+          // border box and not the left border box. We have to subtract |x|
+          // from the width of the block (which can be obtained from the root
+          // line box).
           curr->setLogicalLeft(root().block().logicalWidth() - logicalLeft);
         }
         continue;  // The positioned object has no effect on the width.
       }
       if (curr->getLineLayoutItem().isLayoutInline()) {
         InlineFlowBox* flow = toInlineFlowBox(curr);
         logicalLeft += flow->marginLogicalLeft();
         if (knownToHaveNoOverflow())
           minLogicalLeft = std::min(logicalLeft, minLogicalLeft);
         logicalLeft =
             flow->placeBoxesInInlineDirection(logicalLeft, needsWordSpacing);
         if (knownToHaveNoOverflow())
           maxLogicalRight = std::max(logicalLeft, maxLogicalRight);
         logicalLeft += flow->marginLogicalRight();
       } else if (!curr->getLineLayoutItem().isListMarker() ||
                  LineLayoutListMarker(curr->getLineLayoutItem()).isInside()) {
-        // The box can have a different writing-mode than the overall line, so this is a bit complicated.
-        // Just get all the physical margin and overflow values by hand based off |isHorizontal|.
+        // The box can have a different writing-mode than the overall line, so
+        // this is a bit complicated. Just get all the physical margin and
+        // overflow values by hand based off |isHorizontal|.
         LineLayoutBoxModel box = curr->boxModelObject();
         LayoutUnit logicalLeftMargin;
         LayoutUnit logicalRightMargin;
         if (isHorizontal()) {
           logicalLeftMargin = box.marginLeft();
           logicalRightMargin = box.marginRight();
         } else {
           logicalLeftMargin = box.marginTop();
           logicalRightMargin = box.marginBottom();
         }
 
         logicalLeft += logicalLeftMargin;
         curr->setLogicalLeft(logicalLeft);
         if (knownToHaveNoOverflow())
           minLogicalLeft = std::min(logicalLeft, minLogicalLeft);
         logicalLeft += curr->logicalWidth();
         if (knownToHaveNoOverflow())
           maxLogicalRight = std::max(logicalLeft, maxLogicalRight);
         logicalLeft += logicalRightMargin;
-        // If we encounter any space after this inline block then ensure it is treated as the space between two words.
+        // If we encounter any space after this inline block then ensure it is
+        // treated as the space between two words.
         needsWordSpacing = true;
       }
     }
   }
 }
 
 FontBaseline InlineFlowBox::dominantBaseline() const {
-  // Use "central" (Ideographic) baseline if writing-mode is vertical-* and text-orientation is not sideways-*.
+  // Use "central" (Ideographic) baseline if writing-mode is vertical-* and
+  // text-orientation is not sideways-*.
   // http://dev.w3.org/csswg/css-writing-modes-3/#text-baselines
   if (!isHorizontal() &&
       getLineLayoutItem()
           .style(isFirstLineStyle())
           ->getFontDescription()
           .isVerticalAnyUpright())
     return IdeographicBaseline;
   return AlphabeticBaseline;
 }
 
@@ skipping 36 matching lines @@
     LayoutUnit& maxPositionTop,
     LayoutUnit& maxPositionBottom,
     int& maxAscent,
     int& maxDescent,
     bool& setMaxAscent,
     bool& setMaxDescent,
     bool noQuirksMode,
     GlyphOverflowAndFallbackFontsMap& textBoxDataMap,
     FontBaseline baselineType,
     VerticalPositionCache& verticalPositionCache) {
-  // The primary purpose of this function is to compute the maximal ascent and descent values for
-  // a line.
+  // The primary purpose of this function is to compute the maximal ascent and
+  // descent values for a line.
   //
-  // The maxAscent value represents the distance of the highest point of any box (typically including line-height) from
-  // the root box's baseline. The maxDescent value represents the distance of the lowest point of any box
-  // (also typically including line-height) from the root box baseline. These values can be negative.
+  // The maxAscent value represents the distance of the highest point of any box
+  // (typically including line-height) from the root box's baseline. The
+  // maxDescent value represents the distance of the lowest point of any box
+  // (also typically including line-height) from the root box baseline. These
+  // values can be negative.
   //
-  // A secondary purpose of this function is to store the offset of every box's baseline from the root box's
-  // baseline. This information is cached in the logicalTop() of every box. We're effectively just using
-  // the logicalTop() as scratch space.
+  // A secondary purpose of this function is to store the offset of every box's
+  // baseline from the root box's baseline. This information is cached in the
+  // logicalTop() of every box. We're effectively just using the logicalTop() as
+  // scratch space.
   //
-  // Because a box can be positioned such that it ends up fully above or fully below the
-  // root line box, we only consider it to affect the maxAscent and maxDescent values if some
-  // part of the box (EXCLUDING leading) is above (for ascent) or below (for descent) the root box's baseline.
+  // Because a box can be positioned such that it ends up fully above or fully
+  // below the root line box, we only consider it to affect the maxAscent and
+  // maxDescent values if some part of the box (EXCLUDING leading) is above (for
+  // ascent) or below (for descent) the root box's baseline.
   bool affectsAscent = false;
   bool affectsDescent = false;
   bool checkChildren = !descendantsHaveSameLineHeightAndBaseline();
 
   if (isRootInlineBox()) {
     // Examine our root box.
     int ascent = 0;
     int descent = 0;
     rootBox->ascentAndDescentForBox(rootBox, textBoxDataMap, ascent, descent,
                                     affectsAscent, affectsDescent);
@@ skipping 16 matching lines @@
   for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
     if (curr->getLineLayoutItem().isOutOfFlowPositioned())
       continue;  // Positioned placeholders don't affect calculations.
 
     InlineFlowBox* inlineFlowBox =
         curr->isInlineFlowBox() ? toInlineFlowBox(curr) : nullptr;
 
     bool affectsAscent = false;
     bool affectsDescent = false;
 
-    // The verticalPositionForBox function returns the distance between the child box's baseline
-    // and the root box's baseline.  The value is negative if the child box's baseline is above the
-    // root box's baseline, and it is positive if the child box's baseline is below the root box's baseline.
+    // The verticalPositionForBox function returns the distance between the
+    // child box's baseline and the root box's baseline. The value is negative
+    // if the child box's baseline is above the root box's baseline, and it is
+    // positive if the child box's baseline is below the root box's baseline.
     curr->setLogicalTop(
         rootBox->verticalPositionForBox(curr, verticalPositionCache));
 
     int ascent = 0;
     int descent = 0;
     rootBox->ascentAndDescentForBox(curr, textBoxDataMap, ascent, descent,
                                     affectsAscent, affectsDescent);
 
     LayoutUnit boxHeight(ascent + descent);
     if (curr->verticalAlign() == VerticalAlignTop) {
       if (maxPositionTop < boxHeight)
         maxPositionTop = boxHeight;
     } else if (curr->verticalAlign() == VerticalAlignBottom) {
       if (maxPositionBottom < boxHeight)
         maxPositionBottom = boxHeight;
     } else if (!inlineFlowBox || noQuirksMode ||
                inlineFlowBox->hasTextChildren() ||
                (inlineFlowBox->descendantsHaveSameLineHeightAndBaseline() &&
                 inlineFlowBox->hasTextDescendants()) ||
                inlineFlowBox->boxModelObject()
                    .hasInlineDirectionBordersOrPadding()) {
-      // Note that these values can be negative.  Even though we only affect the maxAscent and maxDescent values
-      // if our box (excluding line-height) was above (for ascent) or below (for descent) the root baseline, once you factor in line-height
-      // the final box can end up being fully above or fully below the root box's baseline!  This is ok, but what it
-      // means is that ascent and descent (including leading), can end up being negative.  The setMaxAscent and
-      // setMaxDescent booleans are used to ensure that we're willing to initially set maxAscent/Descent to negative
-      // values.
+      // Note that these values can be negative. Even though we only affect the
+      // maxAscent and maxDescent values if our box (excluding line-height) was
+      // above (for ascent) or below (for descent) the root baseline, once you
+      // factor in line-height the final box can end up being fully above or
+      // fully below the root box's baseline! This is ok, but what it means is
+      // that ascent and descent (including leading), can end up being negative.
+      // The setMaxAscent and setMaxDescent booleans are used to ensure that
+      // we're willing to initially set maxAscent/Descent to negative values.
       ascent -= curr->logicalTop().round();
       descent += curr->logicalTop().round();
       if (affectsAscent && (maxAscent < ascent || !setMaxAscent)) {
         maxAscent = ascent;
         setMaxAscent = true;
       }
 
       if (affectsDescent && (maxDescent < descent || !setMaxDescent)) {
         maxDescent = descent;
         setMaxDescent = true;
@@ skipping 19 matching lines @@
     bool& setLineTop,
     LayoutUnit& lineTopIncludingMargins,
     LayoutUnit& lineBottomIncludingMargins,
     bool& hasAnnotationsBefore,
     bool& hasAnnotationsAfter,
     FontBaseline baselineType) {
   bool isRootBox = isRootInlineBox();
   if (isRootBox) {
     const FontMetrics& fontMetrics =
         getLineLayoutItem().style(isFirstLineStyle())->getFontMetrics();
-    // RootInlineBoxes are always placed at pixel boundaries in their logical y direction. Not doing
-    // so results in incorrect layout of text decorations, most notably underlines.
+    // RootInlineBoxes are always placed at pixel boundaries in their logical y
+    // direction. Not doing so results in incorrect layout of text decorations,
+    // most notably underlines.
     setLogicalTop(LayoutUnit(
         roundToInt(top + maxAscent - fontMetrics.ascent(baselineType))));
   }
 
   LayoutUnit adjustmentForChildrenWithSameLineHeightAndBaseline;
   if (descendantsHaveSameLineHeightAndBaseline()) {
     adjustmentForChildrenWithSameLineHeightAndBaseline = logicalTop();
     if (parent())
       adjustmentForChildrenWithSameLineHeightAndBaseline +=
           boxModelObject().borderAndPaddingOver();
@@ skipping 39 matching lines @@
       if (curr->isInlineFlowBox()) {
         LineLayoutBoxModel boxObject =
             LineLayoutBoxModel(curr->getLineLayoutItem());
         newLogicalTop -= boxObject.borderAndPaddingOver();
         borderPaddingHeight = boxObject.borderAndPaddingLogicalHeight();
       }
       newLogicalTopIncludingMargins = newLogicalTop;
     } else if (!curr->getLineLayoutItem().isBR()) {
       LineLayoutBox box = LineLayoutBox(curr->getLineLayoutItem());
       newLogicalTopIncludingMargins = newLogicalTop;
-      // TODO(kojii): isHorizontal() does not match to m_layoutObject.isHorizontalWritingMode(). crbug.com/552954
-      // ASSERT(curr->isHorizontal() == curr->getLineLayoutItem().style()->isHorizontalWritingMode());
+      // TODO(kojii): isHorizontal() does not match to
+      // m_layoutObject.isHorizontalWritingMode(). crbug.com/552954
+      // ASSERT(curr->isHorizontal() ==
+      // curr->getLineLayoutItem().style()->isHorizontalWritingMode());
       LayoutUnit overSideMargin =
           curr->isHorizontal() ? box.marginTop() : box.marginRight();
       LayoutUnit underSideMargin =
           curr->isHorizontal() ? box.marginBottom() : box.marginLeft();
       newLogicalTop += overSideMargin;
       boxHeightIncludingMargins += overSideMargin + underSideMargin;
     }
 
     curr->setLogicalTop(newLogicalTop);
 
     if (childAffectsTopBottomPos) {
       if (curr->getLineLayoutItem().isRubyRun()) {
-        // Treat the leading on the first and last lines of ruby runs as not being part of the overall lineTop/lineBottom.
-        // Really this is a workaround hack for the fact that ruby should have been done as line layout and not done using
-        // inline-block.
+        // Treat the leading on the first and last lines of ruby runs as not
+        // being part of the overall lineTop/lineBottom.
+        // Really this is a workaround hack for the fact that ruby should have
+        // been done as line layout and not done using inline-block.
         if (getLineLayoutItem().style()->isFlippedLinesWritingMode() ==
             (curr->getLineLayoutItem().style()->getRubyPosition() ==
              RubyPositionAfter))
           hasAnnotationsBefore = true;
         else
           hasAnnotationsAfter = true;
 
         LineLayoutRubyRun rubyRun =
             LineLayoutRubyRun(curr->getLineLayoutItem());
         if (LineLayoutRubyBase rubyBase = rubyRun.rubyBase()) {
@@ skipping 43 matching lines @@
       }
       selectionBottom = std::max(
           selectionBottom, newLogicalTop + boxHeight - borderPaddingHeight);
       lineBottom = std::max(lineBottom, newLogicalTop + boxHeight);
       lineBottomIncludingMargins = std::max(
           lineBottom,
           std::max(lineBottomIncludingMargins,
                    newLogicalTopIncludingMargins + boxHeightIncludingMargins));
     }
 
-    // Adjust boxes to use their real box y/height and not the logical height (as dictated by
-    // line-height).
+    // Adjust boxes to use their real box y/height and not the logical height
+    // (as dictated by line-height).
     if (inlineFlowBox)
       inlineFlowBox->placeBoxesInBlockDirection(
           top, maxHeight, maxAscent, noQuirksMode, lineTop, lineBottom,
           selectionBottom, setLineTop, lineTopIncludingMargins,
           lineBottomIncludingMargins, hasAnnotationsBefore, hasAnnotationsAfter,
           baselineType);
   }
 
   if (isRootBox) {
     if (noQuirksMode || hasTextChildren() ||
@@ skipping 31 matching lines @@
     maxLogicalTop = std::max<LayoutUnit>(maxLogicalTop, curr->y());
     LayoutUnit localMaxLogicalTop;
     if (curr->isInlineFlowBox())
       toInlineFlowBox(curr)->computeMaxLogicalTop(localMaxLogicalTop);
     maxLogicalTop = std::max<LayoutUnit>(maxLogicalTop, localMaxLogicalTop);
   }
 }
 
 void InlineFlowBox::flipLinesInBlockDirection(LayoutUnit lineTop,
                                               LayoutUnit lineBottom) {
-  // Flip the box on the line such that the top is now relative to the lineBottom instead of the lineTop.
+  // Flip the box on the line such that the top is now relative to the
+  // lineBottom instead of the lineTop.
   setLogicalTop(lineBottom - (logicalTop() - lineTop) - logicalHeight());
 
   for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
     if (curr->getLineLayoutItem().isOutOfFlowPositioned())
       continue;  // Positioned placeholders aren't affected here.
 
     if (curr->isInlineFlowBox())
       toInlineFlowBox(curr)->flipLinesInBlockDirection(lineTop, lineBottom);
     else
       curr->setLogicalTop(lineBottom - (curr->logicalTop() - lineTop) -
@@ skipping 10 matching lines @@
   if (!parent() &&
       (!isFirstLineStyle() || &style == getLineLayoutItem().style()))
     return;
 
   WritingMode writingMode = style.getWritingMode();
   ShadowList* boxShadow = style.boxShadow();
   if (!boxShadow)
     return;
 
   LayoutRectOutsets outsets(boxShadow->rectOutsetsIncludingOriginal());
-  // Similar to how glyph overflow works, if our lines are flipped, then it's actually the opposite shadow that applies, since
-  // the line is "upside down" in terms of block coordinates.
+  // Similar to how glyph overflow works, if our lines are flipped, then it's
+  // actually the opposite shadow that applies, since the line is "upside down"
+  // in terms of block coordinates.
   LayoutRectOutsets logicalOutsets(
       outsets.logicalOutsetsWithFlippedLines(writingMode));
 
   LayoutRect shadowBounds(logicalFrameRect());
   shadowBounds.expand(logicalOutsets);
   logicalVisualOverflow.unite(shadowBounds);
 }
 
 inline void InlineFlowBox::addBorderOutsetVisualOverflow(
     LayoutRect& logicalVisualOverflow) {
   const ComputedStyle& style = getLineLayoutItem().styleRef(isFirstLineStyle());
 
-  // border-image-outset on the block element applies to the block and not to the lines,
-  // unless it is modified by :first-line pseudo element.
+  // border-image-outset on the block element applies to the block and not to
+  // the lines, unless it is modified by :first-line pseudo element.
   if (!parent() &&
       (!isFirstLineStyle() || &style == getLineLayoutItem().style()))
     return;
 
   if (!style.hasBorderImageOutsets())
     return;
 
-  // Similar to how glyph overflow works, if our lines are flipped, then it's actually the opposite border that applies, since
-  // the line is "upside down" in terms of block coordinates. vertical-rl is the flipped line mode.
+  // Similar to how glyph overflow works, if our lines are flipped, then it's
+  // actually the opposite border that applies, since the line is "upside down"
+  // in terms of block coordinates. vertical-rl is the flipped line mode.
   LayoutRectOutsets logicalOutsets =
       style.borderImageOutsets().logicalOutsetsWithFlippedLines(
           style.getWritingMode());
 
   if (!includeLogicalLeftEdge())
     logicalOutsets.setLeft(LayoutUnit());
   if (!includeLogicalRightEdge())
     logicalOutsets.setRight(LayoutUnit());
 
   LayoutRect borderOutsetBounds(logicalFrameRect());
@@ skipping 50 matching lines @@
       textBox->getEmphasisMarkPosition(style, emphasisMarkPosition)) {
     float emphasisMarkHeight =
         style.font().emphasisMarkHeight(style.textEmphasisMarkString());
     if ((emphasisMarkPosition == TextEmphasisPositionOver) ==
         (!style.isFlippedLinesWritingMode()))
       topGlyphOverflow = std::min(topGlyphOverflow, -emphasisMarkHeight);
     else
       bottomGlyphOverflow = std::max(bottomGlyphOverflow, emphasisMarkHeight);
   }
 
-  // If letter-spacing is negative, we should factor that into right layout overflow. Even in RTL, letter-spacing is
-  // applied to the right, so this is not an issue with left overflow.
+  // If letter-spacing is negative, we should factor that into right layout
+  // overflow. Even in RTL, letter-spacing is applied to the right, so this is
+  // not an issue with left overflow.
   rightGlyphOverflow -=
       std::min(0.0f, style.font().getFontDescription().letterSpacing());
 
   LayoutRectOutsets textShadowLogicalOutsets;
   if (ShadowList* textShadow = style.textShadow())
     textShadowLogicalOutsets =
         LayoutRectOutsets(textShadow->rectOutsetsIncludingOriginal())
             .logicalOutsets(style.getWritingMode());
 
   // FIXME: This code currently uses negative values for expansion of the top
@@ skipping 40 matching lines @@
   if (logicalVisualOverflow != textBox->logicalFrameRect())
     textBox->setLogicalOverflowRect(logicalVisualOverflow);
 }
 
 inline void InlineFlowBox::addReplacedChildOverflow(
     const InlineBox* inlineBox,
     LayoutRect& logicalLayoutOverflow,
     LayoutRect& logicalVisualOverflow) {
   LineLayoutBox box = LineLayoutBox(inlineBox->getLineLayoutItem());
 
-  // Visual overflow only propagates if the box doesn't have a self-painting layer.  This rectangle does not include
-  // transforms or relative positioning (since those objects always have self-painting layers), but it does need to be adjusted
-  // for writing-mode differences.
+  // Visual overflow only propagates if the box doesn't have a self-painting
+  // layer. This rectangle does not include transforms or relative positioning
+  // (since those objects always have self-painting layers), but it does need to
+  // be adjusted for writing-mode differences.
   if (!box.hasSelfPaintingLayer()) {
     LayoutRect childLogicalVisualOverflow =
         box.logicalVisualOverflowRectForPropagation(
             getLineLayoutItem().styleRef());
     childLogicalVisualOverflow.move(inlineBox->logicalLeft(),
                                     inlineBox->logicalTop());
     logicalVisualOverflow.unite(childLogicalVisualOverflow);
   }
 
-  // Layout overflow internal to the child box only propagates if the child box doesn't have overflow clip set.
-  // Otherwise the child border box propagates as layout overflow.  This rectangle must include transforms and relative positioning
-  // and be adjusted for writing-mode differences.
+  // Layout overflow internal to the child box only propagates if the child box
+  // doesn't have overflow clip set. Otherwise the child border box propagates
+  // as layout overflow. This rectangle must include transforms and relative
+  // positioning and be adjusted for writing-mode differences.
   LayoutRect childLogicalLayoutOverflow =
       box.logicalLayoutOverflowRectForPropagation(
           getLineLayoutItem().styleRef());
   childLogicalLayoutOverflow.move(inlineBox->logicalLeft(),
                                   inlineBox->logicalTop());
   logicalLayoutOverflow.unite(childLogicalLayoutOverflow);
 }
 
 void InlineFlowBox::computeOverflow(
     LayoutUnit lineTop,
     LayoutUnit lineBottom,
     GlyphOverflowAndFallbackFontsMap& textBoxDataMap) {
   // If we know we have no overflow, we can just bail.
   if (knownToHaveNoOverflow()) {
     ASSERT(!m_overflow);
     return;
   }
 
   if (m_overflow)
     m_overflow.reset();
 
-  // Visual overflow just includes overflow for stuff we need to issues paint invalidations for ourselves. Self-painting layers are ignored.
-  // Layout overflow is used to determine scrolling extent, so it still includes child layers and also factors in
-  // transforms, relative positioning, etc.
+  // Visual overflow just includes overflow for stuff we need to issues paint
+  // invalidations for ourselves. Self-painting layers are ignored.
+  // Layout overflow is used to determine scrolling extent, so it still includes
+  // child layers and also factors in transforms, relative positioning, etc.
   LayoutRect logicalLayoutOverflow(
       logicalFrameRectIncludingLineHeight(lineTop, lineBottom));
   LayoutRect logicalVisualOverflow(logicalLayoutOverflow);
 
   addBoxShadowVisualOverflow(logicalVisualOverflow);
   addBorderOutsetVisualOverflow(logicalVisualOverflow);
   addOutlineVisualOverflow(logicalVisualOverflow);
 
   for (InlineBox* curr = firstChild(); curr; curr = curr->nextOnLine()) {
     if (curr->getLineLayoutItem().isOutOfFlowPositioned())
@@ skipping 75 matching lines @@
                                 const HitTestLocation& locationInContainer,
                                 const LayoutPoint& accumulatedOffset,
                                 LayoutUnit lineTop,
                                 LayoutUnit lineBottom) {
   LayoutRect overflowRect(visualOverflowRect(lineTop, lineBottom));
   flipForWritingMode(overflowRect);
   overflowRect.moveBy(accumulatedOffset);
   if (!locationInContainer.intersects(overflowRect))
     return false;
 
-  // We need to hit test both our inline children (Inline Boxes) and culled inlines
-  // (LayoutObjects). We check our inlines in the same order as line layout but
-  // for each inline we additionally need to hit test its culled inline parents.
-  // While hit testing culled inline parents, we can stop once we reach
-  // a non-inline parent or a culled inline associated with a different inline box.
+  // We need to hit test both our inline children (Inline Boxes) and culled
+  // inlines (LayoutObjects). We check our inlines in the same order as line
+  // layout but for each inline we additionally need to hit test its culled
+  // inline parents. While hit testing culled inline parents, we can stop once
+  // we reach a non-inline parent or a culled inline associated with a different
+  // inline box.
   InlineBox* prev;
   for (InlineBox* curr = lastChild(); curr; curr = prev) {
     prev = curr->prevOnLine();
 
     // Layers will handle hit testing themselves.
     if (!curr->boxModelObject() ||
         !curr->boxModelObject().hasSelfPaintingLayer()) {
       if (curr->nodeAtPoint(result, locationInContainer, accumulatedOffset,
                             lineTop, lineBottom)) {
         getLineLayoutItem().updateHitTestResult(
             result,
             locationInContainer.point() - toLayoutSize(accumulatedOffset));
         return true;
       }
     }
 
-    // If the current inline box's layout object and the previous inline box's layout object are same,
-    // we should yield the hit-test to the previous inline box.
+    // If the current inline box's layout object and the previous inline box's
+    // layout object are same, we should yield the hit-test to the previous
+    // inline box.
     if (prev && curr->getLineLayoutItem() == prev->getLineLayoutItem())
       continue;
 
     // Hit test the culled inline if necessary.
     LineLayoutItem currLayoutItem = curr->getLineLayoutItem();
     while (true) {
-      // If the previous inline box is not a descendant of a current inline's parent,
-      // the parent is a culled inline and we hit test it.
-      // Otherwise, move to the previous inline box because we hit test first all
-      // candidate inline boxes under the parent to take a pre-order tree traversal in reverse.
+      // If the previous inline box is not a descendant of a current inline's
+      // parent, the parent is a culled inline and we hit test it.
+      // Otherwise, move to the previous inline box because we hit test first
+      // all candidate inline boxes under the parent to take a pre-order tree
+      // traversal in reverse.
       bool hasSibling =
           currLayoutItem.previousSibling() || currLayoutItem.nextSibling();
       LineLayoutItem culledParent = currLayoutItem.parent();
       ASSERT(culledParent);
 
       if (culledParent == getLineLayoutItem() ||
           (hasSibling && prev &&
            prev->getLineLayoutItem().isDescendantOf(culledParent)))
         break;
 
@@ skipping 27 matching lines @@
   LayoutRect rect =
       InlineFlowBoxPainter(*this).frameRectClampedToLineTopAndBottomIfNeeded();
 
   flipForWritingMode(rect);
   rect.moveBy(accumulatedOffset);
 
   // Pixel snap hit testing.
   rect = LayoutRect(pixelSnappedIntRect(rect));
   if (visibleToHitTestRequest(result.hitTestRequest()) &&
       locationInContainer.intersects(rect)) {
+    // Don't add in m_topLeft here, we want coords in the containing block's
+    // coordinate space.
     getLineLayoutItem().updateHitTestResult(
-        result,
-        flipForWritingMode(
-            locationInContainer.point() -
-            toLayoutSize(
-                accumulatedOffset)));  // Don't add in m_topLeft here, we want coords in the containing block's space.
+        result, flipForWritingMode(locationInContainer.point() -
+                                   toLayoutSize(accumulatedOffset)));
     if (result.addNodeToListBasedTestResult(getLineLayoutItem().node(),
                                             locationInContainer,
                                             rect) == StopHitTesting)
       return true;
   }
 
   return false;
 }
 
 void InlineFlowBox::paint(const PaintInfo& paintInfo,
                           const LayoutPoint& paintOffset,
                           LayoutUnit lineTop,
                           LayoutUnit lineBottom) const {
   InlineFlowBoxPainter(*this).paint(paintInfo, paintOffset, lineTop,
                                     lineBottom);
 }
 
 bool InlineFlowBox::boxShadowCanBeAppliedToBackground(
     const FillLayer& lastBackgroundLayer) const {
-  // The checks here match how paintFillLayer() decides whether to clip (if it does, the shadow
+  // The checks here match how paintFillLayer() decides whether to clip (if it
+  // does, the shadow
   // would be clipped out, so it has to be drawn separately).
   StyleImage* image = lastBackgroundLayer.image();
   bool hasFillImage = image && image->canRender();
   return (!hasFillImage && !getLineLayoutItem().style()->hasBorderRadius()) ||
          (!prevLineBox() && !nextLineBox()) || !parent();
 }
 
 InlineBox* InlineFlowBox::firstLeafChild() const {
   InlineBox* leaf = nullptr;
   for (InlineBox* child = firstChild(); child && !leaf;
@@ skipping 24 matching lines @@
   return true;
 }
 
 LayoutUnit InlineFlowBox::placeEllipsisBox(bool ltr,
                                            LayoutUnit blockLeftEdge,
                                            LayoutUnit blockRightEdge,
                                            LayoutUnit ellipsisWidth,
                                            LayoutUnit& truncatedWidth,
                                            bool& foundBox) {
   LayoutUnit result(-1);
-  // We iterate over all children, the foundBox variable tells us when we've found the
-  // box containing the ellipsis.  All boxes after that one in the flow are hidden.
-  // If our flow is ltr then iterate over the boxes from left to right, otherwise iterate
-  // from right to left. Varying the order allows us to correctly hide the boxes following the ellipsis.
+  // We iterate over all children, the foundBox variable tells us when we've
+  // found the box containing the ellipsis.  All boxes after that one in the
+  // flow are hidden.
+  // If our flow is ltr then iterate over the boxes from left to right,
+  // otherwise iterate from right to left. Varying the order allows us to
+  // correctly hide the boxes following the ellipsis.
   InlineBox* box = ltr ? firstChild() : lastChild();
 
   // NOTE: these will cross after foundBox = true.
   int visibleLeftEdge = blockLeftEdge.toInt();
   int visibleRightEdge = blockRightEdge.toInt();
 
   while (box) {
     int currResult =
         box->placeEllipsisBox(ltr, LayoutUnit(visibleLeftEdge),
                               LayoutUnit(visibleRightEdge), ellipsisWidth,
@@ skipping 149 matching lines @@
     }
   }
   return result;
 }
 
 void InlineFlowBox::collectLeafBoxesInLogicalOrder(
     Vector<InlineBox*>& leafBoxesInLogicalOrder,
     CustomInlineBoxRangeReverse customReverseImplementation) const {
   InlineBox* leaf = firstLeafChild();
 
-  // FIXME: The reordering code is a copy of parts from BidiResolver::createBidiRunsForLine, operating directly on InlineBoxes, instead of BidiRuns.
-  // Investigate on how this code could possibly be shared.
+  // FIXME: The reordering code is a copy of parts from BidiResolver::
+  // createBidiRunsForLine, operating directly on InlineBoxes, instead of
+  // BidiRuns. Investigate on how this code could possibly be shared.
   unsigned char minLevel = 128;
   unsigned char maxLevel = 0;
 
-  // First find highest and lowest levels, and initialize leafBoxesInLogicalOrder with the leaf boxes in visual order.
+  // First find highest and lowest levels, and initialize
+  // leafBoxesInLogicalOrder with the leaf boxes in visual order.
   for (; leaf; leaf = leaf->nextLeafChild()) {
     minLevel = std::min(minLevel, leaf->bidiLevel());
     maxLevel = std::max(maxLevel, leaf->bidiLevel());
     leafBoxesInLogicalOrder.append(leaf);
   }
 
   if (getLineLayoutItem().style()->rtlOrdering() == VisualOrder)
     return;
 
   // Reverse of reordering of the line (L2 according to Bidi spec):
-  // L2. From the highest level found in the text to the lowest odd level on each line,
-  // reverse any contiguous sequence of characters that are at that level or higher.
+  // L2. From the highest level found in the text to the lowest odd level on
+  // each line, reverse any contiguous sequence of characters that are at that
+  // level or higher.
 
-  // Reversing the reordering of the line is only done up to the lowest odd level.
+  // Reversing the reordering of the line is only done up to the lowest odd
+  // level.
   if (!(minLevel % 2))
     ++minLevel;
 
   Vector<InlineBox*>::iterator end = leafBoxesInLogicalOrder.end();
   while (minLevel <= maxLevel) {
     Vector<InlineBox*>::iterator it = leafBoxesInLogicalOrder.begin();
     while (it != end) {
       while (it != end) {
         if ((*it)->bidiLevel() >= minLevel)
           break;
@@ skipping 47 matching lines @@
     ASSERT(child->prevOnLine() == prev);
     prev = child;
   }
   ASSERT(prev == m_lastChild);
 #endif
 }
 
 #endif
 
 }  // namespace blink