Reformat comments in core/layout up until LayoutTableRow

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc.
+ *               All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
- * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
+ * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
+ *               (http://www.torchmobile.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
  * 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 98 matching lines @@
 
 struct SameSizeAsLayoutObject : DisplayItemClient {
   virtual ~SameSizeAsLayoutObject() {}  // Allocate vtable pointer.
   void* pointers[5];
   Member<void*> members[1];
 #if ENABLE(ASSERT)
   unsigned m_debugBitfields : 2;
 #endif
   unsigned m_bitfields;
   unsigned m_bitfields2;
-  LayoutRect rect;  // Stores the previous paint invalidation rect.
-  LayoutPoint
-      position;  // Stores the previous position from the paint invalidation container.
+  LayoutRect rect;       // Stores the previous paint invalidation rect.
+  LayoutPoint position;  // Stores the previous position from the paint
+                         // invalidation container.
 };
 
 static_assert(sizeof(LayoutObject) == sizeof(SameSizeAsLayoutObject),
               "LayoutObject should stay small");
 
 bool LayoutObject::s_affectsParentBlock = false;
 
-// The pointer to paint properties is implemented as a global hash map temporarily,
+// The pointer to paint properties is implemented as a global hash map
+// temporarily,
 // to avoid memory regression during the transition towards SPv2.
 typedef HashMap<const LayoutObject*, std::unique_ptr<ObjectPaintProperties>>
     ObjectPaintPropertiesMap;
 static ObjectPaintPropertiesMap& objectPaintPropertiesMap() {
   DEFINE_STATIC_LOCAL(ObjectPaintPropertiesMap, staticObjectPaintPropertiesMap,
                       ());
   return staticObjectPaintPropertiesMap;
 }
 
 void* LayoutObject::operator new(size_t sz) {
@@ skipping 11 matching lines @@
                                          const ComputedStyle& style) {
   ASSERT(isAllowedToModifyLayoutTreeStructure(element->document()));
 
   // Minimal support for content properties replacing an entire element.
   // Works only if we have exactly one piece of content and it's a URL.
   // Otherwise acts as if we didn't support this feature.
   const ContentData* contentData = style.contentData();
   if (contentData && !contentData->next() && contentData->isImage() &&
       !element->isPseudoElement()) {
     LayoutImage* image = new LayoutImage(element);
-    // LayoutImageResourceStyleImage requires a style being present on the image but we don't want to
-    // trigger a style change now as the node is not fully attached. Moving this code to style change
-    // doesn't make sense as it should be run once at layoutObject creation.
+    // LayoutImageResourceStyleImage requires a style being present on the image
+    // but we don't want to trigger a style change now as the node is not fully
+    // attached. Moving this code to style change doesn't make sense as it
+    // should be run once at layoutObject creation.
     image->setStyleInternal(const_cast<ComputedStyle*>(&style));
     if (const StyleImage* styleImage =
             toImageContentData(contentData)->image()) {
       image->setImageResource(LayoutImageResourceStyleImage::create(
           const_cast<StyleImage*>(styleImage)));
       image->setIsGeneratedContent();
     } else {
       image->setImageResource(LayoutImageResource::create());
     }
     image->setStyleInternal(nullptr);
@@ skipping 77 matching lines @@
 }
 
 bool LayoutObject::isLegend() const {
   return isHTMLLegendElement(node());
 }
 
 void LayoutObject::setIsInsideFlowThreadIncludingDescendants(
     bool insideFlowThread) {
   LayoutObject* next;
   for (LayoutObject* object = this; object; object = next) {
-    // If object is a fragmentation context it already updated the descendants flag accordingly.
+    // If object is a fragmentation context it already updated the descendants
+    // flag accordingly.
     if (object->isLayoutFlowThread()) {
       next = object->nextInPreOrderAfterChildren(this);
       continue;
     }
     next = object->nextInPreOrder(this);
     ASSERT(insideFlowThread != object->isInsideFlowThread());
     object->setIsInsideFlowThread(insideFlowThread);
   }
 }
 
@@ skipping 43 matching lines @@
       children->insertChildNode(this, table, beforeChild);
     }
     table->addChild(newChild);
   } else {
     children->insertChildNode(this, newChild, beforeChild);
   }
 
   if (newChild->isText() && newChild->style()->textTransform() == CAPITALIZE)
     toLayoutText(newChild)->transformText();
 
-  // SVG creates layoutObjects for <g display="none">, as SVG requires children of hidden
-  // <g>s to have layoutObjects - at least that's how our implementation works. Consider:
+  // SVG creates layoutObjects for <g display="none">, as SVG requires children
+  // of hidden <g>s to have layoutObjects - at least that's how our
+  // implementation works.
+  // Consider:
   // <g display="none"><foreignObject><body style="position: relative">FOO...
