Reformat comments in core/layout/line

third_party/WebKit/Source/core/layout/line/BreakingContextInlineHeaders.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
+ * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
+ *               All right reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated.
  *
  * 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 198 matching lines @@
   bool m_collapseWhiteSpace;
   bool m_startingNewParagraph;
   bool m_allowImagesToBreak;
   bool m_atEnd;
 
   LineMidpointState& m_lineMidpointState;
 
   TrailingObjects m_trailingObjects;
 };
 
-// When ignoring spaces, this needs to be called for objects that need line boxes such as LayoutInlines or
-// hard line breaks to ensure that they're not ignored.
+// When ignoring spaces, this needs to be called for objects that need line
+// boxes such as LayoutInlines or hard line breaks to ensure that they're not
+// ignored.
 inline void ensureLineBoxInsideIgnoredSpaces(LineMidpointState* midpointState,
                                              LineLayoutItem item) {
   InlineIterator midpoint(0, item, 0);
   midpointState->stopIgnoringSpaces(midpoint);
   midpointState->startIgnoringSpaces(midpoint);
 }
 
 inline bool shouldCollapseWhiteSpace(const ComputedStyle& style,
                                      const LineInfo& lineInfo,
                                      WhitespacePosition whitespacePosition) {
   // CSS2 16.6.1
-  // If a space (U+0020) at the beginning of a line has 'white-space' set to 'normal', 'nowrap', or 'pre-line', it is removed.
-  // If a space (U+0020) at the end of a line has 'white-space' set to 'normal', 'nowrap', or 'pre-line', it is also removed.
-  // If spaces (U+0020) or tabs (U+0009) at the end of a line have 'white-space' set to 'pre-wrap', UAs may visually collapse them.
+  // If a space (U+0020) at the beginning of a line has 'white-space' set to
+  // 'normal', 'nowrap', or 'pre-line', it is removed.
+  // If a space (U+0020) at the end of a line has 'white-space' set to 'normal',
+  // 'nowrap', or 'pre-line', it is also removed.
+  // If spaces (U+0020) or tabs (U+0009) at the end of a line have 'white-space'
+  // set to 'pre-wrap', UAs may visually collapse them.
   return style.collapseWhiteSpace() ||
          (whitespacePosition == TrailingWhitespace &&
           style.whiteSpace() == PRE_WRAP &&
           (!lineInfo.isEmpty() || !lineInfo.previousLineBrokeCleanly()));
 }
 
 inline bool requiresLineBoxForContent(LineLayoutInline flow,
                                       const LineInfo& lineInfo) {
   LineLayoutItem parent = flow.parent();
   if (flow.document().inNoQuirksMode() &&
       (flow.style(lineInfo.isFirstLine())->lineHeight() !=
            parent.style(lineInfo.isFirstLine())->lineHeight() ||
        flow.style()->verticalAlign() != parent.style()->verticalAlign() ||
        !parent.style()
             ->font()
             .getFontMetrics()
             .hasIdenticalAscentDescentAndLineGap(
                 flow.style()->font().getFontMetrics())))
     return true;
   return false;
 }
 
 inline bool alwaysRequiresLineBox(LineLayoutItem flow) {
-  // FIXME: Right now, we only allow line boxes for inlines that are truly empty.
-  // We need to fix this, though, because at the very least, inlines containing only
-  // ignorable whitespace should should also have line boxes.
+  // FIXME: Right now, we only allow line boxes for inlines that are truly
+  // empty. We need to fix this, though, because at the very least, inlines
+  // containing only ignorable whitespace should should also have line boxes.
   return isEmptyInline(flow) &&
          LineLayoutInline(flow).hasInlineDirectionBordersPaddingOrMargin();
 }
 
 inline bool requiresLineBox(
     const InlineIterator& it,
     const LineInfo& lineInfo = LineInfo(),
     WhitespacePosition whitespacePosition = LeadingWhitespace) {
   if (it.getLineLayoutItem().isEmptyText())
     return false;
@@ skipping 18 matching lines @@
                            current != softHyphenCharacter &&
                            (current != newlineCharacter ||
                             it.getLineLayoutItem().preservesNewline());
   return notJustWhitespace || isEmptyInline(it.getLineLayoutItem());
 }
 
 inline void setStaticPositions(LineLayoutBlockFlow block,
                                LineLayoutBox child,
                                IndentTextOrNot indentText) {
   ASSERT(child.isOutOfFlowPositioned());
-  // FIXME: The math here is actually not really right. It's a best-guess approximation that
-  // will work for the common cases
+  // FIXME: The math here is actually not really right. It's a best-guess
+  // approximation that will work for the common cases
   LineLayoutItem containerBlock = child.container();
   LayoutUnit blockHeight = block.logicalHeight();
   if (containerBlock.isLayoutInline()) {
-    // A relative positioned inline encloses us. In this case, we also have to determine our
-    // position as though we were an inline. Set |staticInlinePosition| and |staticBlockPosition| on the relative positioned
-    // inline so that we can obtain the value later.
+    // A relative positioned inline encloses us. In this case, we also have to
+    // determine our position as though we were an inline.
+    // Set |staticInlinePosition| and |staticBlockPosition| on the relative
+    // positioned inline so that we can obtain the value later.
     LineLayoutInline(containerBlock)
         .layer()
         ->setStaticInlinePosition(
             block.startAlignedOffsetForLine(blockHeight, indentText));
     LineLayoutInline(containerBlock)
         .layer()
         ->setStaticBlockPosition(blockHeight);
 
-    // If |child| is a leading or trailing positioned object this is its only opportunity to ensure it moves with an inline
-    // container changing width.
+    // If |child| is a leading or trailing positioned object this is its only
+    // opportunity to ensure it moves with an inline container changing width.
     child.moveWithEdgeOfInlineContainerIfNecessary(
         child.isHorizontalWritingMode());
   }
   block.updateStaticInlinePositionForChild(child, blockHeight, indentText);
   child.layer()->setStaticBlockPosition(blockHeight);
 }
 
