Reformat comments in core/layout

third_party/WebKit/Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 97 matching lines @@
   unsigned length = string->length();
   const StringImpl& input = *string->impl();
 
   if (length >= std::numeric_limits<unsigned>::max())
     CRASH();
 
   StringBuffer<UChar> stringWithPrevious(length + 1);
   stringWithPrevious[0] =
       previous == noBreakSpaceCharacter ? spaceCharacter : previous;
   for (unsigned i = 1; i < length + 1; i++) {
-    // Replace &nbsp with a real space since ICU no longer treats &nbsp as a word separator.
+    // Replace &nbsp with a real space since ICU no longer treats &nbsp as a
+    // word separator.
     if (input[i - 1] == noBreakSpaceCharacter)
       stringWithPrevious[i] = spaceCharacter;
     else
       stringWithPrevious[i] = input[i - 1];
   }
 
   TextBreakIterator* boundary =
       wordBreakIterator(stringWithPrevious.characters(), length + 1);
   if (!boundary)
     return;
@@ skipping 23 matching lines @@
       m_containsReversedText(false),
       m_knownToHaveNoOverflowAndNoFallbackFonts(false),
       m_minWidth(-1),
       m_maxWidth(-1),
       m_firstLineMinWidth(0),
       m_lastLineLineMinWidth(0),
       m_text(std::move(str)),
       m_firstTextBox(nullptr),
       m_lastTextBox(nullptr) {
   ASSERT(m_text);
-  // FIXME: Some clients of LayoutText (and subclasses) pass Document as node to create anonymous layoutObject.
+  // FIXME: Some clients of LayoutText (and subclasses) pass Document as node to
+  // create anonymous layoutObject.
   // They should be switched to passing null and using setDocumentForAnonymous.
   if (node && node->isDocumentNode())
     setDocumentForAnonymous(toDocument(node));
 
   m_canUseSimpleFontCodePath = computeCanUseSimpleFontCodePath();
   setIsText();
 
   view()->frameView()->incrementVisuallyNonEmptyCharacterCount(m_text.length());
 }
 
 #if ENABLE(ASSERT)
 
 LayoutText::~LayoutText() {
   ASSERT(!m_firstTextBox);
   ASSERT(!m_lastTextBox);
 }
 
 #endif
 
 bool LayoutText::isTextFragment() const {
   return false;
 }
 
 bool LayoutText::isWordBreak() const {
   return false;
 }
 
 void LayoutText::styleDidChange(StyleDifference diff,
                                 const ComputedStyle* oldStyle) {
-  // There is no need to ever schedule paint invalidations from a style change of a text run, since
-  // we already did this for the parent of the text run.
-  // We do have to schedule layouts, though, since a style change can force us to
-  // need to relayout.
+  // There is no need to ever schedule paint invalidations from a style change
+  // of a text run, since we already did this for the parent of the text run.
+  // We do have to schedule layouts, though, since a style change can force us
+  // to need to relayout.
   if (diff.needsFullLayout()) {
     setNeedsLayoutAndPrefWidthsRecalc(LayoutInvalidationReason::StyleChange);
     m_knownToHaveNoOverflowAndNoFallbackFonts = false;
   }
 
   const ComputedStyle& newStyle = styleRef();
   ETextTransform oldTransform = oldStyle ? oldStyle->textTransform() : TTNONE;
   ETextSecurity oldSecurity = oldStyle ? oldStyle->textSecurity() : TSNONE;
   if (oldTransform != newStyle.textTransform() ||
       oldSecurity != newStyle.textSecurity())
@@ skipping 92 matching lines @@
 
 PassRefPtr<StringImpl> LayoutText::originalText() const {
   Node* e = node();
   return (e && e->isTextNode()) ? toText(e)->dataImpl() : 0;
 }
 
 String LayoutText::plainText() const {
   if (node())
     return blink::plainText(EphemeralRange::rangeOfContents(*node()));
 
-  // FIXME: this is just a stopgap until TextIterator is adapted to support generated text.
+  // FIXME: this is just a stopgap until TextIterator is adapted to support
+  // generated text.
   StringBuilder plainTextBuilder;
   for (InlineTextBox* textBox = firstTextBox(); textBox;
        textBox = textBox->nextTextBox()) {
     String text = m_text.substring(textBox->start(), textBox->len())
                       .simplifyWhiteSpace(WTF::DoNotStripWhiteSpace);
     plainTextBuilder.append(text);
     if (textBox->nextTextBox() &&
         textBox->nextTextBox()->start() > textBox->end() && text.length() &&
         !text.right(1).containsOnlyWhitespace())
       plainTextBuilder.append(spaceCharacter);
@@ skipping 28 matching lines @@
     }
     return FloatRect(r);
   }
   return FloatRect();
 }
 
 void LayoutText::absoluteRectsForRange(Vector<IntRect>& rects,
                                        unsigned start,
                                        unsigned end,
                                        bool useSelectionHeight) {
-  // Work around signed/unsigned issues. This function takes unsigneds, and is often passed UINT_MAX
-  // to mean "all the way to the end". InlineTextBox coordinates are unsigneds, so changing this
-  // function to take ints causes various internal mismatches. But selectionRect takes ints, and
-  // passing UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take unsigneds, but
-  // that would cause many ripple effects, so for now we'll just clamp our unsigned parameters to INT_MAX.
+  // Work around signed/unsigned issues. This function takes unsigneds, and is
+  // often passed UINT_MAX to mean "all the way to the end". InlineTextBox
+  // coordinates are unsigneds, so changing this function to take ints causes
+  // various internal mismatches. But selectionRect takes ints, and passing
+  // UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take
+  // unsigneds, but that would cause many ripple effects, so for now we'll just
+  // clamp our unsigned parameters to INT_MAX.
   ASSERT(end == UINT_MAX || end <= INT_MAX);
   ASSERT(start <= INT_MAX);
   start = std::min(start, static_cast<unsigned>(INT_MAX));
   end = std::min(end, static_cast<unsigned>(INT_MAX));
 
   for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
-    // Note: box->end() returns the index of the last character, not the index past it
+    // Note: box->end() returns the index of the last character, not the index
+    // past it
     if (start <= box->start() && box->end() < end) {
       FloatRect r(box->calculateBoundaries());
       if (useSelectionHeight) {
         LayoutRect selectionRect = box->localSelectionRect(start, end);
         if (box->isHorizontal()) {
           r.setHeight(selectionRect.height().toFloat());
           r.setY(selectionRect.y().toFloat());
         } else {
           r.setWidth(selectionRect.width().toFloat());
           r.setX(selectionRect.x().toFloat());
         }
       }
       rects.append(localToAbsoluteQuad(r).enclosingBoundingBox());
     } else {
-      // FIXME: This code is wrong. It's converting local to absolute twice. http://webkit.org/b/65722
+      // FIXME: This code is wrong. It's converting local to absolute twice.
+      // http://webkit.org/b/65722
       FloatRect rect = localQuadForTextBox(box, start, end, useSelectionHeight);
       if (!rect.isZero())
         rects.append(localToAbsoluteQuad(rect).enclosingBoundingBox());
     }
   }
 }
 
 static IntRect ellipsisRectForBox(InlineTextBox* box,
                                   unsigned startPos,
                                   unsigned endPos) {
   if (!box)
     return IntRect();
 
   unsigned short truncation = box->truncation();
   if (truncation == cNoTruncation)
     return IntRect();
 
   IntRect rect;
   if (EllipsisBox* ellipsis = box->root().ellipsisBox()) {
     int ellipsisStartPosition = std::max<int>(startPos - box->start(), 0);
     int ellipsisEndPosition = std::min<int>(endPos - box->start(), box->len());
 
-    // The ellipsis should be considered to be selected if the end of
-    // the selection is past the beginning of the truncation and the
-    // beginning of the selection is before or at the beginning of the truncation.
+    // The ellipsis should be considered to be selected if the end of the
+    // selection is past the beginning of the truncation and the beginning of
+    // the selection is before or at the beginning of the truncation.
     if (ellipsisEndPosition >= truncation &&
         ellipsisStartPosition <= truncation)
       return ellipsis->selectionRect();
   }
 
   return IntRect();
 }
 
 void LayoutText::quads(Vector<FloatQuad>& quads,
                        ClippingOption option,
                        LocalOrAbsoluteOption localOrAbsolute) const {
   for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
     FloatRect boundaries(box->calculateBoundaries());
 
     // Shorten the width of this text box if it ends in an ellipsis.
-    // FIXME: ellipsisRectForBox should switch to return FloatRect soon with the subpixellayout branch.
+    // FIXME: ellipsisRectForBox should switch to return FloatRect soon with the
+    // subpixellayout branch.
     IntRect ellipsisRect = (option == ClipToEllipsis)
                                ? ellipsisRectForBox(box, 0, textLength())
                                : IntRect();
     if (!ellipsisRect.isEmpty()) {
       if (style()->isHorizontalWritingMode())
         boundaries.setWidth(ellipsisRect.maxX() - boundaries.x());
       else
         boundaries.setHeight(ellipsisRect.maxY() - boundaries.y());
     }
     if (localOrAbsolute == AbsoluteQuads)
       quads.append(localToAbsoluteQuad(boundaries));
     else
       quads.append(boundaries);
   }
 }
 
 void LayoutText::absoluteQuads(Vector<FloatQuad>& quads) const {
   this->quads(quads, NoClipping, AbsoluteQuads);
 }
 
 void LayoutText::absoluteQuadsForRange(Vector<FloatQuad>& quads,
                                        unsigned start,
                                        unsigned end,
                                        bool useSelectionHeight) {
-  // Work around signed/unsigned issues. This function takes unsigneds, and is often passed UINT_MAX
-  // to mean "all the way to the end". InlineTextBox coordinates are unsigneds, so changing this
-  // function to take ints causes various internal mismatches. But selectionRect takes ints, and
-  // passing UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take unsigneds, but
-  // that would cause many ripple effects, so for now we'll just clamp our unsigned parameters to INT_MAX.
+  // Work around signed/unsigned issues. This function takes unsigneds, and is
+  // often passed UINT_MAX to mean "all the way to the end". InlineTextBox
+  // coordinates are unsigneds, so changing this function to take ints causes
+  // various internal mismatches. But selectionRect takes ints, and passing
+  // UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take
+  // unsigneds, but that would cause many ripple effects, so for now we'll just
+  // clamp our unsigned parameters to INT_MAX.
   ASSERT(end == UINT_MAX || end <= INT_MAX);
   ASSERT(start <= INT_MAX);
   start = std::min(start, static_cast<unsigned>(INT_MAX));
   end = std::min(end, static_cast<unsigned>(INT_MAX));
 
   const unsigned caretMinOffset = static_cast<unsigned>(this->caretMinOffset());
   const unsigned caretMaxOffset = static_cast<unsigned>(this->caretMaxOffset());
 
   // Narrows |start| and |end| into |caretMinOffset| and |careMaxOffset|
   // to ignore unrendered leading and trailing whitespaces.
   start = std::min(std::max(caretMinOffset, start), caretMaxOffset);
   end = std::min(std::max(caretMinOffset, end), caretMaxOffset);
 
   for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
-    // Note: box->end() returns the index of the last character, not the index past it
+    // Note: box->end() returns the index of the last character, not the index
+    // past it
     if (start <= box->start() && box->end() < end) {
       LayoutRect r(box->calculateBoundaries());
       if (useSelectionHeight) {
         LayoutRect selectionRect = box->localSelectionRect(start, end);
         if (box->isHorizontal()) {
           r.setHeight(selectionRect.height());
           r.setY(selectionRect.y());
         } else {
           r.setWidth(selectionRect.width());
           r.setX(selectionRect.x());
@@ skipping 22 matching lines @@
   AlwaysUpstream,
   UpstreamIfPositionIsNotAtStart
 };
 
 static bool lineDirectionPointFitsInBox(
     int pointLineDirection,
     InlineTextBox* box,
     ShouldAffinityBeDownstream& shouldAffinityBeDownstream) {
   shouldAffinityBeDownstream = AlwaysDownstream;
 
-  // the x coordinate is equal to the left edge of this box
-  // the affinity must be downstream so the position doesn't jump back to the previous line
-  // except when box is the first box in the line
+  // the x coordinate is equal to the left edge of this box the affinity must be
+  // downstream so the position doesn't jump back to the previous line except
+  // when box is the first box in the line
   if (pointLineDirection <= box->logicalLeft()) {
     shouldAffinityBeDownstream = !box->prevLeafChild()
                                      ? UpstreamIfPositionIsNotAtStart
                                      : AlwaysDownstream;
     return true;
   }
 
   // and the x coordinate is to the left of the right edge of this box
   // check to see if position goes in this box
   if (pointLineDirection < box->logicalRight()) {
     shouldAffinityBeDownstream = UpstreamIfPositionIsNotAtStart;
     return true;
   }
 
   // box is first on line
   // and the x coordinate is to the left of the first text box left edge
   if (!box->prevLeafChildIgnoringLineBreak() &&
       pointLineDirection < box->logicalLeft())
     return true;
 
   if (!box->nextLeafChildIgnoringLineBreak()) {
-    // box is last on line
-    // and the x coordinate is to the right of the last text box right edge
-    // generate VisiblePosition, use TextAffinity::Upstream affinity if possible
+    // box is last on line and the x coordinate is to the right of the last text
+    // box right edge generate VisiblePosition, use TextAffinity::Upstream
+    // affinity if possible
     shouldAffinityBeDownstream = UpstreamIfPositionIsNotAtStart;
     return true;
   }
 
   return false;
 }
 
 static PositionWithAffinity createPositionWithAffinityForBox(
     const InlineBox* box,
     int offset,
@@ skipping 216 matching lines @@
       break;
     case JUSTIFY:
     case TASTART:
       rightAligned = !cbStyle.isLeftToRightDirection();
       break;
     case TAEND:
       rightAligned = cbStyle.isLeftToRightDirection();
       break;
   }
 
-  // for unicode-bidi: plaintext, use inlineBoxBidiLevel() to test the correct direction for the cursor.
+  // for unicode-bidi: plaintext, use inlineBoxBidiLevel() to test the correct
+  // direction for the cursor.
   if (rightAligned && style()->unicodeBidi() == Plaintext) {
     if (inlineBox->bidiLevel() % 2 != 1)
       rightAligned = false;
   }
 
   if (rightAligned) {
     left = std::max(left, leftEdge);
     left = std::min(left, rootRight - caretWidth());
   } else {
     left = std::min(left, rightEdge - caretWidthRightOfOffset);
@@ skipping 46 matching lines @@
                                    bool& hasBreakableChar,
                                    bool& hasBreak,
                                    LayoutUnit& firstLineMaxWidth,
                                    LayoutUnit& lastLineMaxWidth,
                                    LayoutUnit& minWidth,
                                    LayoutUnit& maxWidth,
                                    bool& stripFrontSpaces,
                                    TextDirection direction) {
   float floatMinWidth = 0.0f, floatMaxWidth = 0.0f;
 
-  // Convert leadWidth to a float here, to avoid multiple implict conversions below.
+  // Convert leadWidth to a float here, to avoid multiple implict conversions
+  // below.
   float leadWidth = leadWidthLayoutUnit.toFloat();
 
   bool collapseWhiteSpace = style()->collapseWhiteSpace();
   if (!collapseWhiteSpace)
     stripFrontSpaces = false;
 
   if (m_hasTab || preferredLogicalWidthsDirty())
     computePreferredLogicalWidths(leadWidth);
 
   hasBreakableStart = !stripFrontSpaces && m_hasBreakableStart;
@@ skipping 296 matching lines @@
       }
     }
 
     // Terminate word boundary at bidi run boundary.
     if (run)
       j = std::min(j, run->stop() + 1);
     int wordLen = j - i;
     if (wordLen) {
       bool isSpace = (j < len) && c == spaceCharacter;
 
-      // Non-zero only when kerning is enabled, in which case we measure words with their trailing
-      // space, then subtract its width.
+      // Non-zero only when kerning is enabled, in which case we measure words
+      // with their trailing space, then subtract its width.
       float wordTrailingSpaceWidth = 0;
       if (isSpace &&
           (f.getFontDescription().getTypesettingFeatures() & Kerning)) {
         ASSERT(textDirection >= 0 && textDirection <= 1);
         if (!cachedWordTrailingSpaceWidth[textDirection])
           cachedWordTrailingSpaceWidth[textDirection] =
               f.width(constructTextRun(f, &spaceCharacter, 1, styleToUse,
                                        textDirection)) +
               wordSpacing;
         wordTrailingSpaceWidth = cachedWordTrailingSpaceWidth[textDirection];
@@ skipping 46 matching lines @@
               f, lastWordBoundary, j - lastWordBoundary, leadWidth,
               currMaxWidth, textDirection, &fallbackFonts, &glyphBounds);
         lastWordBoundary = j;
       }
 
       bool isCollapsibleWhiteSpace =
           (j < len) && styleToUse.isCollapsibleWhiteSpace(c);
       if (j < len && styleToUse.autoWrap())
         m_hasBreakableChar = true;
 
-      // Add in wordSpacing to our currMaxWidth, but not if this is the last word on a line or the
+      // Add in wordSpacing to our currMaxWidth, but not if this is the last
+      // word on a line or the
       // last word in the run.
       if (wordSpacing && (isSpace || isCollapsibleWhiteSpace) &&
           !containsOnlyWhitespace(j, len - j))
         currMaxWidth += wordSpacing;
 
       if (firstWord) {
         firstWord = false;
-        // If the first character in the run is breakable, then we consider ourselves to have a beginning
-        // minimum width of 0, since a break could occur right before our run starts, preventing us from ever
-        // being appended to a previous text run when considering the total minimum width of the containing block.
+        // If the first character in the run is breakable, then we consider
+        // ourselves to have a beginning minimum width of 0, since a break could
+        // occur right before our run starts, preventing us from ever being
+        // appended to a previous text run when considering the total minimum
+        // width of the containing block.
         if (hasBreak)
           m_hasBreakableChar = true;
         m_firstLineMinWidth = hasBreak ? 0 : currMinWidth;
       }
       m_lastLineLineMinWidth = currMinWidth;
 
       if (currMinWidth > m_minWidth)
         m_minWidth = currMinWidth;
       currMinWidth = 0;
 
       i += wordLen - 1;
     } else {
-      // Nowrap can never be broken, so don't bother setting the
-      // breakable character boolean. Pre can only be broken if we encounter a newline.
+      // Nowrap can never be broken, so don't bother setting the breakable
+      // character boolean. Pre can only be broken if we encounter a newline.
       if (style()->autoWrap() || isNewline)
         m_hasBreakableChar = true;
 
       if (currMinWidth > m_minWidth)
         m_minWidth = currMinWidth;
       currMinWidth = 0;
 
-      if (isNewline) {  // Only set if preserveNewline was true and we saw a newline.
+      // Only set if preserveNewline was true and we saw a newline.
+      if (isNewline) {
         if (firstLine) {
           firstLine = false;
           leadWidth = 0;
           if (!styleToUse.autoWrap())
             m_firstLineMinWidth = currMaxWidth;
         }
 
         if (currMaxWidth > m_maxWidth)
           m_maxWidth = currMaxWidth;
         currMaxWidth = 0;
@@ skipping 55 matching lines @@
     if (!style()->isCollapsibleWhiteSpace(characters16()[i]))
       return false;
   }
   return true;
 }
 
 bool LayoutText::isRenderedCharacter(int offsetInNode) const {
   for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
     if (offsetInNode < static_cast<int>(box->start()) &&
         !containsReversedText()) {
-      // The offset we're looking for is before this node
-      // this means the offset must be in content that is
-      // not laid out. Return false.
+      // The offset we're looking for is before this node this means the offset
+      // must be in content that is not laid out. Return false.
       return false;
     }
     if (offsetInNode >= static_cast<int>(box->start()) &&
         offsetInNode < static_cast<int>(box->start() + box->len()))
       return true;
   }
 
   return false;
 }
 
@@ skipping 68 matching lines @@
   unsigned oldLen = textLength();
   unsigned newLen = text->length();
   int delta = newLen - oldLen;
   unsigned end = len ? offset + len - 1 : offset;
 
   RootInlineBox* firstRootBox = nullptr;
   RootInlineBox* lastRootBox = nullptr;
 
   bool dirtiedLines = false;
 
-  // Dirty all text boxes that include characters in between offset and offset+len.
+  // Dirty all text boxes that include characters in between offset and
+  // offset+len.
   for (InlineTextBox* curr = firstTextBox(); curr; curr = curr->nextTextBox()) {
-    // FIXME: This shouldn't rely on the end of a dirty line box. See https://bugs.webkit.org/show_bug.cgi?id=97264
+    // FIXME: This shouldn't rely on the end of a dirty line box. See
+    // https://bugs.webkit.org/show_bug.cgi?id=97264
     // Text run is entirely before the affected range.
     if (curr->end() < offset)
       continue;
 
     // Text run is entirely after the affected range.
     if (curr->start() > end) {
       curr->offsetRun(delta);
       RootInlineBox* root = &curr->root();
       if (!firstRootBox) {
         firstRootBox = root;
-        // The affected area was in between two runs. Go ahead and mark the root box of
-        // the run after the affected area as dirty.
+        // The affected area was in between two runs. Go ahead and mark the root
+        // box of the run after the affected area as dirty.
         firstRootBox->markDirty();
         dirtiedLines = true;
       }
       lastRootBox = root;
     } else if (curr->end() >= offset && curr->end() <= end) {
       // Text run overlaps with the left end of the affected range.
       curr->dirtyLineBoxes();
       dirtiedLines = true;
     } else if (curr->start() <= offset && curr->end() >= end) {
       // Text run subsumes the affected range.
       curr->dirtyLineBoxes();
       dirtiedLines = true;
     } else if (curr->start() <= end && curr->end() >= end) {
       // Text run overlaps with right end of the affected range.
       curr->dirtyLineBoxes();
       dirtiedLines = true;
     }
   }
 
-  // Now we have to walk all of the clean lines and adjust their cached line break information
-  // to reflect our updated offsets.
+  // Now we have to walk all of the clean lines and adjust their cached line
+  // break information to reflect our updated offsets.
   if (lastRootBox)
     lastRootBox = lastRootBox->nextRootBox();
   if (firstRootBox) {
     RootInlineBox* prev = firstRootBox->prevRootBox();
     if (prev)
       firstRootBox = prev;
   } else if (lastTextBox()) {
     ASSERT(!lastRootBox);
     firstRootBox = &lastTextBox()->root();
     firstRootBox->markDirty();
@@ skipping 112 matching lines @@
     lastTypedCharacterOffsetToReveal =
         secureTextTimer->lastTypedCharacterOffset();
     if (lastTypedCharacterOffsetToReveal >= 0)
       revealedText = m_text[lastTypedCharacterOffsetToReveal];
   }
 
   m_text.fill(mask);
   if (lastTypedCharacterOffsetToReveal >= 0) {
     m_text.replace(lastTypedCharacterOffsetToReveal, 1,
                    String(&revealedText, 1));
-    // m_text may be updated later before timer fires. We invalidate the lastTypedCharacterOffset to avoid inconsistency.
+    // m_text may be updated later before timer fires. We invalidate the
+    // lastTypedCharacterOffset to avoid inconsistency.
     secureTextTimer->invalidate();
   }
 }
 
 void LayoutText::setText(PassRefPtr<StringImpl> text, bool force) {
   ASSERT(text);
 
   if (!force && equal(m_text.impl(), text.get()))
     return;
 
   setTextInternal(std::move(text));
-  // If preferredLogicalWidthsDirty() of an orphan child is true, LayoutObjectChildList::
-  // insertChildNode() fails to set true to owner. To avoid that, we call
-  // setNeedsLayoutAndPrefWidthsRecalc() only if this LayoutText has parent.
+  // If preferredLogicalWidthsDirty() of an orphan child is true,
+  // LayoutObjectChildList::insertChildNode() fails to set true to owner.
+  // To avoid that, we call setNeedsLayoutAndPrefWidthsRecalc() only if this
+  // LayoutText has parent.
   if (parent())
     setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
         LayoutInvalidationReason::TextChanged);
   m_knownToHaveNoOverflowAndNoFallbackFonts = false;
 
   if (AXObjectCache* cache = document().existingAXObjectCache())
     cache->textChanged(this);
 }
 
 void LayoutText::dirtyOrDeleteLineBoxesIfNeeded(bool fullLayout) {
@@ skipping 303 matching lines @@
   LayoutRect rect = LayoutRect(
       IntRect(firstRunX(), firstRunY(), linesBox.width(), linesBox.height()));
   LayoutBlock* block = containingBlock();
   if (block && hasTextBoxes())
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 }  // namespace blink