-  // - layerTypeRequired() would return true for the <body>, creating a new Layer
-  // - when the document is painted, both layers are painted. The <body> layer doesn't
-  //   know that it's inside a "hidden SVG subtree", and thus paints, even if it shouldn't.
-  // To avoid the problem altogether, detect early if we're inside a hidden SVG subtree
-  // and stop creating layers at all for these cases - they're not used anyways.
+  // - layerTypeRequired() would return true for the <body>, creating a new
+  //   Layer
+  // - when the document is painted, both layers are painted. The <body> layer
+  //   doesn't know that it's inside a "hidden SVG subtree", and thus paints,
+  //   even if it shouldn't.
+  // To avoid the problem altogether, detect early if we're inside a hidden SVG
+  // subtree and stop creating layers at all for these cases - they're not used
+  // anyways.
   if (newChild->hasLayer() && !layerCreationAllowedForSubtree())
     toLayoutBoxModelObject(newChild)
         ->layer()
         ->removeOnlyThisLayerAfterStyleChange();
 }
 
 void LayoutObject::removeChild(LayoutObject* oldChild) {
   ASSERT(isAllowedToModifyLayoutTreeStructure(document()));
 
   LayoutObjectChildList* children = virtualChildren();
@@ skipping 200 matching lines @@
     return;
   }
 
   for (LayoutObject* curr = slowFirstChild(); curr; curr = curr->nextSibling())
     curr->moveLayers(oldParent, newParent);
 }
 
 PaintLayer* LayoutObject::findNextLayer(PaintLayer* parentLayer,
                                         LayoutObject* startPoint,
                                         bool checkParent) {
-  // Error check the parent layer passed in. If it's null, we can't find anything.
+  // Error check the parent layer passed in. If it's null, we can't find
+  // anything.
   if (!parentLayer)
     return 0;
 
-  // Step 1: If our layer is a child of the desired parent, then return our layer.
+  // Step 1: If our layer is a child of the desired parent, then return our
+  // layer.
   PaintLayer* ourLayer =
       hasLayer() ? toLayoutBoxModelObject(this)->layer() : nullptr;
   if (ourLayer && ourLayer->parent() == parentLayer)
     return ourLayer;
 
-  // Step 2: If we don't have a layer, or our layer is the desired parent, then descend
-  // into our siblings trying to find the next layer whose parent is the desired parent.
+  // Step 2: If we don't have a layer, or our layer is the desired parent, then
+  // descend into our siblings trying to find the next layer whose parent is the
+  // desired parent.
   if (!ourLayer || ourLayer == parentLayer) {
     for (LayoutObject* curr = startPoint ? startPoint->nextSibling()
                                          : slowFirstChild();
          curr; curr = curr->nextSibling()) {
       PaintLayer* nextLayer = curr->findNextLayer(parentLayer, nullptr, false);
       if (nextLayer)
         return nextLayer;
     }
   }
 
-  // Step 3: If our layer is the desired parent layer, then we're finished. We didn't
-  // find anything.
+  // Step 3: If our layer is the desired parent layer, then we're finished. We
+  // didn't find anything.
   if (parentLayer == ourLayer)
     return nullptr;
 
-  // Step 4: If |checkParent| is set, climb up to our parent and check its siblings that
-  // follow us to see if we can locate a layer.
+  // Step 4: If |checkParent| is set, climb up to our parent and check its
+  // siblings that follow us to see if we can locate a layer.
   if (checkParent && parent())
     return parent()->findNextLayer(parentLayer, this, true);
 
   return nullptr;
 }
 
 PaintLayer* LayoutObject::enclosingLayer() const {
   for (const LayoutObject* current = this; current;
        current = current->parent()) {
     if (current->hasLayer())
       return toLayoutBoxModelObject(current)->layer();
   }
-  // TODO(crbug.com/365897): we should get rid of detached layout subtrees, at which point this code should
-  // not be reached.
+  // TODO(crbug.com/365897): we should get rid of detached layout subtrees, at
+  // which point this code should not be reached.
   return nullptr;
 }
 
 PaintLayer* LayoutObject::paintingLayer() const {
   for (const LayoutObject* current = this; current;
        current = current->paintInvalidationParent()) {
     if (current->hasLayer() &&
         toLayoutBoxModelObject(current)->layer()->isSelfPaintingLayer())
       return toLayoutBoxModelObject(current)->layer();
   }
-  // TODO(crbug.com/365897): we should get rid of detached layout subtrees, at which point this code should
-  // not be reached.
+  // TODO(crbug.com/365897): we should get rid of detached layout subtrees, at
+  // which point this code should not be reached.
   return nullptr;
 }
 
 bool LayoutObject::scrollRectToVisible(const LayoutRect& rect,
                                        const ScrollAlignment& alignX,
                                        const ScrollAlignment& alignY,
                                        ScrollType scrollType,
                                        bool makeVisibleInVisualViewport) {
   LayoutBox* enclosingBox = this->enclosingBox();
   if (!enclosingBox)
@@ skipping 49 matching lines @@
   if (LayoutState* layoutState = view()->layoutState()) {
     if (LayoutFlowThread* flowThread = layoutState->flowThread())
       return flowThread;
   }
 
   // Not in the middle of layout so have to find the thread the slow way.
   return LayoutFlowThread::locateFlowThreadContainingBlockOf(*this);
 }
 
 static inline bool objectIsRelayoutBoundary(const LayoutObject* object) {
-  // FIXME: In future it may be possible to broaden these conditions in order to improve performance.
+  // FIXME: In future it may be possible to broaden these conditions in order to
+  // improve performance.
   if (object->isTextControl())
     return true;
 
   if (object->isSVGRoot())
     return true;
 
-  // Table parts can't be relayout roots since the table is responsible for layouting all the parts.
+  // Table parts can't be relayout roots since the table is responsible for
+  // layouting all the parts.
   if (object->isTablePart())
     return false;
 
   if (object->style()->containsLayout() && object->style()->containsSize())
     return true;
 
   if (!object->hasOverflowClip())
     return false;
 
   if (object->style()->width().isIntrinsicOrAuto() ||
       object->style()->height().isIntrinsicOrAuto() ||
       object->style()->height().isPercentOrCalc())
     return false;
 
-  // Scrollbar parts can be removed during layout. Avoid the complexity of having to deal with that.
+  // Scrollbar parts can be removed during layout. Avoid the complexity of
+  // having to deal with that.
   if (object->isLayoutScrollbarPart())
     return false;
 
-  // In general we can't relayout a flex item independently of its container; not only is the result
-  // incorrect due to the override size that's set, it also messes with the cached main size on the flexbox.
+  // In general we can't relayout a flex item independently of its container;
+  // not only is the result incorrect due to the override size that's set, it
+  // also messes with the cached main size on the flexbox.
   if (object->isBox() && toLayoutBox(object)->isFlexItem())
     return false;
 
-  // Inside multicol it's generally problematic to allow relayout roots. The multicol container
-  // itself may be scheduled for relayout as well (due to other changes that may have happened
-  // since the previous layout pass), which might affect the column heights, which may affect how
-  // this object breaks across columns). Spanners may also have been added or removed since the
-  // previous layout pass, which is just another way of affecting the column heights (and the
-  // number of rows). Instead of identifying cases where it's safe to allow relayout roots, just
-  // disallow them inside multicol.
+  // Inside multicol it's generally problematic to allow relayout roots. The
+  // multicol container itself may be scheduled for relayout as well (due to
+  // other changes that may have happened since the previous layout pass),
+  // which might affect the column heights, which may affect how this object
+  // breaks across columns). Spanners may also have been added or removed since
+  // the previous layout pass, which is just another way of affecting the column
+  // heights (and the number of rows). Instead of identifying cases where it's
+  // safe to allow relayout roots, just disallow them inside multicol.
   if (object->isInsideFlowThread())
     return false;
 
   return true;
 }
 
 void LayoutObject::markContainerChainForLayout(bool scheduleRelayout,
                                                SubtreeLayoutScope* layouter) {
   ASSERT(!isSetNeedsLayoutForbidden());
   ASSERT(!layouter || this != layouter->root());
   // When we're in layout, we're marking a descendant as needing layout with
   // the intention of visiting it during this layout. We shouldn't be
-  // scheduling it to be laid out later.
-  // Also, scheduleRelayout() must not be called while iterating
-  // FrameView::m_layoutSubtreeRootList.
+  // scheduling it to be laid out later. Also, scheduleRelayout() must not be
+  // called while iterating FrameView::m_layoutSubtreeRootList.
   scheduleRelayout &= !frameView()->isInPerformLayout();
 
   LayoutObject* object = container();
   LayoutObject* last = this;
 
   bool simplifiedNormalFlowLayout = needsSimplifiedNormalFlowLayout() &&
                                     !selfNeedsLayout() &&
                                     !normalChildNeedsLayout();
 
   while (object) {
     if (object->selfNeedsLayout())
       return;
 
-    // Don't mark the outermost object of an unrooted subtree. That object will be
-    // marked when the subtree is added to the document.
+    // Don't mark the outermost object of an unrooted subtree. That object will
+    // be marked when the subtree is added to the document.
     LayoutObject* container = object->container();
     if (!container && !object->isLayoutView())
       return;
     if (!last->isTextOrSVGChild() && last->style()->hasOutOfFlowPosition()) {
       object = last->containingBlock();
       if (object->posChildNeedsLayout())
         return;
       container = object->container();
       object->setPosChildNeedsLayout(true);
       simplifiedNormalFlowLayout = true;
@@ skipping 40 matching lines @@
   if (markParents == MarkContainerChain &&
       (isText() || !style()->hasOutOfFlowPosition()))
     invalidateContainerPreferredLogicalWidths();
 }
 
 void LayoutObject::clearPreferredLogicalWidthsDirty() {
   m_bitfields.setPreferredLogicalWidthsDirty(false);
 }
 
 inline void LayoutObject::invalidateContainerPreferredLogicalWidths() {
-  // In order to avoid pathological behavior when inlines are deeply nested, we do include them
-  // in the chain that we mark dirty (even though they're kind of irrelevant).
+  // In order to avoid pathological behavior when inlines are deeply nested, we
+  // do include them in the chain that we mark dirty (even though they're kind
+  // of irrelevant).
   LayoutObject* o = isTableCell() ? containingBlock() : container();
   while (o && !o->preferredLogicalWidthsDirty()) {
-    // Don't invalidate the outermost object of an unrooted subtree. That object will be
-    // invalidated when the subtree is added to the document.
+    // Don't invalidate the outermost object of an unrooted subtree. That object
+    // will be invalidated when the subtree is added to the document.
     LayoutObject* container =
         o->isTableCell() ? o->containingBlock() : o->container();
     if (!container && !o->isLayoutView())
       break;
 
     o->m_bitfields.setPreferredLogicalWidthsDirty(true);
-    if (o->style()->hasOutOfFlowPosition()) {
-      // A positioned object has no effect on the min/max width of its containing block ever.
-      // We can optimize this case and not go up any further.
+    // A positioned object has no effect on the min/max width of its containing
+    // block ever. We can optimize this case and not go up any further.
+    if (o->style()->hasOutOfFlowPosition())
       break;
-    }
     o = container;
   }
 }
 
 LayoutObject* LayoutObject::containerForAbsolutePosition(
     const LayoutBoxModelObject* ancestor,
     bool* ancestorSkipped,
     bool* filterSkipped) const {
   DCHECK(!ancestorSkipped || !*ancestorSkipped);
   DCHECK(!filterSkipped || !*filterSkipped);
 
-  // We technically just want our containing block, but
-  // we may not have one if we're part of an uninstalled
-  // subtree. We'll climb as high as we can though.
+  // We technically just want our containing block, but we may not have one if
+  // we're part of an uninstalled subtree. We'll climb as high as we can though.
   for (LayoutObject* object = parent(); object; object = object->parent()) {
     if (object->canContainAbsolutePositionObjects())
       return object;
 
     if (ancestorSkipped && object == ancestor)
       *ancestorSkipped = true;
 
     if (filterSkipped && object->hasFilterInducingProperty())
       *filterSkipped = true;
   }
@@ skipping 18 matching lines @@
       *filterSkipped = true;
   }
 
   ASSERT(!object || !object->isAnonymousBlock());
   return toLayoutBlock(object);
 }
 
 LayoutBlock* LayoutObject::containingBlockForAbsolutePosition() const {
   LayoutObject* o = containerForAbsolutePosition();
 
-  // For relpositioned inlines, we return the nearest non-anonymous enclosing block. We don't try
-  // to return the inline itself.  This allows us to avoid having a positioned objects
-  // list in all LayoutInlines and lets us return a strongly-typed LayoutBlock* result
-  // from this method.  The container() method can actually be used to obtain the
-  // inline directly.
+  // For relpositioned inlines, we return the nearest non-anonymous enclosing
+  // block. We don't try to return the inline itself. This allows us to avoid
+  // having a positioned objects list in all LayoutInlines and lets us return a
+  // strongly-typed LayoutBlock* result from this method. The container() method
+  // can actually be used to obtain the inline directly.
   if (o && o->isInline() && !o->isAtomicInlineLevel()) {
     ASSERT(o->style()->hasInFlowPosition());
     o = o->containingBlock();
   }
 
   if (o && !o->isLayoutBlock())
     o = o->containingBlock();
 
   while (o && o->isAnonymousBlock())
     o = o->containingBlock();
@@ skipping 115 matching lines @@
 void LayoutObject::paint(const PaintInfo&, const LayoutPoint&) const {}
 
 const LayoutBoxModelObject& LayoutObject::containerForPaintInvalidation()
     const {
   RELEASE_ASSERT(isRooted());
 
   if (const LayoutBoxModelObject* paintInvalidationContainer =
           enclosingCompositedContainer())
     return *paintInvalidationContainer;
 
-  // If the current frame is not composited, we send just return
-  // the main frame's LayoutView so that we generate invalidations
-  // on the window.
+  // If the current frame is not composited, we send just return the main
+  // frame's LayoutView so that we generate invalidations on the window.
   const LayoutView* layoutView = view();
   while (
       LayoutAPIShim::layoutObjectFrom(layoutView->frame()->ownerLayoutItem()))
     layoutView =
         LayoutAPIShim::layoutObjectFrom(layoutView->frame()->ownerLayoutItem())
             ->view();
   ASSERT(layoutView);
   return *layoutView;
 }
 
 const LayoutBoxModelObject* LayoutObject::enclosingCompositedContainer() const {
   LayoutBoxModelObject* container = nullptr;
-  // FIXME: CompositingState is not necessarily up to date for many callers of this function.
+  // FIXME: CompositingState is not necessarily up to date for many callers of
+  // this function.
   DisableCompositingQueryAsserts disabler;
 
   if (PaintLayer* paintingLayer = this->paintingLayer()) {
     if (PaintLayer* compositingLayer =
             paintingLayer
                 ->enclosingLayerForPaintInvalidationCrossingFrameBoundaries())
       container = compositingLayer->layoutObject();
   }
   return container;
 }
 
 String LayoutObject::decoratedName() const {
   StringBuilder name;
   name.append(this->name());
 
   if (isAnonymous())
     name.append(" (anonymous)");
-  // FIXME: Remove the special case for LayoutView here (requires rebaseline of all tests).
+  // FIXME: Remove the special case for LayoutView here (requires rebaseline of
+  // all tests).
   if (isOutOfFlowPositioned() && !isLayoutView())
     name.append(" (positioned)");
   if (isRelPositioned())
     name.append(" (relative positioned)");
   if (isStickyPositioned())
     name.append(" (sticky positioned)");
   if (isFloating())
     name.append(" (floating)");
   if (spannerPlaceholder())
     name.append(" (column spanner)");
@@ skipping 16 matching lines @@
   return previousPaintInvalidationRect();
 }
 
 bool LayoutObject::isPaintInvalidationContainer() const {
   return hasLayer() &&
          toLayoutBoxModelObject(this)->layer()->isPaintInvalidationContainer();
 }
 
 void LayoutObject::invalidateDisplayItemClients(
     PaintInvalidationReason reason) const {
-  // This default implementation invalidates only the object itself as a DisplayItemClient.
+  // This default implementation invalidates only the object itself as a
+  // DisplayItemClient.
   ObjectPaintInvalidator(*this).invalidateDisplayItemClient(*this, reason);
 }
 
 bool LayoutObject::compositedScrollsWithRespectTo(
     const LayoutBoxModelObject& paintInvalidationContainer) const {
   return paintInvalidationContainer.usesCompositedScrolling() &&
          this != &paintInvalidationContainer;
 }
 
 IntSize LayoutObject::scrollAdjustmentForPaintInvalidation(
     const LayoutBoxModelObject& paintInvalidationContainer) const {
-  // Non-composited scrolling should be included in the bounds of scrolled items. Since mapToVisualRectInAncestorSpace does not include
-  // scrolling of the ancestor, we need to add it back in after.
+  // Non-composited scrolling should be included in the bounds of scrolleditems.
+  // Since mapToVisualRectInAncestorSpace does not include scrolling of the
+  // ancestor, we need to add it back in after.
   if (paintInvalidationContainer.isBox() &&
       !paintInvalidationContainer.usesCompositedScrolling() &&
       this != &paintInvalidationContainer) {
     const LayoutBox* box = toLayoutBox(&paintInvalidationContainer);
     if (box->hasOverflowClip())
       return -box->scrolledContentOffset();
   }
   return IntSize();
 }
 
@@ skipping 29 matching lines @@
   invalidatePaintOfSubtreesIfNeeded(newPaintInvalidationState);
 }
 
 DISABLE_CFI_PERF
 void LayoutObject::invalidatePaintOfSubtreesIfNeeded(
     const PaintInvalidationState& childPaintInvalidationState) {
   DCHECK(!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
 
   for (LayoutObject* child = slowFirstChild(); child;
        child = child->nextSibling()) {
-    // Column spanners are invalidated through their placeholders.
-    // See LayoutMultiColumnSpannerPlaceholder::invalidatePaintOfSubtreesIfNeeded().
+    // Column spanners are invalidated through their placeholders. See
+    // LayoutMultiColumnSpannerPlaceholder::invalidatePaintOfSubtreesIfNeeded().
     if (child->isColumnSpanAll())
       continue;
     child->invalidateTreeIfNeeded(childPaintInvalidationState);
   }
 }
 
 LayoutRect LayoutObject::selectionRectInViewCoordinates() const {
   LayoutRect selectionRect = localSelectionRect();
   if (!selectionRect.isEmpty())
     mapToVisualRectInAncestorSpace(view(), selectionRect);
@@ skipping 31 matching lines @@
       scrollAdjustmentForPaintInvalidation(paintInvalidationContainer);
   context.newLocation.move(adjustment);
   context.newBounds.move(adjustment);
 
   setPreviousPaintInvalidationRect(context.newBounds);
   setPreviousPositionFromPaintInvalidationBacking(context.newLocation);
 
   if (!shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() &&
       paintInvalidationState
           .forcedSubtreeInvalidationRectUpdateWithinContainerOnly()) {
-    // We are done updating the paint invalidation rect. No other paint invalidation work to do for this object.
+    // We are done updating the paint invalidation rect. No other paint
+    // invalidation work to do for this object.
     return PaintInvalidationNone;
   }
 
   return invalidatePaintIfNeeded(context);
 }
 
 DISABLE_CFI_PERF
 PaintInvalidationReason LayoutObject::invalidatePaintIfNeeded(
     const PaintInvalidatorContext& context) const {
   return ObjectPaintInvalidatorWithContext(*this, context)
@@ skipping 21 matching lines @@
 
 void LayoutObject::adjustPreviousPaintInvalidationForScrollIfNeeded(
     const DoubleSize& scrollDelta) {
   if (containerForPaintInvalidation().usesCompositedScrolling())
     return;
   m_previousPaintInvalidationRect.move(LayoutSize(scrollDelta));
 }
 
 void LayoutObject::clearPreviousPaintInvalidationRects() {
   setPreviousPaintInvalidationRect(LayoutRect());
-  // After clearing ("invalidating" the paint invalidation rects, mark this object as needing to re-compute them.
+  // After clearing ("invalidating" the paint invalidation rects, mark this
+  // object as needing to re-compute them.
   setShouldDoFullPaintInvalidation();
 }
 
 LayoutRect LayoutObject::absoluteClippedOverflowRect() const {
   LayoutRect rect = localOverflowRectForPaintInvalidation();
   mapToVisualRectInAncestorSpace(view(), rect);
   return rect;
 }
 
 LayoutRect LayoutObject::localOverflowRectForPaintInvalidation() const {
   ASSERT_NOT_REACHED();
   return LayoutRect();
 }
 
 bool LayoutObject::mapToVisualRectInAncestorSpace(
     const LayoutBoxModelObject* ancestor,
     LayoutRect& rect,
     VisualRectFlags visualRectFlags) const {
-  // For any layout object that doesn't override this method (the main example is LayoutText),
-  // the rect is assumed to be in the parent's coordinate space, except for container flip.
+  // For any layout object that doesn't override this method (the main example
+  // is LayoutText), the rect is assumed to be in the parent's coordinate space,
+  // except for container flip.
 
   if (ancestor == this)
     return true;
 
   if (LayoutObject* parent = this->parent()) {
     if (parent->isBox()) {
       LayoutBox* parentBox = toLayoutBox(parent);
 
       // Never flip for SVG as it handles writing modes itself.
       if (!isSVG())
@@ skipping 127 matching lines @@
 
 Color LayoutObject::selectionEmphasisMarkColor(
     const GlobalPaintFlags globalPaintFlags) const {
   return selectionColor(CSSPropertyWebkitTextEmphasisColor, globalPaintFlags);
 }
 
 void LayoutObject::selectionStartEnd(int& spos, int& epos) const {
   view()->selectionStartEnd(spos, epos);
 }
 
-// Called when an object that was floating or positioned becomes a normal flow object
-// again.  We have to make sure the layout tree updates as needed to accommodate the new
-// normal flow object.
+// Called when an object that was floating or positioned becomes a normal flow
+// object again. We have to make sure the layout tree updates as needed to
+// accommodate the new normal flow object.
 static inline void handleDynamicFloatPositionChange(LayoutObject* object) {
-  // We have gone from not affecting the inline status of the parent flow to suddenly
-  // having an impact.  See if there is a mismatch between the parent flow's
-  // childrenInline() state and our state.
+  // We have gone from not affecting the inline status of the parent flow to
+  // suddenly having an impact.  See if there is a mismatch between the parent
+  // flow's childrenInline() state and our state.
   object->setInline(object->style()->isDisplayInlineType());
   if (object->isInline() != object->parent()->childrenInline()) {
     if (!object->isInline()) {
       toLayoutBoxModelObject(object->parent())->childBecameNonInline(object);
     } else {
       // An anonymous block must be made to wrap this inline.
       LayoutBlock* block =
           toLayoutBlock(object->parent())->createAnonymousBlock();
       LayoutObjectChildList* childlist = object->parent()->virtualChildren();
       childlist->insertChildNode(object->parent(), block, object);
       block->children()->appendChildNode(
           block, childlist->removeChildNode(object->parent(), object));
     }
   }
 }
 
 StyleDifference LayoutObject::adjustStyleDifference(
     StyleDifference diff) const {
   if (diff.transformChanged() && isSVG()) {
-    // Skip a full layout for transforms at the html/svg boundary which do not affect sizes inside SVG.
+    // Skip a full layout for transforms at the html/svg boundary which do not
+    // affect sizes inside SVG.
     if (!isSVGRoot())
       diff.setNeedsFullLayout();
   }
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
-    // Text nodes share style with their parents but the checked styles don't apply to them,
-    // hence the !isText() check.
+    // Text nodes share style with their parents but the checked styles don't
+    // apply to them, hence the !isText() check.
     if (!isText() && (diff.transformChanged() || diff.opacityChanged() ||
                       diff.zIndexChanged() || diff.filterChanged() ||
                       diff.backdropFilterChanged())) {
-      // We don't need to invalidate paint of objects on SPv2 when only paint property or
-      // paint order change. Mark the painting layer needing repaint for changed paint
-      // property or paint order. Raster invalidation will be issued if needed during paint.
+      // We don't need to invalidate paint of objects on SPv2 when only paint
+      // property or paint order change. Mark the painting layer needing repaint
+      // for changed paint property or paint order. Raster invalidation will be
+      // issued if needed during paint.
       ObjectPaintInvalidator(*this).slowSetPaintingLayerNeedsRepaint();
     }
   } else {
-    // If transform changed, and the layer does not paint into its own separate backing, then we need to invalidate paints.
+    // If transform changed, and the layer does not paint into its own separate
+    // backing, then we need to invalidate paints.
     if (diff.transformChanged()) {
-      // Text nodes share style with their parents but transforms don't apply to them,
-      // hence the !isText() check.
+      // Text nodes share style with their parents but transforms don't apply to
+      // them, hence the !isText() check.
       if (!isText() && (!hasLayer() ||
                         !toLayoutBoxModelObject(this)
                              ->layer()
                              ->hasStyleDeterminedDirectCompositingReasons()))
         diff.setNeedsPaintInvalidationSubtree();
     }
 
-    // If opacity or zIndex changed, and the layer does not paint into its own separate backing, then we need to invalidate paints (also
-    // ignoring text nodes)
+    // If opacity or zIndex changed, and the layer does not paint into its own
+    // separate backing, then we need to invalidate paints (also
+    // ignoring text nodes).
     if (diff.opacityChanged() || diff.zIndexChanged()) {
       if (!isText() && (!hasLayer() ||
                         !toLayoutBoxModelObject(this)
                              ->layer()
                              ->hasStyleDeterminedDirectCompositingReasons()))
         diff.setNeedsPaintInvalidationSubtree();
     }
 
-    // If filter changed, and the layer does not paint into its own separate backing or it paints with filters, then we need to invalidate paints.
+    // If filter changed, and the layer does not paint into its own separate
+    // backing or it paints with filters, then we need to invalidate paints.
     if (diff.filterChanged() && hasLayer()) {
       PaintLayer* layer = toLayoutBoxModelObject(this)->layer();
       if (!layer->hasStyleDeterminedDirectCompositingReasons() ||
           layer->paintsWithFilters())
         diff.setNeedsPaintInvalidationSubtree();
     }
 
-    // If backdrop filter changed, and the layer does not paint into its own separate backing or it paints with filters, then we need to invalidate paints.
+    // If backdrop filter changed, and the layer does not paint into its own
+    // separate backing or it paints with filters, then we need to invalidate
+    // paints.
     if (diff.backdropFilterChanged() && hasLayer()) {
       PaintLayer* layer = toLayoutBoxModelObject(this)->layer();
       if (!layer->hasStyleDeterminedDirectCompositingReasons() ||
           layer->paintsWithBackdropFilters())
         diff.setNeedsPaintInvalidationSubtree();
     }
   }
 
-  // Optimization: for decoration/color property changes, invalidation is only needed if we have style or text affected by these properties.
+  // Optimization: for decoration/color property changes, invalidation is only
+  // needed if we have style or text affected by these properties.
   if (diff.textDecorationOrColorChanged() && !diff.needsPaintInvalidation()) {
     if (style()->hasBorder() || style()->hasOutline() ||
         style()->hasBackgroundRelatedColorReferencingCurrentColor()
-        // Skip any text nodes that do not contain text boxes. Whitespace cannot be
-        // skipped or we will miss invalidating decorations (e.g., underlines).
+        // Skip any text nodes that do not contain text boxes. Whitespace cannot
+        // be skipped or we will miss invalidating decorations (e.g.,
+        // underlines).
         || (isText() && !isBR() && toLayoutText(this)->hasTextBoxes())
         // Caret is painted in text color.
         || (isLayoutBlock() && toLayoutBlock(this)->hasCaret()) ||
         (isSVG() && style()->svgStyle().isFillColorCurrentColor()) ||
         (isSVG() && style()->svgStyle().isStrokeColorCurrentColor()) ||
         isListMarker())
       diff.setNeedsPaintInvalidationObject();
   }
 
-  // The answer to layerTypeRequired() for plugins, iframes, and canvas can change without the actual
-  // style changing, since it depends on whether we decide to composite these elements. When the
-  // layer status of one of these elements changes, we need to force a layout.
+  // The answer to layerTypeRequired() for plugins, iframes, and canvas can
+  // change without the actual style changing, since it depends on whether we
+  // decide to composite these elements. When the/ layer status of one of these
+  // elements changes, we need to force a layout.
   if (!diff.needsFullLayout() && style() && isBoxModelObject()) {
     bool requiresLayer =
         toLayoutBoxModelObject(this)->layerTypeRequired() != NoPaintLayer;
     if (hasLayer() != requiresLayer)
       diff.setNeedsFullLayout();
   }
 
   return diff;
 }
 
 void LayoutObject::setPseudoStyle(PassRefPtr<ComputedStyle> pseudoStyle) {
   ASSERT(pseudoStyle->styleType() == PseudoIdBefore ||
          pseudoStyle->styleType() == PseudoIdAfter ||
          pseudoStyle->styleType() == PseudoIdFirstLetter);
 
-  // FIXME: We should consider just making all pseudo items use an inherited style.
+  // FIXME: We should consider just making all pseudo items use an inherited
+  // style.
 
-  // Images are special and must inherit the pseudoStyle so the width and height of
-  // the pseudo element doesn't change the size of the image. In all other cases we
-  // can just share the style.
+  // Images are special and must inherit the pseudoStyle so the width and height
+  // of the pseudo element doesn't change the size of the image. In all other
+  // cases we can just share the style.
   //
-  // Quotes are also LayoutInline, so we need to create an inherited style to avoid
-  // getting an inline with positioning or an invalid display.
+  // Quotes are also LayoutInline, so we need to create an inherited style to
+  // avoid getting an inline with positioning or an invalid display.
   //
   if (isImage() || isQuote()) {
     RefPtr<ComputedStyle> style = ComputedStyle::create();
     style->inheritFrom(*pseudoStyle);
     setStyle(style.release());
     return;
   }
 
   setStyle(std::move(pseudoStyle));
 }
 
 void LayoutObject::firstLineStyleDidChange(const ComputedStyle& oldStyle,
                                            const ComputedStyle& newStyle) {
   StyleDifference diff = oldStyle.visualInvalidationDiff(newStyle);
 
   if (diff.needsPaintInvalidation() || diff.textDecorationOrColorChanged()) {
-    // We need to invalidate all inline boxes in the first line, because they need to be
-    // repainted with the new style, e.g. background, font style, etc.
+    // We need to invalidate all inline boxes in the first line, because they
+    // need to be repainted with the new style, e.g. background, font style,
+    // etc.
     LayoutBlockFlow* firstLineContainer = nullptr;
     if (behavesLikeBlockContainer()) {
-      // This object is a LayoutBlock having PseudoIdFirstLine pseudo style changed.
+      // This object is a LayoutBlock having PseudoIdFirstLine pseudo style
+      // changed.
       firstLineContainer =
           toLayoutBlock(this)->nearestInnerBlockWithFirstLine();
     } else if (isLayoutInline()) {
-      // This object is a LayoutInline having FIRST_LINE_INHERITED pesudo style changed.
-      // This method can be called even if the LayoutInline doesn't intersect the first line,
-      // but we only need to invalidate if it does.
+      // This object is a LayoutInline having FIRST_LINE_INHERITED pesudo style
+      // changed. This method can be called even if the LayoutInline doesn't
+      // intersect the first line, but we only need to invalidate if it does.
       if (InlineBox* firstLineBox =
               toLayoutInline(this)->firstLineBoxIncludingCulling()) {
         if (firstLineBox->isFirstLineStyle())
           firstLineContainer = toLayoutBlockFlow(containingBlock());
       }
     }
     if (firstLineContainer)
       firstLineContainer->setShouldDoFullPaintInvalidationForFirstLine();
   }
   if (diff.needsLayout())
     setNeedsLayoutAndPrefWidthsRecalc(LayoutInvalidationReason::StyleChange);
 }
 
 void LayoutObject::markAncestorsForOverflowRecalcIfNeeded() {
   LayoutObject* object = this;
   do {
-    // Cell and row need to propagate the flag to their containing section and row as their containing block is the table wrapper.
+    // Cell and row need to propagate the flag to their containing section and
+    // row as their containing block is the table wrapper.
     // This enables us to only recompute overflow the modified sections / rows.
     object = object->isTableCell() || object->isTableRow()
                  ? object->parent()
                  : object->containingBlock();
     if (object)
       object->setChildNeedsOverflowRecalcAfterStyleChange();
   } while (object);
 }
 
 void LayoutObject::setNeedsOverflowRecalcAfterStyleChange() {
   bool neededRecalc = needsOverflowRecalcAfterStyleChange();
   setSelfNeedsOverflowRecalcAfterStyleChange();
   if (!neededRecalc)
     markAncestorsForOverflowRecalcIfNeeded();
 }
 
 DISABLE_CFI_PERF
 void LayoutObject::setStyle(PassRefPtr<ComputedStyle> style) {
   ASSERT(style);
 
   if (m_style == style) {
-    // We need to run through adjustStyleDifference() for iframes, plugins, and canvas so
-    // style sharing is disabled for them. That should ensure that we never hit this code path.
+    // We need to run through adjustStyleDifference() for iframes, plugins, and
+    // canvas so style sharing is disabled for them. That should ensure that we
+    // never hit this code path.
     ASSERT(!isLayoutIFrame() && !isEmbeddedObject() && !isCanvas());
     return;
   }
 
   StyleDifference diff;
   if (m_style)
     diff = m_style->visualInvalidationDiff(*style);
 
   diff = adjustStyleDifference(diff);
 
@@ skipping 32 matching lines @@
 
   updateShapeImage(oldStyle ? oldStyle->shapeOutside() : 0,
                    m_style->shapeOutside());
   updateCursorImages(oldStyle ? oldStyle->cursors() : nullptr,
                      m_style->cursors());
 
   bool doesNotNeedLayoutOrPaintInvalidation = !m_parent;
 
   styleDidChange(diff, oldStyle.get());
 
-  // FIXME: |this| might be destroyed here. This can currently happen for a LayoutTextFragment when
-  // its first-letter block gets an update in LayoutTextFragment::styleDidChange. For LayoutTextFragment(s),
-  // we will safely bail out with the doesNotNeedLayoutOrPaintInvalidation flag. We might want to broaden
-  // this condition in the future as we move layoutObject changes out of layout and into style changes.
+  // FIXME: |this| might be destroyed here. This can currently happen for a
+  // LayoutTextFragment when its first-letter block gets an update in
+  // LayoutTextFragment::styleDidChange. For LayoutTextFragment(s),
+  // we will safely bail out with the doesNotNeedLayoutOrPaintInvalidation flag.
+  // We might want to broaden this condition in the future as we move
+  // layoutObject changes out of layout and into style changes.
   if (doesNotNeedLayoutOrPaintInvalidation)
     return;
 
-  // Now that the layer (if any) has been updated, we need to adjust the diff again,
-  // check whether we should layout now, and decide if we need to invalidate paints.
+  // Now that the layer (if any) has been updated, we need to adjust the diff
+  // again, check whether we should layout now, and decide if we need to
+  // invalidate paints.
   StyleDifference updatedDiff = adjustStyleDifference(diff);
 
   if (!diff.needsFullLayout()) {
     if (updatedDiff.needsFullLayout())
       setNeedsLayoutAndPrefWidthsRecalc(LayoutInvalidationReason::StyleChange);
     else if (updatedDiff.needsPositionedMovementLayout())
       setNeedsPositionedMovementLayout();
   }
 
   if (diff.transformChanged() && !needsLayout()) {
@@ skipping 27 matching lines @@
         m_style->zIndex() != newStyle.zIndex() ||
         m_style->isStackingContext() != newStyle.isStackingContext();
     if (visibilityChanged) {
       document().setAnnotatedRegionsDirty(true);
       if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->childrenChanged(parent());
     }
 
     // Keep layer hierarchy visibility bits up to date if visibility changes.
     if (m_style->visibility() != newStyle.visibility()) {
-      // We might not have an enclosing layer yet because we might not be in the tree.
+      // We might not have an enclosing layer yet because we might not be in the
+      // tree.
       if (PaintLayer* layer = enclosingLayer())
         layer->potentiallyDirtyVisibleContentStatus(newStyle.visibility());
     }
 
     if (isFloating() && (m_style->floating() != newStyle.floating())) {
       // For changes in float styles, we need to conceivably remove ourselves
       // from the floating objects list.
       toLayoutBox(this)->removeFloatingOrPositionedChildFromBlockLists();
     } else if (isOutOfFlowPositioned() &&
                (m_style->position() != newStyle.position())) {
-      // For changes in positioning styles, we need to conceivably remove ourselves
-      // from the positioned objects list.
+      // For changes in positioning styles, we need to conceivably remove
+      // ourselves from the positioned objects list.
       toLayoutBox(this)->removeFloatingOrPositionedChildFromBlockLists();
     }
 
     s_affectsParentBlock =
         isFloatingOrOutOfFlowPositioned() &&
         (!newStyle.isFloating() && !newStyle.hasOutOfFlowPosition()) &&
         parent() &&
         (parent()->isLayoutBlockFlow() || parent()->isLayoutInline());
 
     // Clearing these bits is required to avoid leaving stale layoutObjects.
@@ skipping 98 matching lines @@
       markAncestorsForOverflowRecalcIfNeeded();
 
     setNeedsLayoutAndPrefWidthsRecalc(LayoutInvalidationReason::StyleChange);
   } else if (diff.needsPositionedMovementLayout()) {
     setNeedsPositionedMovementLayout();
   }
 
   if (diff.scrollAnchorDisablingPropertyChanged())
     setScrollAnchorDisablingStyleChanged(true);
 
-  // Don't check for paint invalidation here; we need to wait until the layer has been
-  // updated by subclasses before we know if we have to invalidate paints (in setStyle()).
+  // Don't check for paint invalidation here; we need to wait until the layer
+  // has been updated by subclasses before we know if we have to invalidate
+  // paints (in setStyle()).
 
   if (oldStyle && !areCursorsEqual(oldStyle, style())) {
     if (LocalFrame* frame = this->frame()) {
-      // Cursor update scheduling is done by the local root, which is the main frame if there
-      // are no RemoteFrame ancestors in the frame tree. Use of localFrameRoot() is
-      // discouraged but will change when cursor update scheduling is moved from EventHandler
-      // to PageEventHandler.
+      // Cursor update scheduling is done by the local root, which is the main
+      // frame if there are no RemoteFrame ancestors in the frame tree. Use of
+      // localFrameRoot() is discouraged but will change when cursor update
+      // scheduling is moved from EventHandler to PageEventHandler.
       frame->localFrameRoot()->eventHandler().scheduleCursorUpdate();
     }
   }
 }
 
 void LayoutObject::propagateStyleToAnonymousChildren() {
-  // FIXME: We could save this call when the change only affected non-inherited properties.
+  // FIXME: We could save this call when the change only affected non-inherited
+  // properties.
   for (LayoutObject* child = slowFirstChild(); child;
        child = child->nextSibling()) {
     if (!child->isAnonymous() || child->style()->styleType() != PseudoIdNone)
       continue;
 
     if (child->anonymousHasStylePropagationOverride())
       continue;
 
     RefPtr<ComputedStyle> newStyle =
         ComputedStyle::createAnonymousStyleWithDisplay(
             styleRef(), child->style()->display());
 
-    // Preserve the position style of anonymous block continuations as they can have relative position when
-    // they contain block descendants of relative positioned inlines.
+    // Preserve the position style of anonymous block continuations as they can
+    // have relative position when they contain block descendants of relative
+    // positioned inlines.
     if (child->isInFlowPositioned() && child->isLayoutBlockFlow() &&
         toLayoutBlockFlow(child)->isAnonymousBlockContinuation())
       newStyle->setPosition(child->style()->position());
 
     updateAnonymousChildStyle(*child, *newStyle);
 
     child->setStyle(newStyle.release());
   }
 }
 
@@ skipping 17 matching lines @@
   }
   addChild(newChild, beforeChild);
 }
 
 void LayoutObject::updateFillImages(const FillLayer* oldLayers,
                                     const FillLayer& newLayers) {
   // Optimize the common case
   if (FillLayer::imagesIdentical(oldLayers, &newLayers))
     return;
 
-  // Go through the new layers and addClients first, to avoid removing all clients of an image.
+  // Go through the new layers and addClients first, to avoid removing all
+  // clients of an image.
   for (const FillLayer* currNew = &newLayers; currNew;
        currNew = currNew->next()) {
     if (currNew->image())
       currNew->image()->addClient(this);
   }
 
   for (const FillLayer* currOld = oldLayers; currOld;
        currOld = currOld->next()) {
     if (currOld->image())
       currOld->image()->removeClient(this);
@@ skipping 86 matching lines @@
         transformState.move(
             toLayoutBox(o)->flipForWritingMode(LayoutPoint(centerPoint)) -
             centerPoint);
       }
       mode &= ~ApplyContainerFlip;
     }
   }
 
   LayoutSize containerOffset = offsetFromContainer(o);
   if (isLayoutFlowThread()) {
-    // So far the point has been in flow thread coordinates (i.e. as if everything in
-    // the fragmentation context lived in one tall single column). Convert it to a
-    // visual point now, since we're about to escape the flow thread.
+    // So far the point has been in flow thread coordinates (i.e. as if
+    // everything in the fragmentation context lived in one tall single column).
+    // Convert it to a visual point now, since we're about to escape the flow
+    // thread.
     containerOffset +=
         columnOffset(roundedLayoutPoint(transformState.mappedPoint()));
   }
 
-  // Text objects just copy their parent's computed style, so we need to ignore them.
+  // Text objects just copy their parent's computed style, so we need to ignore
+  // them.
   bool preserve3D =
       mode & UseTransforms && ((o->style()->preserves3D() && !o->isText()) ||
                                (style()->preserves3D() && !isText()));
   if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
     TransformationMatrix t;
     getTransformFromContainer(o, containerOffset, t);
     transformState.applyTransform(t, preserve3D
                                          ? TransformState::AccumulateTransform
                                          : TransformState::FlattenTransform);
   } else {
     transformState.move(containerOffset.width(), containerOffset.height(),
                         preserve3D ? TransformState::AccumulateTransform
                                    : TransformState::FlattenTransform);
   }
 
   if (ancestorSkipped) {
-    // There can't be a transform between |ancestor| and |o|, because transforms create
-    // containers, so it should be safe to just subtract the delta between the ancestor and |o|.
+    // There can't be a transform between |ancestor| and |o|, because transforms
+    // create containers, so it should be safe to just subtract the delta
+    // between the ancestor and |o|.
     LayoutSize containerOffset = ancestor->offsetFromAncestorContainer(o);
     transformState.move(-containerOffset.width(), -containerOffset.height(),
                         preserve3D ? TransformState::AccumulateTransform
                                    : TransformState::FlattenTransform);
     return;
   }
 
   o->mapLocalToAncestor(ancestor, transformState, mode);
 }
 