-// FIXME: The entire concept of the skipTrailingWhitespace function is flawed, since we really need to be building
-// line boxes even for containers that may ultimately collapse away. Otherwise we'll never get positioned
-// elements quite right. In other words, we need to build this function's work into the normal line
-// object iteration process.
-// NB. this function will insert any floating elements that would otherwise
-// be skipped but it will not position them.
+// FIXME: The entire concept of the skipTrailingWhitespace function is flawed,
+// since we really need to be building line boxes even for containers that may
+// ultimately collapse away. Otherwise we'll never get positioned elements quite
+// right. In other words, we need to build this function's work into the normal
+// line object iteration process. NB. this function will insert any floating
+// elements that would otherwise be skipped but it will not position them.
 inline void BreakingContext::skipTrailingWhitespace(InlineIterator& iterator,
                                                     const LineInfo& lineInfo) {
   while (!iterator.atEnd() &&
          !requiresLineBox(iterator, lineInfo, TrailingWhitespace)) {
     LineLayoutItem item = iterator.getLineLayoutItem();
     if (item.isOutOfFlowPositioned())
       setStaticPositions(m_block, LineLayoutBox(item), DoNotIndentText);
     else if (item.isFloating())
       m_block.insertFloatingObject(LineLayoutBox(item));
     iterator.increment();
@@ skipping 17 matching lines @@
                  : m_lastObject.parent().style()->whiteSpace();
 
   bool isSVGText = m_current.getLineLayoutItem().isSVGInlineText();
   m_autoWrap = !isSVGText && ComputedStyle::autoWrap(m_currWS);
   m_autoWrapWasEverTrueOnLine = m_autoWrapWasEverTrueOnLine || m_autoWrap;
 
   m_preservesNewline = !isSVGText && ComputedStyle::preserveNewline(m_currWS);
 
   m_collapseWhiteSpace = ComputedStyle::collapseWhiteSpace(m_currWS);
 
-  // Ensure the whitespace in constructions like '<span style="white-space: pre-wrap">text <span><span> text</span>'
-  // does not collapse.
+  // Ensure the whitespace in constructions like '<span style="white-space:
+  // pre-wrap">text <span><span> text</span>' does not collapse.
   if (m_collapseWhiteSpace && !ComputedStyle::collapseWhiteSpace(m_lastWS))
     m_currentCharacterIsSpace = false;
 }
 
 inline void BreakingContext::increment() {
   m_current.moveToStartOf(m_nextObject);
 
-  // When the line box tree is created, this position in the line will be snapped to
-  // LayoutUnit's, and those measurements will be used by the paint code.  Do the
-  // equivalent snapping here, to get consistent line measurements.
+  // When the line box tree is created, this position in the line will be
+  // snapped to LayoutUnit's, and those measurements will be used by the paint
+  // code. Do the equivalent snapping here, to get consistent line measurements.
   m_width.snapUncommittedWidth();
 
   m_atStart = false;
 }
 
 inline void BreakingContext::handleBR(EClear& clear) {
   if (m_width.fitsOnLine()) {
     LineLayoutItem br = m_current.getLineLayoutItem();
     m_lineBreak.moveToStartOf(br);
     m_lineBreak.increment();
 
     // A <br> always breaks a line, so don't let the line be collapsed
     // away. Also, the space at the end of a line with a <br> does not
     // get collapsed away. It only does this if the previous line broke
     // cleanly. Otherwise the <br> has no effect on whether the line is
     // empty or not.
     if (m_startingNewParagraph)
       m_lineInfo.setEmpty(false);
     m_trailingObjects.clear();
     m_lineInfo.setPreviousLineBrokeCleanly(true);
 
-    // A <br> with clearance always needs a linebox in case the lines below it get dirtied later and
-    // need to check for floats to clear - so if we're ignoring spaces, stop ignoring them and add a
-    // run for this object.
+    // A <br> with clearance always needs a linebox in case the lines below it
+    // get dirtied later and need to check for floats to clear - so if we're
+    // ignoring spaces, stop ignoring them and add a run for this object.
     if (m_ignoringSpaces && m_currentStyle->clear() != ClearNone)
       ensureLineBoxInsideIgnoredSpaces(&m_lineMidpointState, br);
 
     if (!m_lineInfo.isEmpty())
       clear = m_currentStyle->clear();
   }
   m_atEnd = true;
 }
 
 inline LayoutUnit borderPaddingMarginStart(LineLayoutInline child) {
@@ skipping 37 matching lines @@
 inline void BreakingContext::handleOutOfFlowPositioned(
     Vector<LineLayoutBox>& positionedObjects) {
   // If our original display wasn't an inline type, then we can
   // go ahead and determine our static inline position now.
   LineLayoutBox box(m_current.getLineLayoutItem());
   bool isInlineType = box.style()->isOriginalDisplayInlineType();
   if (!isInlineType) {
     m_block.setStaticInlinePositionForChild(box,
                                             m_block.startOffsetForContent());
   } else {
-    // If our original display was an INLINE type, then we can determine our static y position
-    // now. Note, however, that if we're paginated, we may have to update this position after
-    // the line has been laid out, since the line may be pushed by a pagination strut.
+    // If our original display was an INLINE type, then we can determine our
+    // static y position now. Note, however, that if we're paginated, we may
+    // have to update this position after the line has been laid out, since the
+    // line may be pushed by a pagination strut.
     box.layer()->setStaticBlockPosition(m_block.logicalHeight());
   }
 
   // If we're ignoring spaces, we have to stop and include this object and
   // then start ignoring spaces again.
   bool containerIsInline = box.container().isLayoutInline();
   if (isInlineType || containerIsInline) {
     if (m_ignoringSpaces)
       ensureLineBoxInsideIgnoredSpaces(&m_lineMidpointState, box);
     m_trailingObjects.appendObjectIfNeeded(box);
   }
   if (!containerIsInline)
     positionedObjects.append(box);
   m_width.addUncommittedWidth(
       inlineLogicalWidthFromAncestorsIfNeeded(box).toFloat());
   // Reset prior line break context characters.
   m_layoutTextInfo.m_lineBreakIterator.resetPriorContext();
 }
 
 inline void BreakingContext::handleFloat() {
   LineLayoutBox floatBox(m_current.getLineLayoutItem());
   FloatingObject* floatingObject = m_block.insertFloatingObject(floatBox);
-  // check if it fits in the current line.
-  // If it does, position it now, otherwise, position
-  // it after moving to next line (in newLine() func)
-  // FIXME: Bug 110372: Properly position multiple stacked floats with non-rectangular shape outside.
+  // Check if it fits in the current line; if it does, position it now,
+  // otherwise, position it after moving to next line (in newLine() func).
+  // FIXME: Bug 110372: Properly position multiple stacked floats with
+  // non-rectangular shape outside.
   if (m_floatsFitOnLine &&
       m_width.fitsOnLine(
           m_block.logicalWidthForFloat(*floatingObject).toFloat(),
           ExcludeWhitespace)) {
     m_block.positionNewFloats(&m_width);
     if (m_lineBreak.getLineLayoutItem() == m_current.getLineLayoutItem()) {
       ASSERT(!m_lineBreak.offset());
       m_lineBreak.increment();
     }
   } else {
     m_floatsFitOnLine = false;
   }
-  // Update prior line break context characters, using U+FFFD (OBJECT REPLACEMENT CHARACTER) for floating element.
+  // Update prior line break context characters, using U+FFFD (OBJECT
+  // REPLACEMENT CHARACTER) for floating element.
   m_layoutTextInfo.m_lineBreakIterator.updatePriorContext(replacementCharacter);
 }
 
-// This is currently just used for list markers and inline flows that have line boxes. Neither should
-// have an effect on whitespace at the start of the line.
+// This is currently just used for list markers and inline flows that have line
+// boxes. Neither should have an effect on whitespace at the start of the line.
 inline bool shouldSkipWhitespaceAfterStartObject(
     LineLayoutBlockFlow block,
     LineLayoutItem o,
     LineMidpointState& lineMidpointState) {
   LineLayoutItem next = bidiNextSkippingEmptyInlines(block, o);
   while (next && next.isFloatingOrOutOfFlowPositioned())
     next = bidiNextSkippingEmptyInlines(block, next);
 
   while (next && isEmptyInline(next)) {
     LineLayoutItem child = LineLayoutInline(next).firstChild();
@@ skipping 14 matching lines @@
 }
 
 inline void BreakingContext::handleEmptyInline() {
   // This should only end up being called on empty inlines
   ASSERT(m_current.getLineLayoutItem());
 
   LineLayoutInline flowBox(m_current.getLineLayoutItem());
 
   bool requiresLineBox = alwaysRequiresLineBox(m_current.getLineLayoutItem());
   if (requiresLineBox || requiresLineBoxForContent(flowBox, m_lineInfo)) {
-    // An empty inline that only has line-height, vertical-align or font-metrics will
-    // not force linebox creation (and thus affect the height of the line) if the rest of the line is empty.
+    // An empty inline that only has line-height, vertical-align or font-metrics
+    // will not force linebox creation (and thus affect the height of the line)
+    // if the rest of the line is empty.
     if (requiresLineBox)
       m_lineInfo.setEmpty(false);
     if (m_ignoringSpaces) {
-      // If we are in a run of ignored spaces then ensure we get a linebox if lineboxes are eventually
-      // created for the line...
+      // If we are in a run of ignored spaces then ensure we get a linebox if
+      // lineboxes are eventually created for the line...
       m_trailingObjects.clear();
       ensureLineBoxInsideIgnoredSpaces(&m_lineMidpointState,
                                        m_current.getLineLayoutItem());
     } else if (m_blockStyle->collapseWhiteSpace() &&
                m_resolver.position().getLineLayoutItem() ==
                    m_current.getLineLayoutItem() &&
                shouldSkipWhitespaceAfterStartObject(
                    m_block, m_current.getLineLayoutItem(),
                    m_lineMidpointState)) {
-      // If this object is at the start of the line, we need to behave like list markers and
-      // start ignoring spaces.
+      // If this object is at the start of the line, we need to behave like list
+      // markers and start ignoring spaces.
       m_currentCharacterIsSpace = true;
       m_ignoringSpaces = true;
     } else {
-      // If we are after a trailing space but aren't ignoring spaces yet then ensure we get a linebox
-      // if we encounter collapsible whitepace.
+      // If we are after a trailing space but aren't ignoring spaces yet then
+      // ensure we get a linebox if we encounter collapsible whitepace.
       m_trailingObjects.appendObjectIfNeeded(m_current.getLineLayoutItem());
     }
   }
 
   m_width.addUncommittedWidth(
       (inlineLogicalWidthFromAncestorsIfNeeded(m_current.getLineLayoutItem()) +
        borderPaddingMarginStart(flowBox) + borderPaddingMarginEnd(flowBox))
           .toFloat());
 }
 
@@ skipping 40 matching lines @@
       m_ignoringSpaces = true;
     }
     if (LineLayoutListMarker(m_current.getLineLayoutItem()).isInside())
       m_width.addUncommittedWidth(replacedLogicalWidth.toFloat());
   } else {
     m_width.addUncommittedWidth(replacedLogicalWidth.toFloat());
   }
   if (m_current.getLineLayoutItem().isRubyRun())
     m_width.applyOverhang(LineLayoutRubyRun(m_current.getLineLayoutItem()),
                           m_lastObject, m_nextObject);
-  // Update prior line break context characters, using U+FFFD (OBJECT REPLACEMENT CHARACTER) for replaced element.
+  // Update prior line break context characters, using U+FFFD (OBJECT
+  // REPLACEMENT CHARACTER) for replaced element.
   m_layoutTextInfo.m_lineBreakIterator.updatePriorContext(replacementCharacter);
 }
 
 inline void nextCharacter(UChar& currentCharacter,
                           UChar& lastCharacter,
                           UChar& secondToLastCharacter) {
   secondToLastCharacter = lastCharacter;
   lastCharacter = currentCharacter;
 }
 
