Reformat comments in core/layout up until LayoutMultiColumnFlowThread

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 67 matching lines @@
 void LayoutBoxModelObject::setSelectionState(SelectionState state) {
   if (state == SelectionInside && getSelectionState() != SelectionNone)
     return;
 
   if ((state == SelectionStart && getSelectionState() == SelectionEnd) ||
       (state == SelectionEnd && getSelectionState() == SelectionStart))
     LayoutObject::setSelectionState(SelectionBoth);
   else
     LayoutObject::setSelectionState(state);
 
-  // FIXME: We should consider whether it is OK propagating to ancestor LayoutInlines.
-  // This is a workaround for http://webkit.org/b/32123
+  // FIXME: We should consider whether it is OK propagating to ancestor
+  // LayoutInlines. This is a workaround for http://webkit.org/b/32123
   // The containing block can be null in case of an orphaned tree.
   LayoutBlock* containingBlock = this->containingBlock();
   if (containingBlock && !containingBlock->isLayoutView())
     containingBlock->setSelectionState(state);
 }
 
 void LayoutBoxModelObject::contentChanged(ContentChangeType changeType) {
   if (!hasLayer())
     return;
 
@@ skipping 13 matching lines @@
 }
 
 bool LayoutBoxModelObject::hasLocalEquivalentBackground() const {
   int minBorderWidth = std::min(
       style()->borderTopWidth(),
       std::min(
           style()->borderLeftWidth(),
           std::min(style()->borderRightWidth(), style()->borderBottomWidth())));
   bool outlineOverlapsPaddingBox = style()->outlineOffset() < -minBorderWidth;
   bool hasCustomScrollbars = false;
-  // TODO(flackr): Detect opaque custom scrollbars which would cover up a border-box
-  // background.
+  // TODO(flackr): Detect opaque custom scrollbars which would cover up a
+  // border-box background.
   if (PaintLayerScrollableArea* scrollableArea = getScrollableArea()) {
     if ((scrollableArea->horizontalScrollbar() &&
          scrollableArea->horizontalScrollbar()->isCustomScrollbar()) ||
         (scrollableArea->verticalScrollbar() &&
          scrollableArea->verticalScrollbar()->isCustomScrollbar())) {
       hasCustomScrollbars = true;
     }
   }
 
   // TODO(flackr): When we correctly clip the scrolling contents layer we can
   // paint locally equivalent backgrounds into it. https://crbug.com/645957
   if (!style()->hasAutoClip())
     return false;
 
-  // TODO(flackr): Remove this when box shadows are still painted correctly when painting
-  // into the composited scrolling contents layer. https://crbug.com/646464
+  // TODO(flackr): Remove this when box shadows are still painted correctly when
+  // painting into the composited scrolling contents layer.
+  // https://crbug.com/646464
   if (style()->boxShadow())
     return false;
 
   const FillLayer* layer = &(style()->backgroundLayers());
   for (; layer; layer = layer->next()) {
     if (layer->attachment() == LocalBackgroundAttachment)
       continue;
 
-    // If the outline draws inside the border, it intends to draw on top of the scroller's background,
-    // however because it is painted into a layer behind the scrolling contents layer we avoid auto
-    // promoting in this case to avoid obscuring the outline.
-    // TODO(flackr): Outlines should be drawn on top of the scrolling contents layer so that
-    // they cannot be covered up by composited scrolling contents.
+    // If the outline draws inside the border, it intends to draw on top of the
+    // scroller's background, however because it is painted into a layer behind
+    // the scrolling contents layer we avoid auto promoting in this case to
+    // avoid obscuring the outline.
+    // TODO(flackr): Outlines should be drawn on top of the scrolling contents
+    // layer so that they cannot be covered up by composited scrolling contents.
     if (outlineOverlapsPaddingBox)
       return false;
 
-    // Solid color layers with an effective background clip of the padding box can be treated
-    // as local.
+    // Solid color layers with an effective background clip of the padding box
+    // can be treated as local.
     if (!layer->image() && !layer->next() &&
         resolveColor(CSSPropertyBackgroundColor).alpha() > 0) {
       EFillBox clip = layer->clip();
       if (clip == PaddingFillBox)
         continue;
-      // A border box can be treated as a padding box if the border is opaque or there is
-      // no border and we don't have custom scrollbars.
+      // A border box can be treated as a padding box if the border is opaque or
+      // there is no border and we don't have custom scrollbars.
       if (clip == BorderFillBox && !hasCustomScrollbars &&
           (style()->borderTopWidth() == 0 ||
            !resolveColor(CSSPropertyBorderTopColor).hasAlpha()) &&
           (style()->borderLeftWidth() == 0 ||
            !resolveColor(CSSPropertyBorderLeftColor).hasAlpha()) &&
           (style()->borderRightWidth() == 0 ||
            !resolveColor(CSSPropertyBorderRightColor).hasAlpha()) &&
           (style()->borderBottomWidth() == 0 ||
            !resolveColor(CSSPropertyBorderBottomColor).hasAlpha())) {
         continue;
       }
-      // A content fill box can be treated as a padding fill box if there is no padding.
+      // A content fill box can be treated as a padding fill box if there is no
+      // padding.
       if (clip == ContentFillBox && style()->paddingTop().isZero() &&
           style()->paddingLeft().isZero() && style()->paddingRight().isZero() &&
           style()->paddingBottom().isZero()) {
         continue;
       }
     }
     return false;
   }
   return true;
 }
 
 LayoutBoxModelObject::~LayoutBoxModelObject() {
   // Our layer should have been destroyed and cleared by now
   ASSERT(!hasLayer());
   ASSERT(!m_layer);
 }
 
 void LayoutBoxModelObject::willBeDestroyed() {
   ImageQualityController::remove(*this);
 
   // A continuation of this LayoutObject should be destroyed at subclasses.
   ASSERT(!continuation());
 
   if (isPositioned()) {
-    // Don't use this->view() because the document's layoutView has been set to 0 during destruction.
+    // Don't use this->view() because the document's layoutView has been set to
+    // 0 during destruction.
     if (LocalFrame* frame = this->frame()) {
       if (FrameView* frameView = frame->view()) {
         if (style()->hasViewportConstrainedPosition())
           frameView->removeViewportConstrainedObject(this);
       }
     }
   }
 
   LayoutObject::willBeDestroyed();
 
   destroyLayer();
 }
 
 void LayoutBoxModelObject::styleWillChange(StyleDifference diff,
                                            const ComputedStyle& newStyle) {
-  // This object's layer may cease to be a stacking context, in which case the paint
-  // invalidation container of the children may change. Thus we need to invalidate paint
-  // eagerly for all such children.
+  // This object's layer may cease to be a stacking context, in which case the
+  // paint invalidation container of the children may change. Thus we need to
+  // invalidate paint eagerly for all such children.
   if (hasLayer() && enclosingLayer()->stackingNode() &&
       enclosingLayer()->stackingNode()->isStackingContext() &&
       !newStyle.isStackingContext()) {
-    // The following disablers are valid because we need to invalidate based on the current
-    // status.
+    // The following disablers are valid because we need to invalidate based on
+    // the current status.
     DisableCompositingQueryAsserts compositingDisabler;
     DisablePaintInvalidationStateAsserts paintDisabler;
     ObjectPaintInvalidator(*this)
         .invalidatePaintIncludingNonCompositingDescendants();
   }
 
   FloatStateForStyleChange::setWasFloating(this, isFloating());
 
   if (const ComputedStyle* oldStyle = style()) {
     if (hasLayer() && diff.needsPaintInvalidationSubtree()) {
@@ skipping 12 matching lines @@
   bool hadTransform = hasTransformRelatedProperty();
   bool hadLayer = hasLayer();
   bool layerWasSelfPainting = hadLayer && layer()->isSelfPaintingLayer();
   bool wasFloatingBeforeStyleChanged =
       FloatStateForStyleChange::wasFloating(this);
   bool wasHorizontalWritingMode = isHorizontalWritingMode();
 
   LayoutObject::styleDidChange(diff, oldStyle);
   updateFromStyle();
 
-  // When an out-of-flow-positioned element changes its display between block and inline-block,
-  // then an incremental layout on the element's containing block lays out the element through
-  // LayoutPositionedObjects, which skips laying out the element's parent.
-  // The element's parent needs to relayout so that it calls
-  // LayoutBlockFlow::setStaticInlinePositionForChild with the out-of-flow-positioned child, so
-  // that when it's laid out, its LayoutBox::computePositionedLogicalWidth/Height takes into
-  // account its new inline/block position rather than its old block/inline position.
+  // When an out-of-flow-positioned element changes its display between block
+  // and inline-block, then an incremental layout on the element's containing
+  // block lays out the element through LayoutPositionedObjects, which skips
+  // laying out the element's parent.
+  // The element's parent needs to relayout so that it calls LayoutBlockFlow::
+  // setStaticInlinePositionForChild with the out-of-flow-positioned child, so
+  // that when it's laid out, its LayoutBox::computePositionedLogicalWidth/
+  // Height takes into account its new inline/block position rather than its old
+  // block/inline position.
   // Position changes and other types of display changes are handled elsewhere.
   if (oldStyle && isOutOfFlowPositioned() && parent() &&
       (parent() != containingBlock()) &&
       (styleRef().position() == oldStyle->position()) &&
       (styleRef().originalDisplay() != oldStyle->originalDisplay()) &&
       ((styleRef().originalDisplay() == EDisplay::Block) ||
        (styleRef().originalDisplay() == EDisplay::InlineBlock)) &&
       ((oldStyle->originalDisplay() == EDisplay::Block) ||
        (oldStyle->originalDisplay() == EDisplay::InlineBlock)))
     parent()->setNeedsLayout(LayoutInvalidationReason::ChildChanged,
                              MarkContainerChain);
 
   PaintLayerType type = layerTypeRequired();
   if (type != NoPaintLayer) {
     if (!layer() && layerCreationAllowedForSubtree()) {
       if (wasFloatingBeforeStyleChanged && isFloating())
         setChildNeedsLayout();
       createLayer();
       if (parent() && !needsLayout()) {
         // FIXME: We should call a specialized version of this function.
         layer()->updateLayerPositionsAfterLayout();
       }
     }
   } else if (layer() && layer()->parent()) {
     PaintLayer* parentLayer = layer()->parent();
-    setHasTransformRelatedProperty(
-        false);  // Either a transform wasn't specified or the object doesn't support transforms, so just null out the bit.
+    // Either a transform wasn't specified or the object doesn't support
+    // transforms, so just null out the bit.
+    setHasTransformRelatedProperty(false);
     setHasReflection(false);
-    layer()
-        ->removeOnlyThisLayerAfterStyleChange();  // calls destroyLayer() which clears m_layer
+    // Calls destroyLayer() which clears m_layer.
+    layer()->removeOnlyThisLayerAfterStyleChange();
     if (wasFloatingBeforeStyleChanged && isFloating())
       setChildNeedsLayout();
     if (hadTransform)
       setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
           LayoutInvalidationReason::StyleChange);
     if (!needsLayout()) {
       // FIXME: We should call a specialized version of this function.
       parentLayer->updateLayerPositionsAfterLayout();
     }
   }
@@ skipping 56 matching lines @@
 
   if (FrameView* frameView = view()->frameView()) {
     bool newStyleIsViewportConstained = style()->position() == FixedPosition;
     bool oldStyleIsViewportConstrained =
         oldStyle && oldStyle->position() == FixedPosition;
     bool newStyleIsSticky = style()->position() == StickyPosition;
     bool oldStyleIsSticky = oldStyle && oldStyle->position() == StickyPosition;
 
     if (newStyleIsSticky != oldStyleIsSticky) {
       if (newStyleIsSticky) {
-        // During compositing inputs update we'll have the scroll
-        // ancestor without having to walk up the tree and can compute
-        // the sticky position constraints then.
+        // During compositing inputs update we'll have the scroll ancestor
+        // without having to walk up the tree and can compute the sticky
+        // position constraints then.
         if (layer())
           layer()->setNeedsCompositingInputsUpdate();
 
         // TODO(pdr): When slimming paint v2 is enabled, we will need to
-        // invalidate the scroll paint property subtree for this so main
-        // thread scroll reasons are recomputed.
+        // invalidate the scroll paint property subtree for this so main thread
+        // scroll reasons are recomputed.
       } else {
-        // This may get re-added to viewport constrained objects if the object went
-        // from sticky to fixed.
+        // This may get re-added to viewport constrained objects if the object
+        // went from sticky to fixed.
         frameView->removeViewportConstrainedObject(this);
 
         // Remove sticky constraints for this layer.
         if (layer()) {
           DisableCompositingQueryAsserts disabler;
           if (const PaintLayer* ancestorOverflowLayer =
                   layer()->ancestorOverflowLayer())
             ancestorOverflowLayer->getScrollableArea()
                 ->invalidateStickyConstraintsFor(layer());
         }
 
         // TODO(pdr): When slimming paint v2 is enabled, we will need to
-        // invalidate the scroll paint property subtree for this so main
-        // thread scroll reasons are recomputed.
+        // invalidate the scroll paint property subtree for this so main thread
+        // scroll reasons are recomputed.
       }
     }
 
     if (newStyleIsViewportConstained != oldStyleIsViewportConstrained) {
       if (newStyleIsViewportConstained && layer())
         frameView->addViewportConstrainedObject(this);
       else
         frameView->removeViewportConstrainedObject(this);
     }
   }
 }
 
 void LayoutBoxModelObject::invalidateStickyConstraints() {
   if (!layer())
     return;
 
-  // This intentionally uses the stale ancestor overflow layer compositing
-  // input as if we have saved constraints for this layer they were saved
-  // in the previous frame.
+  // This intentionally uses the stale ancestor overflow layer compositing input
+  // as if we have saved constraints for this layer they were saved in the
+  // previous frame.
   DisableCompositingQueryAsserts disabler;
   if (const PaintLayer* ancestorOverflowLayer =
           layer()->ancestorOverflowLayer())
     ancestorOverflowLayer->getScrollableArea()
         ->invalidateAllStickyConstraints();
 }
 
 void LayoutBoxModelObject::createLayer() {
   ASSERT(!m_layer);
   m_layer = wrapUnique(new PaintLayer(this));
@@ skipping 14 matching lines @@
   return m_layer ? m_layer->getScrollableArea() : 0;
 }
 
 void LayoutBoxModelObject::addLayerHitTestRects(
     LayerHitTestRects& rects,
     const PaintLayer* currentLayer,
     const LayoutPoint& layerOffset,
     const LayoutRect& containerRect) const {
   if (hasLayer()) {
     if (isLayoutView()) {
-      // LayoutView is handled with a special fast-path, but it needs to know the current layer.
+      // LayoutView is handled with a special fast-path, but it needs to know
+      // the current layer.
       LayoutObject::addLayerHitTestRects(rects, layer(), LayoutPoint(),
                                          LayoutRect());
     } else {
-      // Since a LayoutObject never lives outside it's container Layer, we can switch
-      // to marking entire layers instead. This may sometimes mark more than necessary (when
-      // a layer is made of disjoint objects) but in practice is a significant performance
-      // savings.
+      // Since a LayoutObject never lives outside it's container Layer, we can
+      // switch to marking entire layers instead. This may sometimes mark more
+      // than necessary (when a layer is made of disjoint objects) but in
+      // practice is a significant performance savings.
       layer()->addLayerHitTestRects(rects);
     }
   } else {
     LayoutObject::addLayerHitTestRects(rects, currentLayer, layerOffset,
                                        containerRect);
   }
 }
 
 static bool hasPercentageTransform(const ComputedStyle& style) {
   if (TransformOperation* translate = style.translate()) {
@@ skipping 26 matching lines @@
       this->previousPaintInvalidationRect();
   LayoutPoint previousPosition = previousPositionFromPaintInvalidationBacking();
   PaintInvalidationReason reason =
       invalidatePaintIfNeeded(newPaintInvalidationState);
   clearPaintInvalidationFlags();
 
   if (previousPosition != previousPositionFromPaintInvalidationBacking())
     newPaintInvalidationState
         .setForceSubtreeInvalidationCheckingWithinContainer();
 
-  // TODO(wangxianzhu): Combine this function into LayoutObject::invalidateTreeIfNeeded() when removing the following workarounds.
+  // TODO(wangxianzhu): Combine this function into LayoutObject::
+  // invalidateTreeIfNeeded() when removing the following workarounds.
 
-  // TODO(wangxianzhu): This is a workaround for crbug.com/533277. Will remove when we enable paint offset caching.
+  // TODO(wangxianzhu): This is a workaround for crbug.com/533277. Will remove
+  // when we enable paint offset caching.
   if (reason != PaintInvalidationNone && hasPercentageTransform(styleRef()))
     newPaintInvalidationState
         .setForceSubtreeInvalidationCheckingWithinContainer();
 
-  // TODO(wangxianzhu): This is a workaround for crbug.com/490725. We don't have enough saved information to do accurate check
-  // of clipping change. Will remove when we remove rect-based paint invalidation.
+  // TODO(wangxianzhu): This is a workaround for crbug.com/490725. We don't have
+  // enough saved information to do accurate check of clipping change. Will
+  // remove when we remove rect-based paint invalidation.
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
       previousPaintInvalidationRect != this->previousPaintInvalidationRect() &&
       !usesCompositedScrolling()
-      // Note that isLayoutView() below becomes unnecessary after the launch of root layer scrolling.
+      // Note that isLayoutView() below becomes unnecessary after the launch of
+      // root layer scrolling.
       && (hasOverflowClip() || isLayoutView()))
     newPaintInvalidationState
         .setForceSubtreeInvalidationRectUpdateWithinContainer();
 
   newPaintInvalidationState.updateForChildren(reason);
   invalidatePaintOfSubtreesIfNeeded(newPaintInvalidationState);
 }
 
 void LayoutBoxModelObject::addOutlineRectsForNormalChildren(
     Vector<LayoutRect>& rects,
     const LayoutPoint& additionalOffset,
     IncludeBlockVisualOverflowOrNot includeBlockOverflows) const {
   for (LayoutObject* child = slowFirstChild(); child;
        child = child->nextSibling()) {
-    // Outlines of out-of-flow positioned descendants are handled in LayoutBlock::addOutlineRects().
+    // Outlines of out-of-flow positioned descendants are handled in
+    // LayoutBlock::addOutlineRects().
     if (child->isOutOfFlowPositioned())
       continue;
 
-    // Outline of an element continuation or anonymous block continuation is added when we iterate the continuation chain.
+    // Outline of an element continuation or anonymous block continuation is
+    // added when we iterate the continuation chain.
     // See LayoutBlock::addOutlineRects() and LayoutInline::addOutlineRects().
     if (child->isElementContinuation() ||
         (child->isLayoutBlockFlow() &&
          toLayoutBlockFlow(child)->isAnonymousBlockContinuation()))
       continue;
 
     addOutlineRectsForDescendant(*child, rects, additionalOffset,
                                  includeBlockOverflows);
   }
 }
@@ skipping 17 matching lines @@
   }
 
   if (descendant.isBox()) {
     descendant.addOutlineRects(
         rects, additionalOffset + toLayoutBox(descendant).locationOffset(),
         includeBlockOverflows);
     return;
   }
 
   if (descendant.isLayoutInline()) {
-    // As an optimization, an ancestor has added rects for its line boxes covering descendants'
-    // line boxes, so descendants don't need to add line boxes again. For example, if the parent
-    // is a LayoutBlock, it adds rects for its RootOutlineBoxes which cover the line boxes of
-    // this LayoutInline. So the LayoutInline needs to add rects for children and continuations only.
+    // As an optimization, an ancestor has added rects for its line boxes
+    // covering descendants' line boxes, so descendants don't need to add line
+    // boxes again. For example, if the parent is a LayoutBlock, it adds rects
+    // for its RootOutlineBoxes which cover the line boxes of this LayoutInline.
+    // So the LayoutInline needs to add rects for children and continuations
+    // only.
     toLayoutInline(descendant)
         .addOutlineRectsForChildrenAndContinuations(rects, additionalOffset,
                                                     includeBlockOverflows);
     return;
   }
 
   descendant.addOutlineRects(rects, additionalOffset, includeBlockOverflows);
 }
 
 bool LayoutBoxModelObject::hasNonEmptyLayoutSize() const {
@@ skipping 27 matching lines @@
 
 static inline bool isOutOfFlowPositionedWithImplicitHeight(
     const LayoutBoxModelObject* child) {
   return child->isOutOfFlowPositioned() &&
          !child->style()->logicalTop().isAuto() &&
          !child->style()->logicalBottom().isAuto();
 }
 
 LayoutBlock* LayoutBoxModelObject::containingBlockForAutoHeightDetection(
     Length logicalHeight) const {
-  // For percentage heights: The percentage is calculated with respect to the height of the generated box's
-  // containing block. If the height of the containing block is not specified explicitly (i.e., it depends
-  // on content height), and this element is not absolutely positioned,  the used height is calculated
-  // as if 'auto' was specified.
+  // For percentage heights: The percentage is calculated with respect to the
+  // height of the generated box's containing block. If the height of the
+  // containing block is not specified explicitly (i.e., it depends on content
+  // height), and this element is not absolutely positioned, the used height is
+  // calculated as if 'auto' was specified.
   if (!logicalHeight.isPercentOrCalc() || isOutOfFlowPositioned())
     return nullptr;
 
-  // Anonymous block boxes are ignored when resolving percentage values that would refer to it:
-  // the closest non-anonymous ancestor box is used instead.
+  // Anonymous block boxes are ignored when resolving percentage values that
+  // would refer to it: the closest non-anonymous ancestor box is used instead.
   LayoutBlock* cb = containingBlock();
   while (cb->isAnonymous())
     cb = cb->containingBlock();
 
   // Matching LayoutBox::percentageLogicalHeightIsResolvableFromBlock() by
-  // ignoring table cell's attribute value, where it says that table cells violate
-  // what the CSS spec says to do with heights. Basically we
-  // don't care if the cell specified a height or not.
+  // ignoring table cell's attribute value, where it says that table cells
+  // violate what the CSS spec says to do with heights. Basically we don't care
+  // if the cell specified a height or not.
   if (cb->isTableCell())
     return nullptr;
 
-  // Match LayoutBox::availableLogicalHeightUsing by special casing
-  // the layout view. The available height is taken from the frame.
+  // Match LayoutBox::availableLogicalHeightUsing by special casing the layout
+  // view. The available height is taken from the frame.
   if (cb->isLayoutView())
     return nullptr;
 
   if (isOutOfFlowPositionedWithImplicitHeight(cb))
     return nullptr;
 
   return cb;
 }
 
 bool LayoutBoxModelObject::hasAutoHeightOrContainingBlockWithAutoHeight(
     bool checkingContainingBlock) const {
-  // TODO(rego): Check if we can somehow reuse LayoutBlock::availableLogicalHeightForPercentageComputation() (see http://crbug.com/635655).
+  // TODO(rego): Check if we can somehow reuse LayoutBlock::
+  // availableLogicalHeightForPercentageComputation() (see crbug.com/635655).
   const LayoutBox* thisBox = isBox() ? toLayoutBox(this) : nullptr;
   Length logicalHeightLength = style()->logicalHeight();
   LayoutBlock* cb = containingBlockForAutoHeightDetection(logicalHeightLength);
   if (logicalHeightLength.isPercentOrCalc() && cb && isBox())
     cb->addPercentHeightDescendant(const_cast<LayoutBox*>(toLayoutBox(this)));
   if (thisBox && thisBox->isFlexItem()) {
     LayoutFlexibleBox& flexBox = toLayoutFlexibleBox(*parent());
     if (flexBox.childLogicalHeightForPercentageResolution(*thisBox) !=
         LayoutUnit(-1))
       return false;
   }
   if (thisBox && thisBox->isGridItem()) {
     if (checkingContainingBlock && thisBox->hasOverrideLogicalContentHeight())
       return false;
     if (!checkingContainingBlock &&
         thisBox->hasOverrideContainingBlockLogicalHeight())
       return false;
   }
   if (logicalHeightLength.isAuto() &&
       !isOutOfFlowPositionedWithImplicitHeight(this))
     return true;
 
   if (document().inQuirksMode())
     return false;
 
-  // If the height of the containing block computes to 'auto', then it hasn't been 'specified explicitly'.
+  // If the height of the containing block computes to 'auto', then it hasn't
+  // been 'specified explicitly'.
   if (cb)
     return cb->hasAutoHeightOrContainingBlockWithAutoHeight(true);
   return false;
 }
 
 bool LayoutBoxModelObject::hasAutoHeightOrContainingBlockWithAutoHeight()
     const {
   return hasAutoHeightOrContainingBlockWithAutoHeight(false);
 }
 
 LayoutSize LayoutBoxModelObject::relativePositionOffset() const {
   LayoutSize offset = accumulateInFlowPositionOffsets();
 
   LayoutBlock* containingBlock = this->containingBlock();
 
-  // Objects that shrink to avoid floats normally use available line width when computing containing block width.  However
-  // in the case of relative positioning using percentages, we can't do this.  The offset should always be resolved using the
-  // available width of the containing block.  Therefore we don't use containingBlockLogicalWidthForContent() here, but instead explicitly
-  // call availableWidth on our containing block.
+  // Objects that shrink to avoid floats normally use available line width when
+  // computing containing block width. However in the case of relative
+  // positioning using percentages, we can't do this. The offset should always
+  // be resolved using the available width of the containing block. Therefore we
+  // don't use containingBlockLogicalWidthForContent() here, but instead
+  // explicitly call availableWidth on our containing block.
   if (!style()->left().isAuto()) {
     if (!style()->right().isAuto() &&
         !containingBlock->style()->isLeftToRightDirection())
       offset.setWidth(
           -valueForLength(style()->right(), containingBlock->availableWidth()));
     else
       offset.expand(
           valueForLength(style()->left(), containingBlock->availableWidth()),
           LayoutUnit());
   } else if (!style()->right().isAuto()) {
     offset.expand(
         -valueForLength(style()->right(), containingBlock->availableWidth()),
         LayoutUnit());
   }
 
-  // If the containing block of a relatively positioned element does not
-  // specify a height, a percentage top or bottom offset should be resolved as
-  // auto. An exception to this is if the containing block has the WinIE quirk
-  // where <html> and <body> assume the size of the viewport. In this case,
-  // calculate the percent offset based on this height.
+  // If the containing block of a relatively positioned element does not specify
+  // a height, a percentage top or bottom offset should be resolved as auto.
+  // An exception to this is if the containing block has the WinIE quirk where
+  // <html> and <body> assume the size of the viewport. In this case, calculate
+  // the percent offset based on this height.
   // See <https://bugs.webkit.org/show_bug.cgi?id=26396>.
   if (!style()->top().isAuto() &&
       (!containingBlock->hasAutoHeightOrContainingBlockWithAutoHeight() ||
        !style()->top().isPercentOrCalc() ||
        containingBlock->stretchesToViewport()))
     offset.expand(
         LayoutUnit(),
         valueForLength(style()->top(), containingBlock->availableHeight()));
 
   else if (!style()->bottom().isAuto() &&
@@ skipping 23 matching lines @@
   }
   LayoutBox* scrollAncestor =
       layer()->ancestorOverflowLayer()->isRootLayer()
           ? nullptr
           : toLayoutBox(layer()->ancestorOverflowLayer()->layoutObject());
 
   LayoutUnit maxContainerWidth =
       containingBlock->isLayoutView()
           ? containingBlock->logicalWidth()
           : containingBlock->containingBlockLogicalWidthForContent();
-  // Sticky positioned element ignore any override logical width on the containing block (as they don't call
-  // containingBlockLogicalWidthForContent). It's unclear whether this is totally fine.
-  // Compute the container-relative area within which the sticky element is allowed to move.
+  // Sticky positioned element ignore any override logical width on the
+  // containing block, as they don't call containingBlockLogicalWidthForContent.
+  // It's unclear whether this is totally fine.
+  // Compute the container-relative area within which the sticky element is
+  // allowed to move.
   LayoutUnit maxWidth = containingBlock->availableLogicalWidth();
 
   // Map the containing block to the scroll ancestor without transforms.
   FloatRect scrollContainerRelativePaddingBoxRect(
       containingBlock->layoutOverflowRect());
   if (containingBlock != scrollAncestor) {
     FloatQuad localQuad(FloatRect(containingBlock->paddingBoxRect()));
     TransformState transformState(TransformState::ApplyTransformDirection,
                                   localQuad.boundingBox().center(), localQuad);
     containingBlock->mapLocalToAncestor(scrollAncestor, transformState,
                                         ApplyContainerFlip);
     transformState.flatten();
     scrollContainerRelativePaddingBoxRect =
         transformState.lastPlanarQuad().boundingBox();
 
-    // The sticky position constraint rects should be independent of the current scroll position, so after
-    // mapping we add in the scroll position to get the container's position within the ancestor scroller's
-    // unscrolled layout overflow.
+    // The sticky position constraint rects should be independent of the current
+    // scroll position, so after mapping we add in the scroll position to get
+    // the container's position within the ancestor scroller's unscrolled layout
+    // overflow.
     ScrollOffset scrollOffset(
         scrollAncestor
             ? toFloatSize(scrollAncestor->getScrollableArea()->scrollPosition())
             : FloatSize());
     scrollContainerRelativePaddingBoxRect.move(scrollOffset);
   }
 
   LayoutRect scrollContainerRelativeContainingBlockRect(
       scrollContainerRelativePaddingBoxRect);
-  // This is removing the padding of the containing block's overflow rect to get the flow
-  // box rectangle and removing the margin of the sticky element to ensure that space between
-  // the sticky element and its containing flow box. It is an open issue whether the margin
-  // should collapse (See https://www.w3.org/TR/css-position-3/#sticky-pos).
+  // This is removing the padding of the containing block's overflow rect to get
+  // the flow box rectangle and removing the margin of the sticky element to
+  // ensure that space between the sticky element and its containing flow box.
+  // It is an open issue whether the margin should collapse.
+  // See https://www.w3.org/TR/css-position-3/#sticky-pos
   scrollContainerRelativeContainingBlockRect.contractEdges(
       minimumValueForLength(containingBlock->style()->paddingTop(),
                             maxContainerWidth) +
           minimumValueForLength(style()->marginTop(), maxWidth),
       minimumValueForLength(containingBlock->style()->paddingRight(),
                             maxContainerWidth) +
           minimumValueForLength(style()->marginRight(), maxWidth),
       minimumValueForLength(containingBlock->style()->paddingBottom(),
                             maxContainerWidth) +
           minimumValueForLength(style()->marginBottom(), maxWidth),
       minimumValueForLength(containingBlock->style()->paddingLeft(),
                             maxContainerWidth) +
           minimumValueForLength(style()->marginLeft(), maxWidth));
 
   constraints.setScrollContainerRelativeContainingBlockRect(
       FloatRect(scrollContainerRelativeContainingBlockRect));
 
   FloatRect stickyBoxRect =
       isLayoutInline() ? FloatRect(toLayoutInline(this)->linesBoundingBox())
                        : FloatRect(toLayoutBox(this)->frameRect());
   FloatRect flippedStickyBoxRect = stickyBoxRect;
   containingBlock->flipForWritingMode(flippedStickyBoxRect);
   FloatPoint stickyLocation =
       flippedStickyBoxRect.location() + skippedContainersOffset;
 
-  // The scrollContainerRelativePaddingBoxRect's position is the padding box so we need to remove the border when finding
-  // the position of the sticky box within the scroll ancestor if the container is not our scroll ancestor.
+  // The scrollContainerRelativePaddingBoxRect's position is the padding box so
+  // we need to remove the border when finding the position of the sticky box
+  // within the scroll ancestor if the container is not our scroll ancestor.
   if (containingBlock != scrollAncestor) {
     FloatSize containerBorderOffset(containingBlock->borderLeft(),
                                     containingBlock->borderTop());
     stickyLocation -= containerBorderOffset;
   }
   constraints.setScrollContainerRelativeStickyBoxRect(
       FloatRect(scrollContainerRelativePaddingBoxRect.location() +
                     toFloatSize(stickyLocation),
                 flippedStickyBoxRect.size()));
 
-  // We skip the right or top sticky offset if there is not enough space to honor both the left/right or top/bottom offsets.
+  // We skip the right or top sticky offset if there is not enough space to
+  // honor both the left/right or top/bottom offsets.
   LayoutUnit horizontalOffsets =
       minimumValueForLength(style()->right(),
                             LayoutUnit(constrainingSize.width())) +
       minimumValueForLength(style()->left(),
                             LayoutUnit(constrainingSize.width()));
   bool skipRight = false;
   bool skipLeft = false;
   if (!style()->left().isAuto() && !style()->right().isAuto()) {
     if (horizontalOffsets >
             scrollContainerRelativeContainingBlockRect.width() ||
@@ skipping 12 matching lines @@
   }
 
   if (!style()->right().isAuto() && !skipRight) {
     constraints.setRightOffset(minimumValueForLength(
         style()->right(), LayoutUnit(constrainingSize.width())));
     constraints.addAnchorEdge(
         StickyPositionScrollingConstraints::AnchorEdgeRight);
   }
 
   bool skipBottom = false;
-  // TODO(flackr): Exclude top or bottom edge offset depending on the writing mode when related
-  // sections are fixed in spec: http://lists.w3.org/Archives/Public/www-style/2014May/0286.html
+  // TODO(flackr): Exclude top or bottom edge offset depending on the writing
+  // mode when related sections are fixed in spec.
+  // See http://lists.w3.org/Archives/Public/www-style/2014May/0286.html
   LayoutUnit verticalOffsets =
       minimumValueForLength(style()->top(),
                             LayoutUnit(constrainingSize.height())) +
       minimumValueForLength(style()->bottom(),
                             LayoutUnit(constrainingSize.height()));
   if (!style()->top().isAuto() && !style()->bottom().isAuto()) {
     if (verticalOffsets > scrollContainerRelativeContainingBlockRect.height() ||
         verticalOffsets + scrollContainerRelativeContainingBlockRect.height() >
             constrainingSize.height()) {
       skipBottom = true;
@@ skipping 31 matching lines @@
   constrainingRect.contract(
       FloatSize(enclosingClippingBox->paddingLeft() +
                     enclosingClippingBox->paddingRight(),
                 enclosingClippingBox->paddingTop() +
                     enclosingClippingBox->paddingBottom()));
   return constrainingRect;
 }
 
 LayoutSize LayoutBoxModelObject::stickyPositionOffset() const {
   const PaintLayer* ancestorOverflowLayer = layer()->ancestorOverflowLayer();
-  // TODO: Force compositing input update if we ask for offset before compositing inputs have been computed?
+  // TODO: Force compositing input update if we ask for offset before
+  // compositing inputs have been computed?
   if (!ancestorOverflowLayer)
     return LayoutSize();
   FloatRect constrainingRect = computeStickyConstrainingRect();
   PaintLayerScrollableArea* scrollableArea =
       ancestorOverflowLayer->getScrollableArea();
 
-  // The sticky offset is physical, so we can just return the delta computed in absolute coords (though it may be wrong with transforms).
-  // TODO: Force compositing input update if we ask for offset with stale compositing inputs.
+  // The sticky offset is physical, so we can just return the delta computed in
+  // absolute coords (though it may be wrong with transforms).
+  // TODO: Force compositing input update if we ask for offset with stale
+  // compositing inputs.
   if (!scrollableArea->stickyConstraintsMap().contains(layer()))
     return LayoutSize();
   return LayoutSize(
       scrollableArea->stickyConstraintsMap().get(layer()).computeStickyOffset(
           constrainingRect));
 }
 
 LayoutPoint LayoutBoxModelObject::adjustedPositionRelativeTo(
     const LayoutPoint& startPoint,
     const Element* element) const {
   // If the element is the HTML body element or doesn't have a parent
   // return 0 and stop this algorithm.
   if (isBody() || !parent())
     return LayoutPoint();
 
   LayoutPoint referencePoint = startPoint;
 
-  // If the base element is null, return the distance between the canvas origin and
-  // the left border edge of the element and stop this algorithm.
+  // If the base element is null, return the distance between the canvas origin
+  // and the left border edge of the element and stop this algorithm.
   if (!element)
     return referencePoint;
 
   if (const LayoutBoxModelObject* offsetParent =
           element->layoutBoxModelObject()) {
     if (!isOutOfFlowPositioned()) {
       if (isInFlowPositioned())
         referencePoint.move(offsetForInFlowPosition());
 
-      // Note that we may fail to find |offsetParent| while walking the container chain, if
-      // |offsetParent| is an inline split into continuations.
-      // <body style="display:inline;" id="offsetParent"><div></div><span id="this">
+      // Note that we may fail to find |offsetParent| while walking the
+      // container chain, if |offsetParent| is an inline split into
+      // continuations: <body style="display:inline;" id="offsetParent"><div>
+      // </div><span id="this">
       // This is why we have to do a nullptr check here.
       // offset(Left|Top) is generally broken when offsetParent is inline.
       for (const LayoutObject* current = container();
            current && current != offsetParent; current = current->container()) {
         // FIXME: What are we supposed to do inside SVG content?
         referencePoint.move(current->columnOffset(referencePoint));
         if (current->isBox() && !current->isTableRow())
           referencePoint.moveBy(toLayoutBox(current)->topLeftLocation());
       }
 
@@ skipping 225 matching lines @@
   LayoutObject* container = this->container(ancestorToStopAt, &ancestorSkipped);
   if (!container)
     return nullptr;
 
   bool isInline = isLayoutInline();
   bool isFixedPos = !isInline && style()->position() == FixedPosition;
   bool containsFixedPosition = canContainFixedPositionObjects();
 
   LayoutSize adjustmentForSkippedAncestor;
   if (ancestorSkipped) {
-    // There can't be a transform between paintInvalidationContainer and ancestorToStopAt, because transforms create containers, so it should be safe
-    // to just subtract the delta between the ancestor and ancestorToStopAt.
+    // There can't be a transform between paintInvalidationContainer and
+    // ancestorToStopAt, because transforms create containers, so it should be
+    // safe to just subtract the delta between the ancestor and
+    // ancestorToStopAt.
     adjustmentForSkippedAncestor =
         -ancestorToStopAt->offsetFromAncestorContainer(container);
   }
 
   LayoutSize containerOffset = offsetFromContainer(container);
   bool offsetDependsOnPoint;
   if (isLayoutFlowThread()) {
     containerOffset += columnOffset(LayoutPoint());
     offsetDependsOnPoint = true;
   } else {
@@ skipping 22 matching lines @@
     geometryMap.push(this, containerOffset, flags, LayoutSize());
   }
 
   return ancestorSkipped ? ancestorToStopAt : container;
 }
 
 void LayoutBoxModelObject::moveChildTo(LayoutBoxModelObject* toBoxModelObject,
                                        LayoutObject* child,
                                        LayoutObject* beforeChild,
                                        bool fullRemoveInsert) {
-  // We assume that callers have cleared their positioned objects list for child moves (!fullRemoveInsert) so the
-  // positioned layoutObject maps don't become stale. It would be too slow to do the map lookup on each call.
+  // We assume that callers have cleared their positioned objects list for child
+  // moves (!fullRemoveInsert) so the positioned layoutObject maps don't become
+  // stale. It would be too slow to do the map lookup on each call.
   ASSERT(!fullRemoveInsert || !isLayoutBlock() ||
          !toLayoutBlock(this)->hasPositionedObjects());
 
   ASSERT(this == child->parent());
   ASSERT(!beforeChild || toBoxModelObject == beforeChild->parent());
 
-  // If a child is moving from a block-flow to an inline-flow parent then any floats currently intruding into
-  // the child can no longer do so. This can happen if a block becomes floating or out-of-flow and is moved
-  // to an anonymous block. Remove all floats from their float-lists immediately as markAllDescendantsWithFloatsForLayout
-  // won't attempt to remove floats from parents that have inline-flow if we try later.
+  // If a child is moving from a block-flow to an inline-flow parent then any
+  // floats currently intruding into the child can no longer do so. This can
+  // happen if a block becomes floating or out-of-flow and is moved to an
+  // anonymous block. Remove all floats from their float-lists immediately as
+  // markAllDescendantsWithFloatsForLayout won't attempt to remove floats from
+  // parents that have inline-flow if we try later.
   if (child->isLayoutBlockFlow() && toBoxModelObject->childrenInline() &&
       !childrenInline()) {
     toLayoutBlockFlow(child)->removeFloatingObjectsFromDescendants();
     ASSERT(!toLayoutBlockFlow(child)->containsFloats());
   }
 
   if (fullRemoveInsert && isLayoutBlock() && child->isBox())
     toLayoutBox(child)->removeFromPercentHeightContainer();
 
   if (fullRemoveInsert && (toBoxModelObject->isLayoutBlock() ||
@@ skipping 32 matching lines @@
     // Save our next sibling as moveChildTo will clear it.
     LayoutObject* nextSibling = child->nextSibling();
     moveChildTo(toBoxModelObject, child, beforeChild, fullRemoveInsert);
     child = nextSibling;
   }
 }
 
 bool LayoutBoxModelObject::backgroundStolenForBeingBody(
     const ComputedStyle* rootElementStyle) const {
   // http://www.w3.org/TR/css3-background/#body-background
-  // If the root element is <html> with no background, and a <body> child element exists,
-  // the root element steals the first <body> child element's background.
+  // If the root element is <html> with no background, and a <body> child
+  // element exists, the root element steals the first <body> child element's
+  // background.
   if (!isBody())
     return false;
 
   Element* rootElement = document().documentElement();
   if (!isHTMLHtmlElement(rootElement))
     return false;
 
   if (!rootElementStyle)
     rootElementStyle = rootElement->ensureComputedStyle();
   if (rootElementStyle->hasBackground())
     return false;
 
   if (node() != document().firstBodyElement())
     return false;
 
   return true;
 }
 
 }  // namespace blink