@@ skipping 23 matching lines @@
       applyContainerFlip = o->style()->isFlippedBlocksWritingMode();
       mode &= ~ApplyContainerFlip;
     }
   }
 
   if (!ancestorSkipped)
     o->mapAncestorToLocal(ancestor, transformState, mode);
 
   LayoutSize containerOffset = offsetFromContainer(o);
   if (isLayoutFlowThread()) {
-    // Descending into a flow thread. Convert to the local coordinate space, i.e. flow thread coordinates.
+    // Descending into a flow thread. Convert to the local coordinate space,
+    // i.e. flow thread coordinates.
     LayoutPoint visualPoint = LayoutPoint(transformState.mappedPoint());
     transformState.move(
         visualPoint -
         toLayoutFlowThread(this)->visualPointToFlowThreadPoint(visualPoint));
   }
 
   bool preserve3D = mode & UseTransforms &&
                     (o->style()->preserves3D() || style()->preserves3D());
   if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
     TransformationMatrix t;
@@ skipping 15 matching lines @@
   }
 
   if (ancestorSkipped) {
     containerOffset = ancestor->offsetFromAncestorContainer(o);
     transformState.move(-containerOffset.width(), -containerOffset.height());
   }
 }
 
 bool LayoutObject::shouldUseTransformFromContainer(
     const LayoutObject* containerObject) const {
-  // hasTransform() indicates whether the object has transform, transform-style or perspective. We just care about transform,
-  // so check the layer's transform directly.
+  // hasTransform() indicates whether the object has transform, transform-style
+  // or perspective. We just care about transform, so check the layer's
+  // transform directly.
   return (hasLayer() && toLayoutBoxModelObject(this)->layer()->transform()) ||
          (containerObject && containerObject->style()->hasPerspective());
 }
 
 void LayoutObject::getTransformFromContainer(
     const LayoutObject* containerObject,
     const LayoutSize& offsetInContainer,
     TransformationMatrix& transform) const {
   transform.makeIdentity();
   transform.translate(offsetInContainer.width().toFloat(),
@@ skipping 16 matching lines @@
                                0);
     transform = perspectiveMatrix * transform;
     transform.translateRight3d(perspectiveOrigin.x(), perspectiveOrigin.y(), 0);
   }
 }
 
 FloatQuad LayoutObject::localToAncestorQuad(
     const FloatQuad& localQuad,
     const LayoutBoxModelObject* ancestor,
     MapCoordinatesFlags mode) const {
-  // Track the point at the center of the quad's bounding box. As mapLocalToAncestor() calls offsetFromContainer(),
-  // it will use that point as the reference point to decide which column's transform to apply in multiple-column blocks.
+  // Track the point at the center of the quad's bounding box. As
+  // mapLocalToAncestor() calls offsetFromContainer(), it will use that point
+  // as the reference point to decide which column's transform to apply in
+  // multiple-column blocks.
   TransformState transformState(TransformState::ApplyTransformDirection,
                                 localQuad.boundingBox().center(), localQuad);
   mapLocalToAncestor(ancestor, transformState,
                      mode | ApplyContainerFlip | UseTransforms);
   transformState.flatten();
 
   return transformState.lastPlanarQuad();
 }
 
 FloatPoint LayoutObject::localToAncestorPoint(
@@ skipping 43 matching lines @@
   const LayoutBoxModelObject& paintInvalidationContainer =
       containerForPaintInvalidation();
   ASSERT(paintInvalidationContainer.layer());
 
   if (backingLayer)
     *backingLayer = paintInvalidationContainer.layer();
   FloatPoint containerPoint =
       localToAncestorPoint(FloatPoint(localPoint), &paintInvalidationContainer,
                            TraverseDocumentBoundaries);
 
-  // A layoutObject can have no invalidation backing if it is from a detached frame,
-  // or when forced compositing is disabled.
+  // A layoutObject can have no invalidation backing if it is from a detached
+  // frame, or when forced compositing is disabled.
   if (paintInvalidationContainer.layer()->compositingState() == NotComposited)
     return containerPoint;
 
   PaintLayer::mapPointInPaintInvalidationContainerToBacking(
       paintInvalidationContainer, containerPoint);
   return containerPoint;
 }
 
 LayoutSize LayoutObject::offsetFromContainer(const LayoutObject* o) const {
   ASSERT(o == container());
   return o->hasOverflowClip()
              ? LayoutSize(-toLayoutBox(o)->scrolledContentOffset())
              : LayoutSize();
 }
 
 LayoutSize LayoutObject::offsetFromAncestorContainer(
     const LayoutObject* ancestorContainer) const {
   if (ancestorContainer == this)
     return LayoutSize();
 
   LayoutSize offset;
   LayoutPoint referencePoint;
   const LayoutObject* currContainer = this;
   do {
     const LayoutObject* nextContainer = currContainer->container();
-    ASSERT(
-        nextContainer);  // This means we reached the top without finding container.
+    // This means we reached the top without finding container.
+    DCHECK(nextContainer);
     if (!nextContainer)
       break;
     ASSERT(!currContainer->hasTransformRelatedProperty());
     LayoutSize currentOffset =
         currContainer->offsetFromContainer(nextContainer);
     offset += currentOffset;
     referencePoint.move(currentOffset);
     currContainer = nextContainer;
   } while (currContainer != ancestorContainer);
 
   return offset;
 }
 
 LayoutRect LayoutObject::localCaretRect(InlineBox*,
                                         int,
                                         LayoutUnit* extraWidthToEndOfLine) {
   if (extraWidthToEndOfLine)
     *extraWidthToEndOfLine = LayoutUnit();
 
   return LayoutRect();
 }
 
 void LayoutObject::computeLayerHitTestRects(
     LayerHitTestRects& layerRects) const {
-  // Figure out what layer our container is in. Any offset (or new layer) for this
-  // layoutObject within it's container will be applied in addLayerHitTestRects.
+  // Figure out what layer our container is in. Any offset (or new layer) for
+  // this layoutObject within it's container will be applied in
+  // addLayerHitTestRects.
   LayoutPoint layerOffset;
   const PaintLayer* currentLayer = nullptr;
 
   if (!hasLayer()) {
     LayoutObject* container = this->container();
     currentLayer = container->enclosingLayer();
     if (container && currentLayer->layoutObject() != container) {
       layerOffset.move(
           container->offsetFromAncestorContainer(currentLayer->layoutObject()));
-      // If the layer itself is scrolled, we have to undo the subtraction of its scroll
-      // offset since we want the offset relative to the scrolling content, not the
-      // element itself.
+      // If the layer itself is scrolled, we have to undo the subtraction of its
+      // scroll offset since we want the offset relative to the scrolling
+      // content, not the element itself.
       if (currentLayer->layoutObject()->hasOverflowClip())
         layerOffset.move(currentLayer->layoutBox()->scrolledContentOffset());
     }
   }
 
   this->addLayerHitTestRects(layerRects, currentLayer, layerOffset,
                              LayoutRect());
 }
 
 void LayoutObject::addLayerHitTestRects(LayerHitTestRects& layerRects,
                                         const PaintLayer* currentLayer,
                                         const LayoutPoint& layerOffset,
                                         const LayoutRect& containerRect) const {
   ASSERT(currentLayer);
   ASSERT(currentLayer == this->enclosingLayer());
 
   // Compute the rects for this layoutObject only and add them to the results.
-  // Note that we could avoid passing the offset and instead adjust each result, but this
-  // seems slightly simpler.
+  // Note that we could avoid passing the offset and instead adjust each result,
+  // but this seems slightly simpler.
   Vector<LayoutRect> ownRects;
   LayoutRect newContainerRect;
   computeSelfHitTestRects(ownRects, layerOffset);
 
-  // When we get to have a lot of rects on a layer, the performance cost of tracking those
-  // rects outweighs the benefit of doing compositor thread hit testing.
+  // When we get to have a lot of rects on a layer, the performance cost of
+  // tracking those rects outweighs the benefit of doing compositor thread hit
+  // testing.
   // FIXME: This limit needs to be low due to the O(n^2) algorithm in
   // WebLayer::setTouchEventHandlerRegion - crbug.com/300282.
   const size_t maxRectsPerLayer = 100;
 
   LayerHitTestRects::iterator iter = layerRects.find(currentLayer);
   Vector<LayoutRect>* iterValue;
   if (iter == layerRects.end())
     iterValue =
         &layerRects.add(currentLayer, Vector<LayoutRect>()).storedValue->value;
   else
     iterValue = &iter->value;
   for (size_t i = 0; i < ownRects.size(); i++) {
     if (!containerRect.contains(ownRects[i])) {
       iterValue->append(ownRects[i]);
       if (iterValue->size() > maxRectsPerLayer) {
         // Just mark the entire layer instead, and switch to walking the layer
         // tree instead of the layout tree.
         layerRects.remove(currentLayer);
         currentLayer->addLayerHitTestRects(layerRects);
         return;
       }
       if (newContainerRect.isEmpty())
         newContainerRect = ownRects[i];
     }
   }
   if (newContainerRect.isEmpty())
     newContainerRect = containerRect;
 
-  // If it's possible for children to have rects outside our bounds, then we need to descend into
-  // the children and compute them.
-  // Ideally there would be other cases where we could detect that children couldn't have rects
-  // outside our bounds and prune the tree walk.
-  // Note that we don't use Region here because Union is O(N) - better to just keep a list of
-  // partially redundant rectangles. If we find examples where this is expensive, then we could
-  // rewrite Region to be more efficient. See https://bugs.webkit.org/show_bug.cgi?id=100814.
+  // If it's possible for children to have rects outside our bounds, then we
+  // need to descend into the children and compute them.
+  // Ideally there would be other cases where we could detect that children
+  // couldn't have rects outside our bounds and prune the tree walk.
+  // Note that we don't use Region here because Union is O(N) - better to just
+  // keep a list of partially redundant rectangles. If we find examples where
+  // this is expensive, then we could rewrite Region to be more efficient. See
+  // https://bugs.webkit.org/show_bug.cgi?id=100814.
   if (!isLayoutView()) {
     for (LayoutObject* curr = slowFirstChild(); curr;
          curr = curr->nextSibling()) {
       curr->addLayerHitTestRects(layerRects, currentLayer, layerOffset,
                                  newContainerRect);
     }
   }
 }
 
 bool LayoutObject::isRooted() const {
@@ skipping 48 matching lines @@
   if (pos == FixedPosition)
     return containerForFixedPosition(ancestor, ancestorSkipped, filterSkipped);
 
   if (pos == AbsolutePosition)
     return containerForAbsolutePosition(ancestor, ancestorSkipped,
                                         filterSkipped);
 
   if (isColumnSpanAll()) {
     LayoutObject* multicolContainer = spannerPlaceholder()->container();
     if ((ancestorSkipped && ancestor) || filterSkipped) {
-      // We jumped directly from the spanner to the multicol container. Need to check if
-      // we skipped |ancestor| or filter/reflection on the way.
+      // We jumped directly from the spanner to the multicol container. Need to
+      // check if we skipped |ancestor| or filter/reflection on the way.
       for (LayoutObject* walker = parent();
            walker && walker != multicolContainer; walker = walker->parent()) {
         if (ancestorSkipped && walker == ancestor)
           *ancestorSkipped = true;
         if (filterSkipped && walker->hasFilterInducingProperty())
           *filterSkipped = true;
       }
     }
     return multicolContainer;
   }
@@ skipping 26 matching lines @@
   LayoutObjectChildList* children = virtualChildren();
   if (children)
     children->destroyLeftoverChildren();
 
   if (LocalFrame* frame = this->frame()) {
     // If this layoutObject is being autoscrolled, stop the autoscrolling.
     if (frame->page())
       frame->page()->autoscrollController().stopAutoscrollIfNeeded(this);
   }
 
-  // For accessibility management, notify the parent of the imminent change to its child set.
+  // For accessibility management, notify the parent of the imminent change to
+  // its child set.
   // We do it now, before remove(), while the parent pointer is still available.
   if (AXObjectCache* cache = document().existingAXObjectCache())
     cache->childrenChanged(this->parent());
 
   remove();
 
-  // The remove() call above may invoke axObjectCache()->childrenChanged() on the parent, which may require the AX layout
-  // object for this layoutObject. So we remove the AX layout object now, after the layoutObject is removed.
+  // The remove() call above may invoke axObjectCache()->childrenChanged() on
+  // the parent, which may require the AX layout object for this layoutObject.
+  // So we remove the AX layout object now, after the layoutObject is removed.
   if (AXObjectCache* cache = document().existingAXObjectCache())
     cache->remove(this);
 
-  // If this layoutObject had a parent, remove should have destroyed any counters
-  // attached to this layoutObject and marked the affected other counters for
-  // reevaluation. This apparently redundant check is here for the case when
-  // this layoutObject had no parent at the time remove() was called.
+  // If this layoutObject had a parent, remove should have destroyed any
+  // counters attached to this layoutObject and marked the affected other
+  // counters for reevaluation. This apparently redundant check is here for the
+  // case when this layoutObject had no parent at the time remove() was called.
 
   if (hasCounterNodeMap())
     LayoutCounter::destroyCounterNodes(*this);
 
   // Remove the handler if node had touch-action set. Handlers are not added
   // for text nodes so don't try removing for one too. Need to check if
   // m_style is null in cases of partial construction. Any handler we added
   // previously may have already been removed by the Document independently.
   if (node() && !node()->isTextNode() && m_style &&
       m_style->getTouchAction() != TouchActionAuto) {
@@ skipping 44 matching lines @@
     removeShapeImageClient(m_style->shapeOutside());
     removeCursorImageClient(m_style->cursors());
   }
 
   if (frameView())
     setIsBackgroundAttachmentFixedObject(false);
 }
 
 DISABLE_CFI_PERF
 void LayoutObject::insertedIntoTree() {
-  // FIXME: We should ASSERT(isRooted()) here but generated content makes some out-of-order insertion.
+  // FIXME: We should ASSERT(isRooted()) here but generated content makes some
+  // out-of-order insertion.
 
-  // Keep our layer hierarchy updated. Optimize for the common case where we don't have any children
-  // and don't have a layer attached to ourselves.
+  // Keep our layer hierarchy updated. Optimize for the common case where we
+  // don't have any children and don't have a layer attached to ourselves.
   PaintLayer* layer = nullptr;
   if (slowFirstChild() || hasLayer()) {
     layer = parent()->enclosingLayer();
     addLayers(layer);
   }
 
-  // If |this| is visible but this object was not, tell the layer it has some visible content
-  // that needs to be drawn and layer visibility optimization can't be used
+  // If |this| is visible but this object was not, tell the layer it has some
+  // visible content that needs to be drawn and layer visibility optimization
+  // can't be used
   if (parent()->style()->visibility() != EVisibility::Visible &&
       style()->visibility() == EVisibility::Visible && !hasLayer()) {
     if (!layer)
       layer = parent()->enclosingLayer();
     if (layer)
       layer->dirtyVisibleContentStatus();
   }
 
   if (parent()->childrenInline())
     parent()->dirtyLinesFromChangedChild(this);
@@ skipping 33 matching lines @@
     if (anchor->refersTo(layoutObject)) {
       found = true;
       if (behavior == Clear)
         anchor->notifyRemoved(layoutObject);
     }
   }
   return found;
 }
 
 void LayoutObject::willBeRemovedFromTree() {
-  // FIXME: We should ASSERT(isRooted()) but we have some out-of-order removals which would need to be fixed first.
+  // FIXME: We should ASSERT(isRooted()) but we have some out-of-order removals
+  // which would need to be fixed first.
 
-  // If we remove a visible child from an invisible parent, we don't know the layer visibility any more.
+  // If we remove a visible child from an invisible parent, we don't know the
+  // layer visibility any more.
   PaintLayer* layer = nullptr;
   if (parent()->style()->visibility() != EVisibility::Visible &&
       style()->visibility() == EVisibility::Visible && !hasLayer()) {
     layer = parent()->enclosingLayer();
     if (layer)
       layer->dirtyVisibleContentStatus();
   }
 
   // Keep our layer hierarchy updated.
   if (slowFirstChild() || hasLayer()) {
     if (!layer)
       layer = parent()->enclosingLayer();
     removeLayers(layer);
   }
 
   if (isOutOfFlowPositioned() && parent()->childrenInline())
     parent()->dirtyLinesFromChangedChild(this);
 
   removeFromLayoutFlowThread();
 
   // Update cached boundaries in SVG layoutObjects if a child is removed.
   if (parent()->isSVG())
     parent()->setNeedsBoundariesUpdate();
 
   if (RuntimeEnabledFeatures::scrollAnchoringEnabled() &&
       m_bitfields.isScrollAnchorObject()) {
-    // Clear the bit first so that anchor.clear() doesn't recurse into findReferencingScrollAnchors.
+    // Clear the bit first so that anchor.clear() doesn't recurse into
+    // findReferencingScrollAnchors.
     m_bitfields.setIsScrollAnchorObject(false);
     findReferencingScrollAnchors(this, Clear);
   }
 }
 
 void LayoutObject::maybeClearIsScrollAnchorObject() {
   if (m_bitfields.isScrollAnchorObject())
     m_bitfields.setIsScrollAnchorObject(
         findReferencingScrollAnchors(this, DontClear));
 }
 
 void LayoutObject::removeFromLayoutFlowThread() {
   if (!isInsideFlowThread())
     return;
 
-  // Sometimes we remove the element from the flow, but it's not destroyed at that time.
-  // It's only until later when we actually destroy it and remove all the children from it.
+  // Sometimes we remove the element from the flow, but it's not destroyed at
+  // that time.
+  // It's only until later when we actually destroy it and remove all the
+  // children from it.
   // Currently, that happens for firstLetter elements and list markers.
-  // Pass in the flow thread so that we don't have to look it up for all the children.
-  // If we're a column spanner, we need to use our parent to find the flow thread, since a spanner
-  // doesn't have the flow thread in its containing block chain. We still need to notify the flow
-  // thread when the layoutObject removed happens to be a spanner, so that we get rid of the spanner
+  // Pass in the flow thread so that we don't have to look it up for all the
+  // children.
+  // If we're a column spanner, we need to use our parent to find the flow
+  // thread, since a spanner doesn't have the flow thread in its containing
+  // block chain. We still need to notify the flow thread when the layoutObject
+  // removed happens to be a spanner, so that we get rid of the spanner
   // placeholder, and column sets around the placeholder get merged.
   LayoutFlowThread* flowThread = isColumnSpanAll()
                                      ? parent()->flowThreadContainingBlock()
                                      : flowThreadContainingBlock();
   removeFromLayoutFlowThreadRecursive(flowThread);
 }
 
 void LayoutObject::removeFromLayoutFlowThreadRecursive(
     LayoutFlowThread* layoutFlowThread) {
   if (const LayoutObjectChildList* children = virtualChildren()) {
@@ skipping 19 matching lines @@
     destroy();
     return;
   }
 
   LayoutObject* destroyRoot = this;
   for (LayoutObject *destroyRootParent = destroyRoot->parent();
        destroyRootParent && destroyRootParent->isAnonymous() &&
        !destroyRootParent->parent()->createsAnonymousWrapper();
        destroyRoot = destroyRootParent,
                     destroyRootParent = destroyRootParent->parent()) {
-    // Anonymous block continuations are tracked and destroyed elsewhere (see the bottom of LayoutBlock::removeChild)
+    // Anonymous block continuations are tracked and destroyed elsewhere (see
+    // the bottom of LayoutBlock::removeChild)
     if (destroyRootParent->isLayoutBlockFlow() &&
         toLayoutBlockFlow(destroyRootParent)->isAnonymousBlockContinuation())
       break;
-    // A flow thread is tracked by its containing block. Whether its children are removed or not is irrelevant.
+    // A flow thread is tracked by its containing block. Whether its children
+    // are removed or not is irrelevant.
     if (destroyRootParent->isLayoutFlowThread())
       break;
 
     if (destroyRootParent->slowFirstChild() != destroyRoot ||
         destroyRootParent->slowLastChild() != destroyRoot)
-      break;  // Need to keep the anonymous parent, since it won't become empty by the removal of this layoutObject.
+      break;  // Need to keep the anonymous parent, since it won't become empty
+              // by the removal of this layoutObject.
   }
 
   destroyRoot->destroy();
 
   // WARNING: |this| is deleted here.
 }
 
 void LayoutObject::destroy() {
   willBeDestroyed();
   delete this;
@@ skipping 37 matching lines @@
   if (hitTestFilter != HitTestSelf) {
     // First test the foreground layer (lines and inlines).
     inside = nodeAtPoint(result, locationInContainer, accumulatedOffset,
                          HitTestForeground);
 
     // Test floats next.
     if (!inside)
       inside = nodeAtPoint(result, locationInContainer, accumulatedOffset,
                            HitTestFloat);
 
-    // Finally test to see if the mouse is in the background (within a child block's background).
+    // Finally test to see if the mouse is in the background (within a child
+    // block's background).
     if (!inside)
       inside = nodeAtPoint(result, locationInContainer, accumulatedOffset,
                            HitTestChildBlockBackgrounds);
   }
 
   // See if the mouse is inside us but not any of our descendants
   if (hitTestFilter != HitTestDescendants && !inside)
     inside = nodeAtPoint(result, locationInContainer, accumulatedOffset,
                          HitTestBlockBackground);
 
@@ skipping 40 matching lines @@
     }
   }
 }
 
 void LayoutObject::forceLayout() {
   setSelfNeedsLayout(true);
   setShouldDoFullPaintInvalidation();
   layout();
 }
 