@@ skipping 223 matching lines @@
              : m_current.previousInSameNode() == softHyphenCharacter;
 }
 
 inline bool BreakingContext::handleText(WordMeasurements& wordMeasurements,
                                         bool& hyphenated) {
   if (!m_current.offset())
     m_appliedStartWidth = false;
 
   LineLayoutText layoutText(m_current.getLineLayoutItem());
 
-  // If we have left a no-wrap inline and entered an autowrap inline while ignoring spaces
-  // then we need to mark the start of the autowrap inline as a potential linebreak now.
+  // If we have left a no-wrap inline and entered an autowrap inline while
+  // ignoring spaces then we need to mark the start of the autowrap inline as a
+  // potential linebreak now.
   if (m_autoWrap && !ComputedStyle::autoWrap(m_lastWS) && m_ignoringSpaces) {
     m_width.commit();
     m_lineBreak.moveToStartOf(m_current.getLineLayoutItem());
   }
 
   const ComputedStyle& style = layoutText.styleRef(m_lineInfo.isFirstLine());
   const Font& font = style.font();
 
   unsigned lastSpace = m_current.offset();
   float wordSpacing = m_currentStyle->wordSpacing();
   float lastSpaceWordSpacing = 0;
   float wordSpacingForWordMeasurement = 0;
 
   float widthFromLastBreakingOpportunity = m_width.uncommittedWidth();
   float charWidth = 0;
-  // Auto-wrapping text should wrap in the middle of a word only if it could not wrap before the word,
-  // which is only possible if the word is the first thing on the line, that is, if |w| is zero.
+  // Auto-wrapping text should wrap in the middle of a word only if it could not
+  // wrap before the word, which is only possible if the word is the first thing
+  // on the line, that is, if |w| is zero.
   bool breakWords =
       m_currentStyle->breakWords() &&
       ((m_autoWrap && !m_width.committedWidth()) || m_currWS == PRE);
   bool midWordBreak = false;
   bool breakAll =
       m_currentStyle->wordBreak() == BreakAllWordBreak && m_autoWrap;
   bool keepAll = m_currentStyle->wordBreak() == KeepAllWordBreak && m_autoWrap;
   bool prohibitBreakInside = m_currentStyle->hasTextCombine() &&
                              layoutText.isCombineText() &&
                              LineLayoutTextCombine(layoutText).isCombined();
 
-  // This is currently only used for word-break: break-all, specifically for the case
-  // where we have a break opportunity within a word, then a string of non-breakable
-  // content that ends up making our word wider than the current line.
+  // This is currently only used for word-break: break-all, specifically for the
+  // case where we have a break opportunity within a word, then a string of non-
+  // breakable content that ends up making our word wider than the current line.
   // See: fast/css3-text/css3-word-break/word-break-all-wrap-with-floats.html
   float widthMeasurementAtLastBreakOpportunity = 0;
 
   Hyphenation* hyphenation = style.getHyphenation();
   bool disableSoftHyphen = style.getHyphens() == HyphensNone;
   float hyphenWidth = 0;
 
   if (layoutText.isSVGInlineText()) {
     breakWords = false;
     breakAll = false;
@@ skipping 64 matching lines @@
     int nextBreakablePosition = m_current.nextBreakablePosition();
     bool betweenWords =
         c == newlineCharacter ||
         (m_currWS != PRE && !m_atStart &&
          m_layoutTextInfo.m_lineBreakIterator.isBreakable(
              m_current.offset(), nextBreakablePosition, lineBreakType) &&
          (!disableSoftHyphen ||
           m_current.previousInSameNode() != softHyphenCharacter));
     m_current.setNextBreakablePosition(nextBreakablePosition);
 
-    // If we're in the middle of a word or at the start of a new one and can't break there, then continue to the next character.
+    // If we're in the middle of a word or at the start of a new one and can't
+    // break there, then continue to the next character.
     if (!betweenWords && !midWordBreak) {
       if (m_ignoringSpaces) {
         // Stop ignoring spaces and begin at this
         // new point.
         lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0;
         wordSpacingForWordMeasurement =
             (applyWordSpacing && wordMeasurements.last().width) ? wordSpacing
                                                                 : 0;
         stopIgnoringSpaces(lastSpace);
       }
 
       prepareForNextCharacter(layoutText, prohibitBreakInside,
                               previousCharacterIsSpace);
       m_atStart = false;
       nextCharacter(c, lastCharacter, secondToLastCharacter);
       continue;
     }
 
-    // If we're collapsing space and we're at a collapsible space such as a space or tab, continue to the next character.
+    // If we're collapsing space and we're at a collapsible space such as a
+    // space or tab, continue to the next character.
     if (m_ignoringSpaces && m_currentCharacterIsSpace) {
       lastSpaceWordSpacing = 0;
       // Just keep ignoring these spaces.
       nextCharacter(c, lastCharacter, secondToLastCharacter);
       continue;
     }
 
-    // We're in the first whitespace after a word or in whitespace that we don't collapse, which means we may have a breaking opportunity here.
+    // We're in the first whitespace after a word or in whitespace that we don't
+    // collapse, which means we may have a breaking opportunity here.
 
-    // If we're here and we're collapsing space then the current character isn't a form of whitespace we can collapse. Stop ignoring spaces.
+    // If we're here and we're collapsing space then the current character isn't
+    // a form of whitespace we can collapse. Stop ignoring spaces.
     bool stoppedIgnoringSpaces = false;
     if (m_ignoringSpaces) {
       lastSpaceWordSpacing = 0;
       wordSpacingForWordMeasurement = 0;
       stoppedIgnoringSpaces = true;
       stopIgnoringSpaces(lastSpace);
     }
 
-    // Update our tally of the width since the last breakable position with the width of the word we're now at the end of.
+    // Update our tally of the width since the last breakable position with the
+    // width of the word we're now at the end of.
     float lastWidthMeasurement;
     WordMeasurement& wordMeasurement = calculateWordWidth(
         wordMeasurements, layoutText, lastSpace, lastWidthMeasurement,
         wordSpacingForWordMeasurement, font, wordTrailingSpaceWidth, c);
     lastWidthMeasurement += lastSpaceWordSpacing;
     m_width.addUncommittedWidth(lastWidthMeasurement);
 
-    // We keep track of the total width contributed by trailing space as we often want to exclude it when determining
+    // We keep track of the total width contributed by trailing space as we
+    // often want to exclude it when determining
     // if a run fits on a line.
     if (m_collapseWhiteSpace && previousCharacterIsSpace &&
         m_currentCharacterIsSpace && lastWidthMeasurement)
       m_width.setTrailingWhitespaceWidth(lastWidthMeasurement);
 
-    // If this is the end of the first word in run of text then make sure we apply the width from any leading inlines.
-    // For example: '<span style="margin-left: 5px;"><span style="margin-left: 10px;">FirstWord</span></span>' would
-    // apply a width of 15px from the two span ancestors.
+    // If this is the end of the first word in run of text then make sure we
+    // apply the width from any leading inlines.
+    // For example: '<span style="margin-left: 5px;"><span style="margin-left:
+    // 10px;">FirstWord</span></span>' would apply a width of 15px from the two
+    // span ancestors.
     if (!m_appliedStartWidth) {
       m_width.addUncommittedWidth(
           inlineLogicalWidthFromAncestorsIfNeeded(m_current.getLineLayoutItem(),
                                                   true, false)
               .toFloat());
       m_appliedStartWidth = true;
     }
 
     midWordBreak = false;
     if (!m_width.fitsOnLine()) {
@@ skipping 14 matching lines @@
                       lastSpaceWordSpacing, wordMeasurement)) {
           m_width.addUncommittedWidth(wordMeasurement.width);
           hyphenated = true;
           m_atEnd = true;
           return false;
         }
         m_width.addUncommittedWidth(wordMeasurement.width);
       }
     }
 
-    // If we haven't hit a breakable position yet and already don't fit on the line try to move below any floats.
+    // If we haven't hit a breakable position yet and already don't fit on the
+    // line try to move below any floats.
     if (!m_width.committedWidth() && m_autoWrap && !m_width.fitsOnLine() &&
         !widthMeasurementAtLastBreakOpportunity) {
       float availableWidthBefore = m_width.availableWidth();
       m_width.fitBelowFloats(m_lineInfo.isFirstLine());
-      // If availableWidth changes by moving the line below floats, needs to measure midWordBreak again.
+      // If availableWidth changes by moving the line below floats, needs to
+      // measure midWordBreak again.
       if (midWordBreak && availableWidthBefore != m_width.availableWidth())
         midWordBreak = false;
     }
 
-    // If there is a soft-break available at this whitespace position then take it.
+    // If there is a soft-break available at this whitespace position then take
+    // it.
     applyWordSpacing = wordSpacing && m_currentCharacterIsSpace;
     if (canBreakAtWhitespace(breakWords, wordMeasurement, stoppedIgnoringSpaces,
                              charWidth, hyphenated, disableSoftHyphen,
                              hyphenWidth, betweenWords, midWordBreak,
                              canBreakMidWord, previousCharacterIsSpace,
                              lastWidthMeasurement, layoutText, font,
                              applyWordSpacing, wordSpacing))
       return false;
 