-// FIXME: Does this do anything different than forceLayout given that we don't walk
-// the containing block chain. If not, we should change all callers to use forceLayout.
+// FIXME: Does this do anything different than forceLayout given that we don't
+// walk the containing block chain. If not, we should change all callers to use
+// forceLayout.
 void LayoutObject::forceChildLayout() {
   setNormalChildNeedsLayout(true);
   layout();
 }
 
 enum StyleCacheState { Cached, Uncached };
 
 static PassRefPtr<ComputedStyle> firstLineStyleForCachedUncachedType(
     StyleCacheState type,
     const LayoutObject* layoutObject,
@@ skipping 13 matching lines @@
           firstLineBlock == layoutObject ? style : 0);
     }
   } else if (!layoutObjectForFirstLineStyle->isAnonymous() &&
              layoutObjectForFirstLineStyle->isLayoutInline() &&
              !layoutObjectForFirstLineStyle->node()
                   ->isFirstLetterPseudoElement()) {
     const ComputedStyle* parentStyle =
         layoutObjectForFirstLineStyle->parent()->firstLineStyle();
     if (parentStyle != layoutObjectForFirstLineStyle->parent()->style()) {
       if (type == Cached) {
-        // A first-line style is in effect. Cache a first-line style for ourselves.
+        // A first-line style is in effect. Cache a first-line style for
+        // ourselves.
         layoutObjectForFirstLineStyle->mutableStyleRef().setHasPseudoStyle(
             PseudoIdFirstLineInherited);
         return layoutObjectForFirstLineStyle->getCachedPseudoStyle(
             PseudoIdFirstLineInherited, parentStyle);
       }
       return layoutObjectForFirstLineStyle->getUncachedPseudoStyle(
           PseudoStyleRequest(PseudoIdFirstLineInherited), parentStyle, style);
     }
   }
   return nullptr;