-    // If there is a hard-break available at this whitespace position then take it.
+    // If there is a hard-break available at this whitespace position then take
+    // it.
     if (c == newlineCharacter && m_preservesNewline) {
       if (!stoppedIgnoringSpaces && m_current.offset())
         m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
       m_lineBreak.moveTo(m_current.getLineLayoutItem(), m_current.offset(),
                          m_current.nextBreakablePosition());
       m_lineBreak.increment();
       m_lineInfo.setPreviousLineBrokeCleanly(true);
       return true;
     }
 
-    // Auto-wrapping text should not wrap in the middle of a word once it has had an
-    // opportunity to break after a word.
+    // Auto-wrapping text should not wrap in the middle of a word once it has
+    // had an opportunity to break after a word.
     if (m_autoWrap && betweenWords) {
       m_width.commit();
       widthFromLastBreakingOpportunity = 0;
       m_lineBreak.moveTo(m_current.getLineLayoutItem(), m_current.offset(),
                          m_current.nextBreakablePosition());
       breakWords = false;
       canBreakMidWord = breakAll;
       widthMeasurementAtLastBreakOpportunity = lastWidthMeasurement;
     }
 
     if (betweenWords) {
       lastSpaceWordSpacing = applyWordSpacing ? wordSpacing : 0;
       wordSpacingForWordMeasurement =
           (applyWordSpacing && wordMeasurement.width) ? wordSpacing : 0;
       lastSpace = m_current.offset();
     }
 
-    // If we encounter a newline, or if we encounter a second space, we need to go ahead and break up
-    // this run and enter a mode where we start collapsing spaces.
+    // If we encounter a newline, or if we encounter a second space, we need to
+    // go ahead and break up this run and enter a mode where we start collapsing
+    // spaces.
     if (!m_ignoringSpaces && m_currentStyle->collapseWhiteSpace()) {
       if (m_currentCharacterIsSpace && previousCharacterIsSpace) {
         m_ignoringSpaces = true;
 
-        // We just entered a mode where we are ignoring spaces. Create a midpoint to terminate the run
-        // before the second space.
+        // We just entered a mode where we are ignoring spaces. Create a
+        // midpoint to terminate the run before the second space.
         m_lineMidpointState.startIgnoringSpaces(m_startOfIgnoredSpaces);
         m_trailingObjects.updateMidpointsForTrailingObjects(
             m_lineMidpointState, InlineIterator(),
             TrailingObjects::DoNotCollapseFirstSpace);
       }
     }
 
     prepareForNextCharacter(layoutText, prohibitBreakInside,
                             previousCharacterIsSpace);
     m_atStart = false;
@@ skipping 68 matching lines @@
     }
   }
   return false;
 }
 
 inline void BreakingContext::prepareForNextCharacter(
     const LineLayoutText& layoutText,
     bool& prohibitBreakInside,
     bool previousCharacterIsSpace) {
   if (layoutText.isSVGInlineText() && m_current.offset()) {
-    // Force creation of new InlineBoxes for each absolute positioned character (those that start new text chunks).
+    // Force creation of new InlineBoxes for each absolute positioned character
+    // (those that start new text chunks).
     if (LineLayoutSVGInlineText(layoutText)
             .characterStartsNewTextChunk(m_current.offset()))
       m_lineMidpointState.ensureCharacterGetsLineBox(m_current);
   }
   if (prohibitBreakInside) {
     m_current.setNextBreakablePosition(layoutText.textLength());
     prohibitBreakInside = false;
   }
   if (m_currentCharacterIsSpace && !previousCharacterIsSpace) {
     m_startOfIgnoredSpaces.setLineLayoutItem(m_current.getLineLayoutItem());
     m_startOfIgnoredSpaces.setOffset(m_current.offset());
   }
   if (!m_currentCharacterIsSpace && previousCharacterIsSpace) {
     if (m_autoWrap && m_currentStyle->breakOnlyAfterWhiteSpace())
       m_lineBreak.moveTo(m_current.getLineLayoutItem(), m_current.offset(),
                          m_current.nextBreakablePosition());
   }
   if (m_collapseWhiteSpace && m_currentCharacterIsSpace && !m_ignoringSpaces)
     m_trailingObjects.setTrailingWhitespace(
         LineLayoutText(m_current.getLineLayoutItem()));
   else if (!m_currentStyle->collapseWhiteSpace() || !m_currentCharacterIsSpace)
     m_trailingObjects.clear();
 }
 
 inline void BreakingContext::stopIgnoringSpaces(unsigned& lastSpace) {
   m_ignoringSpaces = false;
-  lastSpace =
-      m_current
-          .offset();  // e.g., "Foo    goo", don't add in any of the ignored spaces.
+  // e.g., "Foo    goo", don't add in any of the ignored spaces.
+  lastSpace = m_current.offset();
   m_lineMidpointState.stopIgnoringSpaces(
       InlineIterator(0, m_current.getLineLayoutItem(), m_current.offset()));
 }
 
 inline WordMeasurement& BreakingContext::calculateWordWidth(
     WordMeasurements& wordMeasurements,
     LineLayoutText& layoutText,
     unsigned lastSpace,
     float& lastWidthMeasurement,
     float wordSpacingForWordMeasurement,
@@ skipping 91 matching lines @@
     if (isBreakAtSoftHyphen() && !disableSoftHyphen)
       hyphenated = true;
     if (m_lineBreak.offset() &&
         m_lineBreak.offset() != (unsigned)wordMeasurement.endOffset &&
         !wordMeasurement.width) {
       if (charWidth) {
         wordMeasurement.endOffset = m_lineBreak.offset();
         wordMeasurement.width = charWidth;
       }
     }
-    // Didn't fit. Jump to the end unless there's still an opportunity to collapse whitespace.
+    // Didn't fit. Jump to the end unless there's still an opportunity to
+    // collapse whitespace.
     if (m_ignoringSpaces || !m_collapseWhiteSpace ||
         !m_currentCharacterIsSpace || !previousCharacterIsSpace) {
       m_atEnd = true;
       return true;
     }
   } else {
     if (!betweenWords || (midWordBreak && !m_autoWrap))
       m_width.addUncommittedWidth(-lastWidthMeasurement);
     if (hyphenWidth) {
       // Subtract the width of the soft hyphen out since we fit on a line.
@@ skipping 16 matching lines @@
   } else if (m_nextObject && m_current.getLineLayoutItem().isText() &&
              m_nextObject.isText() && !m_nextObject.isBR() &&
              (m_autoWrap || m_nextObject.style()->autoWrap())) {
     if (m_autoWrap && m_currentCharacterIsSpace) {
       checkForBreak = true;
     } else {
       LineLayoutText nextText(m_nextObject);
       if (nextText.textLength()) {
         UChar c = nextText.characterAt(0);
         // If the next item on the line is text, and if we did not end with
-        // a space, then the next text run continues our word (and so it needs to
-        // keep adding to the uncommitted width. Just update and continue.
+        // a space, then the next text run continues our word (and so it needs
+        // to keep adding to the uncommitted width. Just update and continue.
         checkForBreak =
             !m_currentCharacterIsSpace &&
             (c == spaceCharacter || c == tabulationCharacter ||
              (c == newlineCharacter && !m_nextObject.preservesNewline()));
       } else if (nextText.isWordBreak()) {
         checkForBreak = true;
       }
 
       if (!m_width.fitsOnLine() && !m_width.committedWidth())
         m_width.fitBelowFloats(m_lineInfo.isFirstLine());
@@ skipping 14 matching lines @@
         m_currentStyle->collapseWhiteSpace())
       m_trailingObjects.clear();
 
     if (m_width.committedWidth()) {
       m_atEnd = true;
       return;
     }
 
     m_width.fitBelowFloats(m_lineInfo.isFirstLine());
 
-    // |width| may have been adjusted because we got shoved down past a float (thus
-    // giving us more room), so we need to retest, and only jump to
+    // |width| may have been adjusted because we got shoved down past a float
+    // (thus giving us more room), so we need to retest, and only jump to the
     // the end label if we still don't fit on the line. -dwh
     if (!m_width.fitsOnLine()) {
       m_atEnd = true;
       return;
     }
   } else if (m_blockStyle->autoWrap() && !m_width.fitsOnLine() &&
              !m_width.committedWidth()) {
-    // If the container autowraps but the current child does not then we still need to ensure that it
-    // wraps and moves below any floats.
+    // If the container autowraps but the current child does not then we still
+    // need to ensure that it wraps and moves below any floats.
     m_width.fitBelowFloats(m_lineInfo.isFirstLine());
   }
 
   if (!m_current.getLineLayoutItem().isFloatingOrOutOfFlowPositioned()) {
     m_lastObject = m_current.getLineLayoutItem();
     if (m_lastObject.isAtomicInlineLevel() && m_autoWrap &&
         (!m_lastObject.isImage() || m_allowImagesToBreak) &&
         (!m_lastObject.isListMarker() ||
          LineLayoutListMarker(m_lastObject).isInside()) &&
         !m_lastObject.isRubyRun()) {
@@ skipping 13 matching lines @@
 
   if (style.getTextIndentType() == TextIndentHanging)
     indentText = indentText == IndentText ? DoNotIndentText : IndentText;
 
   return indentText;
 }
 
 }  // namespace blink
 
 #endif  // BreakingContextInlineHeaders_h