@@ skipping 96 matching lines @@
   unsigned currDecs = TextDecorationNone;
   Color resultColor;
   TextDecorationStyle resultStyle;
   do {
     styleToUse = curr->style(firstlineStyle);
     currDecs = styleToUse->getTextDecoration();
     currDecs &= decorations;
     resultColor =
         styleToUse->visitedDependentColor(CSSPropertyTextDecorationColor);
     resultStyle = styleToUse->getTextDecorationStyle();
-    // Parameter 'decorations' is cast as an int to enable the bitwise operations below.
+    // Parameter 'decorations' is cast as an int to enable the bitwise
+    // operations below.
     if (currDecs) {
       if (currDecs & TextDecorationUnderline) {
         decorations &= ~TextDecorationUnderline;
         underline.color = resultColor;
         underline.style = resultStyle;
       }
       if (currDecs & TextDecorationOverline) {
         decorations &= ~TextDecorationOverline;
         overline.color = resultColor;
         overline.style = resultStyle;
       }
       if (currDecs & TextDecorationLineThrough) {
         decorations &= ~TextDecorationLineThrough;
         linethrough.color = resultColor;
         linethrough.style = resultStyle;
       }
     }
     if (curr->isRubyText())
       return;
     curr = curr->parent();
     if (curr && curr->isAnonymousBlock() && curr->isLayoutBlockFlow() &&
         toLayoutBlockFlow(curr)->continuation())
       curr = toLayoutBlockFlow(curr)->continuation();
   } while (curr && decorations && (!quirksMode || !curr->node() ||
                                    (!isHTMLAnchorElement(*curr->node()) &&
                                     !isHTMLFontElement(*curr->node()))));
 
-  // If we bailed out, use the element we bailed out at (typically a <font> or <a> element).
+  // If we bailed out, use the element we bailed out at (typically a <font> or
+  // <a> element).
   if (decorations && curr) {
     styleToUse = curr->style(firstlineStyle);
     resultColor =
         styleToUse->visitedDependentColor(CSSPropertyTextDecorationColor);
     if (decorations & TextDecorationUnderline) {
       underline.color = resultColor;
       underline.style = resultStyle;
     }
     if (decorations & TextDecorationOverline) {
       overline.color = resultColor;
@@ skipping 18 matching lines @@
   FloatRect localBounds(FloatPoint(), FloatSize(box->size()));
   FloatRect absBounds = localToAbsoluteQuad(localBounds).boundingBox();
 
   AnnotatedRegionValue region;
   region.draggable = style()->getDraggableRegionMode() == DraggableRegionDrag;
   region.bounds = LayoutRect(absBounds);
   regions.append(region);
 }
 
 bool LayoutObject::willRenderImage() {
-  // Without visibility we won't render (and therefore don't care about animation).
+  // Without visibility we won't render (and therefore don't care about
+  // animation).
   if (style()->visibility() != EVisibility::Visible)
     return false;
 
   // We will not render a new image when Active DOM is suspended
   if (document().activeDOMObjectsAreSuspended())
     return false;
 
-  // If we're not in a window (i.e., we're dormant from being in a background tab)
-  // then we don't want to render either.
+  // If we're not in a window (i.e., we're dormant from being in a background
+  // tab) then we don't want to render either.
   return document().view()->isVisible();
 }
 
 bool LayoutObject::getImageAnimationPolicy(ImageAnimationPolicy& policy) {
   if (!document().settings())
     return false;
   policy = document().settings()->imageAnimationPolicy();
   return true;
 }
 
@@ skipping 39 matching lines @@
   Node* node = nullptr;
   for (LayoutObject* ancestor = parent(); ancestor;
        ancestor = ancestor->parent()) {
     // Spec: http://www.w3.org/TR/cssom-view/#offset-attributes
 
     node = ancestor->node();
 
     if (!node)
       continue;
 
-    // TODO(kochi): If |base| or |node| is nested deep in shadow roots, this loop may
-    // get expensive, as isUnclosedNodeOf() can take up to O(N+M) time (N and M are depths).
+    // TODO(kochi): If |base| or |node| is nested deep in shadow roots, this
+    // loop may get expensive, as isUnclosedNodeOf() can take up to O(N+M) time
+    // (N and M are depths).
     if (base &&
         (node->isClosedShadowHiddenFrom(*base) ||
          (node->isInShadowTree() &&
           node->containingShadowRoot()->type() == ShadowRootType::UserAgent))) {
-      // If 'position: fixed' node is found while traversing up, terminate the loop and
-      // return null.
+      // If 'position: fixed' node is found while traversing up, terminate the
+      // loop and return null.
       if (ancestor->isFixedPositioned())
         return nullptr;
       continue;
     }
 
     if (ancestor->canContainAbsolutePositionObjects())
       break;
 
     if (isHTMLBodyElement(*node))
       break;
 
     if (!isPositioned() &&
         (isHTMLTableElement(*node) || isHTMLTableCellElement(*node)))
       break;
 
     // Webkit specific extension where offsetParent stops at zoom level changes.
     if (effectiveZoom != ancestor->style()->effectiveZoom())
       break;
   }
 
   return node && node->isElementNode() ? toElement(node) : nullptr;
 }
 
 PositionWithAffinity LayoutObject::createPositionWithAffinity(
     int offset,
     TextAffinity affinity) {
-  // If this is a non-anonymous layoutObject in an editable area, then it's simple.
+  // If this is a non-anonymous layoutObject in an editable area, then it's
+  // simple.
   if (Node* node = nonPseudoNode()) {
     if (!hasEditableStyle(*node)) {
-      // If it can be found, we prefer a visually equivalent position that is editable.
+      // If it can be found, we prefer a visually equivalent position that is
+      // editable.
       const Position position = Position(node, offset);
       Position candidate =
           mostForwardCaretPosition(position, CanCrossEditingBoundary);
       if (hasEditableStyle(*candidate.anchorNode()))
         return PositionWithAffinity(candidate, affinity);
       candidate = mostBackwardCaretPosition(position, CanCrossEditingBoundary);
       if (hasEditableStyle(*candidate.anchorNode()))
         return PositionWithAffinity(candidate, affinity);
     }
     // FIXME: Eliminate legacy editing positions
@@ skipping 205 matching lines @@
     DeprecatedDisableModifyLayoutTreeStructureAsserts()
     : m_disabler(&gModifyLayoutTreeStructureAnyState, true) {}
 
 bool DeprecatedDisableModifyLayoutTreeStructureAsserts::
     canModifyLayoutTreeStateInAnyState() {
   return gModifyLayoutTreeStructureAnyState;
 }
 
 void LayoutObject::
     setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants() {
-  // Clear first because PaintInvalidationSubtree overrides other full paint invalidation reasons.
+  // Clear first because PaintInvalidationSubtree overrides other full paint
+  // invalidation reasons.
   clearShouldDoFullPaintInvalidation();
   setShouldDoFullPaintInvalidation(PaintInvalidationSubtree);
 }
 
 void LayoutObject::setIsBackgroundAttachmentFixedObject(
     bool isBackgroundAttachmentFixedObject) {
   ASSERT(frameView());
   if (m_bitfields.isBackgroundAttachmentFixedObject() ==
       isBackgroundAttachmentFixedObject)
     return;
@@ skipping 56 matching lines @@
     const blink::LayoutObject* root = object1;
     while (root->parent())
       root = root->parent();
     root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
   } else {
     WTFLogAlways("%s", "Cannot showLayoutTree. Root is (nil)");
   }
 }
 
 #endif