Reformat comments in core/layout up until LayoutBox

third_party/WebKit/Source/core/layout/LayoutBox.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2006, 2007 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 57 matching lines @@
   LayoutBoxRareData()
       : m_spannerPlaceholder(nullptr),
         m_overrideLogicalContentWidth(-1),
         m_overrideLogicalContentHeight(-1),
         m_hasOverrideContainingBlockContentLogicalWidth(false),
         m_hasOverrideContainingBlockContentLogicalHeight(false),
         m_percentHeightContainer(nullptr),
         m_snapContainer(nullptr),
         m_snapAreas(nullptr) {}
 
-  // For spanners, the spanner placeholder that lays us out within the multicol container.
+  // For spanners, the spanner placeholder that lays us out within the multicol
+  // container.
   LayoutMultiColumnSpannerPlaceholder* m_spannerPlaceholder;
 
   LayoutUnit m_overrideLogicalContentWidth;
   LayoutUnit m_overrideLogicalContentHeight;
 
   bool m_hasOverrideContainingBlockContentLogicalWidth;
   bool m_hasOverrideContainingBlockContentLogicalHeight;
   LayoutUnit m_overrideContainingBlockContentLogicalWidth;
   LayoutUnit m_overrideContainingBlockContentLogicalHeight;
 
@@ skipping 235 matching lines @@
       return;
     m_frameRect.setLocation(location);
     frameRectChanged();
   }
 
   // The ancestor box that this object's location and topLeftLocation are
   // relative to.
   virtual LayoutBox* locationContainer() const;
 
   // FIXME: Currently scrollbars are using int geometry and positioned based on
-  // pixelSnappedBorderBoxRect whose size may change when location changes because of
-  // pixel snapping. This function is used to change location of the LayoutBox outside
-  // of LayoutBox::layout(). Will remove when we use LayoutUnits for scrollbars.
+  // pixelSnappedBorderBoxRect whose size may change when location changes
+  // because of pixel snapping. This function is used to change location of the
+  // LayoutBox outside of LayoutBox::layout(). Will remove when we use
+  // LayoutUnits for scrollbars.
   void setLocationAndUpdateOverflowControlsIfNeeded(const LayoutPoint&);
 
   void setSize(const LayoutSize& size) {
     if (size == m_frameRect.size())
       return;
     m_frameRect.setSize(size);
     frameRectChanged();
   }
   void move(LayoutUnit dx, LayoutUnit dy) {
     if (!dx && !dy)
@@ skipping 20 matching lines @@
     return LayoutRect(LayoutUnit(borderLeft()), LayoutUnit(borderTop()),
                       clientWidth(), clientHeight());
   }
   IntRect pixelSnappedBorderBoxRect() const {
     return IntRect(IntPoint(), m_frameRect.pixelSnappedSize());
   }
   IntRect borderBoundingBox() const final {
     return pixelSnappedBorderBoxRect();
   }
 
-  // The content area of the box (excludes padding - and intrinsic padding for table cells, etc... - and border).
+  // The content area of the box (excludes padding - and intrinsic padding for
+  // table cells, etc... - and border).
   DISABLE_CFI_PERF LayoutRect contentBoxRect() const {
     return LayoutRect(borderLeft() + paddingLeft(), borderTop() + paddingTop(),
                       contentWidth(), contentHeight());
   }
   LayoutSize contentBoxOffset() const {
     return LayoutSize(borderLeft() + paddingLeft(), borderTop() + paddingTop());
   }
   // The content box in absolute coords. Ignores transforms.
   IntRect absoluteContentBox() const;
   // The offset of the content box in absolute coords, ignoring transforms.
   IntSize absoluteContentBoxOffset() const;
-  // The content box converted to absolute coords (taking transforms into account).
+  // The content box converted to absolute coords (taking transforms into
+  // account).
   FloatQuad absoluteContentQuad() const;
   // The enclosing rectangle of the background with given opacity requirement.
   LayoutRect backgroundRect(BackgroundRectType) const;
 
-  // This returns the content area of the box (excluding padding and border). The only difference with contentBoxRect is that computedCSSContentBoxRect
-  // does include the intrinsic padding in the content box as this is what some callers expect (like getComputedStyle).
+  // This returns the content area of the box (excluding padding and border).
+  // The only difference with contentBoxRect is that computedCSSContentBoxRect
+  // does include the intrinsic padding in the content box as this is what some
+  // callers expect (like getComputedStyle).
   LayoutRect computedCSSContentBoxRect() const {
     return LayoutRect(
         borderLeft() + computedCSSPaddingLeft(),
         borderTop() + computedCSSPaddingTop(),
         clientWidth() - computedCSSPaddingLeft() - computedCSSPaddingRight(),
         clientHeight() - computedCSSPaddingTop() - computedCSSPaddingBottom());
   }
 
   void addOutlineRects(Vector<LayoutRect>&,
                        const LayoutPoint& additionalOffset,
                        IncludeBlockVisualOverflowOrNot) const override;
 
   // Use this with caution! No type checking is done!
   LayoutBox* previousSiblingBox() const;
   LayoutBox* previousInFlowSiblingBox() const;
   LayoutBox* nextSiblingBox() const;
   LayoutBox* nextInFlowSiblingBox() const;
   LayoutBox* parentBox() const;
 
-  // Return the previous sibling column set or spanner placeholder. Only to be used on multicol container children.
+  // Return the previous sibling column set or spanner placeholder. Only to be
+  // used on multicol container children.
   LayoutBox* previousSiblingMultiColumnBox() const;
-  // Return the next sibling column set or spanner placeholder. Only to be used on multicol container children.
+  // Return the next sibling column set or spanner placeholder. Only to be used
+  // on multicol container children.
   LayoutBox* nextSiblingMultiColumnBox() const;
 
   bool canResize() const;
 
-  // Visual and layout overflow are in the coordinate space of the box.  This means that they
-  // aren't purely physical directions. For horizontal-tb and vertical-lr they will match physical
-  // directions, but for vertical-rl, the left/right are flipped when compared to their physical
-  // counterparts.  For example minX is on the left in vertical-lr, but it is on the right in
+  // Visual and layout overflow are in the coordinate space of the box. This
+  // means that they aren't purely physical directions. For horizontal-tb and
+  // vertical-lr they will match physical directions, but for vertical-rl, the
+  // left/right are flipped when compared to their physical counterparts.
+  // For example minX is on the left in vertical-lr, but it is on the right in
   // vertical-rl.
   LayoutRect noOverflowRect() const;
   LayoutRect layoutOverflowRect() const {
     return m_overflow ? m_overflow->layoutOverflowRect() : noOverflowRect();
   }
   IntRect pixelSnappedLayoutOverflowRect() const {
     return pixelSnappedIntRect(layoutOverflowRect());
   }
   LayoutSize maxLayoutOverflow() const {
     return LayoutSize(layoutOverflowRect().maxX(), layoutOverflowRect().maxY());
@@ skipping 17 matching lines @@
                                               : visualOverflowRect().maxY();
   }
 
   LayoutRect selfVisualOverflowRect() const {
     return m_overflow ? m_overflow->selfVisualOverflowRect() : borderBoxRect();
   }
   LayoutRect contentsVisualOverflowRect() const {
     return m_overflow ? m_overflow->contentsVisualOverflowRect() : LayoutRect();
   }
 
-  // These methods don't mean the box *actually* has top/left overflow.  They mean that
-  // *if* the box overflows, it will overflow to the top/left rather than the bottom/right.
-  // This happens when child content is laid out right-to-left (e.g. direction:rtl) or
-  // or bottom-to-top (e.g. direction:rtl writing-mode:vertical-rl).
+  // These methods don't mean the box *actually* has top/left overflow. They
+  // mean that *if* the box overflows, it will overflow to the top/left rather
+  // than the bottom/right. This happens when child content is laid out
+  // right-to-left (e.g. direction:rtl) or or bottom-to-top (e.g. direction:rtl
+  // writing-mode:vertical-rl).
   virtual bool hasTopOverflow() const;
   virtual bool hasLeftOverflow() const;
 
   void addLayoutOverflow(const LayoutRect&);
   void addSelfVisualOverflow(const LayoutRect&);
   void addContentsVisualOverflow(const LayoutRect&);
 
   void addVisualEffectOverflow();
   LayoutRectOutsets computeVisualEffectOverflowOutsets() const;
   void addOverflowFromChild(LayoutBox* child) {
@@ skipping 16 matching lines @@
   }
   LayoutUnit contentLogicalWidth() const {
     return style()->isHorizontalWritingMode() ? contentWidth()
                                               : contentHeight();
   }
   LayoutUnit contentLogicalHeight() const {
     return style()->isHorizontalWritingMode() ? contentHeight()
                                               : contentWidth();
   }
 
-  // IE extensions. Used to calculate offsetWidth/Height.  Overridden by inlines (LayoutFlow)
-  // to return the remaining width on a given line (and the height of a single line).
+  // IE extensions. Used to calculate offsetWidth/Height. Overridden by inlines
+  // (LayoutFlow) to return the remaining width on a given line (and the height
+  // of a single line).
   LayoutUnit offsetWidth() const override { return m_frameRect.width(); }
   LayoutUnit offsetHeight() const override { return m_frameRect.height(); }
 
   int pixelSnappedOffsetWidth(const Element*) const final;
   int pixelSnappedOffsetHeight(const Element*) const final;
 
-  // More IE extensions.  clientWidth and clientHeight represent the interior of an object
-  // excluding border and scrollbar.  clientLeft/Top are just the borderLeftWidth and borderTopWidth.
+  // More IE extensions.  clientWidth and clientHeight represent the interior of
+  // an object excluding border and scrollbar. clientLeft/Top are just the
+  // borderLeftWidth and borderTopWidth.
   DISABLE_CFI_PERF LayoutUnit clientLeft() const {
     return LayoutUnit(borderLeft() +
                       (shouldPlaceBlockDirectionScrollbarOnLogicalLeft()
                            ? verticalScrollbarWidth()
                            : 0));
   }
   DISABLE_CFI_PERF LayoutUnit clientTop() const {
     return LayoutUnit(borderTop());
   }
   LayoutUnit clientWidth() const;
   LayoutUnit clientHeight() const;
   DISABLE_CFI_PERF LayoutUnit clientLogicalWidth() const {
     return style()->isHorizontalWritingMode() ? clientWidth() : clientHeight();
   }
   DISABLE_CFI_PERF LayoutUnit clientLogicalHeight() const {
     return style()->isHorizontalWritingMode() ? clientHeight() : clientWidth();
   }
   DISABLE_CFI_PERF LayoutUnit clientLogicalBottom() const {
     return borderBefore() + clientLogicalHeight();
   }
   DISABLE_CFI_PERF LayoutRect clientBoxRect() const {
     return LayoutRect(clientLeft(), clientTop(), clientWidth(), clientHeight());
   }
 
   int pixelSnappedClientWidth() const;
   int pixelSnappedClientHeight() const;
 
-  // scrollWidth/scrollHeight will be the same as clientWidth/clientHeight unless the
-  // object has overflow:hidden/scroll/auto specified and also has overflow.
-  // scrollLeft/Top return the current scroll position.  These methods are virtual so that objects like
-  // textareas can scroll shadow content (but pretend that they are the objects that are
-  // scrolling).
+  // scrollWidth/scrollHeight will be the same as clientWidth/clientHeight
+  // unless the object has overflow:hidden/scroll/auto specified and also has
+  // overflow. scrollLeft/Top return the current scroll position. These methods
+  // are virtual so that objects like textareas can scroll shadow content (but
+  // pretend that they are the objects that are scrolling).
   virtual LayoutUnit scrollLeft() const;
   virtual LayoutUnit scrollTop() const;
   virtual LayoutUnit scrollWidth() const;
   virtual LayoutUnit scrollHeight() const;
   int pixelSnappedScrollWidth() const;
   int pixelSnappedScrollHeight() const;
   virtual void setScrollLeft(LayoutUnit);
   virtual void setScrollTop(LayoutUnit);
 
   void scrollToOffset(const DoubleSize&,
@@ skipping 78 matching lines @@
                                 styleToUse->direction(), value);
   }
   void setMarginEnd(LayoutUnit value,
                     const ComputedStyle* overrideStyle = nullptr) {
     const ComputedStyle* styleToUse = overrideStyle ? overrideStyle : style();
     m_marginBoxOutsets.setEnd(styleToUse->getWritingMode(),
                               styleToUse->direction(), value);
   }
 
   // The following functions are used to implement collapsing margins.
-  // All objects know their maximal positive and negative margins.  The
-  // formula for computing a collapsed margin is |maxPosMargin| - |maxNegmargin|.
-  // For a non-collapsing box, such as a leaf element, this formula will simply return
-  // the margin of the element.  Blocks override the maxMarginBefore and maxMarginAfter
-  // methods.
+  // All objects know their maximal positive and negative margins. The formula
+  // for computing a collapsed margin is |maxPosMargin| - |maxNegmargin|.
+  // For a non-collapsing box, such as a leaf element, this formula will simply
+  // return the margin of the element.  Blocks override the maxMarginBefore and
+  // maxMarginAfter methods.
   virtual bool isSelfCollapsingBlock() const { return false; }
   virtual LayoutUnit collapsedMarginBefore() const { return marginBefore(); }
   virtual LayoutUnit collapsedMarginAfter() const { return marginAfter(); }
   LayoutRectOutsets collapsedMarginBoxLogicalOutsets() const {
     return LayoutRectOutsets(collapsedMarginBefore(), LayoutUnit(),
                              collapsedMarginAfter(), LayoutUnit());
   }
 
   void absoluteRects(Vector<IntRect>&,
                      const LayoutPoint& accumulatedOffset) const override;
   void absoluteQuads(Vector<FloatQuad>&) const override;
   FloatRect localBoundingBoxRectForAccessibility() const final;
 
   int reflectionOffset() const;
-  // Given a rect in the object's coordinate space, returns the corresponding rect in the reflection.
+  // Given a rect in the object's coordinate space, returns the corresponding
+  // rect in the reflection.
   LayoutRect reflectedRect(const LayoutRect&) const;
 
   void layout() override;
   void paint(const PaintInfo&, const LayoutPoint&) const override;
   bool nodeAtPoint(HitTestResult&,
                    const HitTestLocation& locationInContainer,
                    const LayoutPoint& accumulatedOffset,
                    HitTestAction) override;
 
   LayoutUnit minPreferredLogicalWidth() const override;
   LayoutUnit maxPreferredLogicalWidth() const override;
 
-  // FIXME: We should rename these back to overrideLogicalHeight/Width and have them store
-  // the border-box height/width like the regular height/width accessors on LayoutBox.
-  // Right now, these are different than contentHeight/contentWidth because they still
-  // include the scrollbar height/width.
+  // FIXME: We should rename these back to overrideLogicalHeight/Width and have
+  // them store the border-box height/width like the regular height/width
+  // accessors on LayoutBox. Right now, these are different than contentHeight/
+  // contentWidth because they still include the scrollbar height/width.
   LayoutUnit overrideLogicalContentWidth() const;
   LayoutUnit overrideLogicalContentHeight() const;
   bool hasOverrideLogicalContentHeight() const;
   bool hasOverrideLogicalContentWidth() const;
   void setOverrideLogicalContentHeight(LayoutUnit);
   void setOverrideLogicalContentWidth(LayoutUnit);
   void clearOverrideSize();
   void clearOverrideLogicalContentHeight();
   void clearOverrideLogicalContentWidth();
 
@@ skipping 47 matching lines @@
     // (logical top or logical left).
     LayoutUnit m_position;
 
     // |m_margins| represents the margins in the measured direction.
     // Note that ComputedMarginValues has also the margins in
     // the orthogonal direction to have clearer names but they are
     // ignored in the code.
     ComputedMarginValues m_margins;
   };
 
-  // Resolve auto margins in the chosen direction of the containing block so that objects can be pushed to the start, middle or end
-  // of the containing block.
+  // Resolve auto margins in the chosen direction of the containing block so
+  // that objects can be pushed to the start, middle or end of the containing
+  // block.
   void computeMarginsForDirection(MarginDirection forDirection,
                                   const LayoutBlock* containingBlock,
                                   LayoutUnit containerWidth,
                                   LayoutUnit childWidth,
                                   LayoutUnit& marginStart,
                                   LayoutUnit& marginEnd,
                                   Length marginStartLength,
                                   Length marginStartEnd) const;
 
   // Used to resolve margins in the containing block's block-flow direction.
   void computeAndSetBlockDirectionMargins(const LayoutBlock* containingBlock);
 
   LayoutUnit offsetFromLogicalTopOfFirstPage() const;
 
-  // The page logical offset is the object's offset from the top of the page in the page progression
-  // direction (so an x-offset in vertical text and a y-offset for horizontal text).
+  // The page logical offset is the object's offset from the top of the page in
+  // the page progression direction (so an x-offset in vertical text and a
+  // y-offset for horizontal text).
   LayoutUnit pageLogicalOffset() const {
     return m_rareData ? m_rareData->m_pageLogicalOffset : LayoutUnit();
   }
   void setPageLogicalOffset(LayoutUnit);
 
-  // Specify which page or column to associate with an offset, if said offset is exactly at a page
-  // or column boundary.
+  // Specify which page or column to associate with an offset, if said offset is
+  // exactly at a page or column boundary.
   enum PageBoundaryRule { AssociateWithFormerPage, AssociateWithLatterPage };
   LayoutUnit pageLogicalHeightForOffset(LayoutUnit) const;
   LayoutUnit pageRemainingLogicalHeightForOffset(LayoutUnit,
                                                  PageBoundaryRule) const;
 
-  // Calculate the strut to insert in order fit content of size |contentLogicalHeight|.
-  // |strutToNextPage| is the strut to add to |offset| to merely get to the top of the next page
-  // or column. This is what will be returned if the content can actually fit there. Otherwise,
-  // return the distance to the next fragmentainer that can fit this piece of content.
+  // Calculate the strut to insert in order fit content of size
+  // |contentLogicalHeight|. |strutToNextPage| is the strut to add to |offset|
+  // to merely get to the top of the next page or column. This is what will be
+  // returned if the content can actually fit there. Otherwise, return the
+  // distance to the next fragmentainer that can fit this piece of content.
   virtual LayoutUnit calculatePaginationStrutToFitContent(
       LayoutUnit offset,
       LayoutUnit strutToNextPage,
       LayoutUnit contentLogicalHeight) const;
 
   void positionLineBox(InlineBox*);
   void moveWithEdgeOfInlineContainerIfNecessary(bool isHorizontal);
 
   virtual InlineBox* createInlineBox();
   void dirtyLineBoxes(bool fullLayout);
 
-  // For atomic inline elements, this function returns the inline box that contains us.  Enables
-  // the atomic inline LayoutObject to quickly determine what line it is contained on and to easily
-  // iterate over structures on the line.
+  // For atomic inline elements, this function returns the inline box that
+  // contains us. Enables the atomic inline LayoutObject to quickly determine
+  // what line it is contained on and to easily iterate over structures on the
+  // line.
   InlineBox* inlineBoxWrapper() const { return m_inlineBoxWrapper; }
   void setInlineBoxWrapper(InlineBox*);
   void deleteLineBoxWrapper();
 
   void setSpannerPlaceholder(LayoutMultiColumnSpannerPlaceholder&);
   void clearSpannerPlaceholder();
   LayoutMultiColumnSpannerPlaceholder* spannerPlaceholder() const final {
     return m_rareData ? m_rareData->m_spannerPlaceholder : 0;
   }
 
-  // A pagination strut is the amount of space needed to push an in-flow block-level object (or
-  // float) to the logical top of the next page or column. It will be set both for forced breaks
-  // (e.g. page-break-before:always) and soft breaks (when there's not enough space in the current
-  // page / column for the object). The strut is baked into the logicalTop() of the object, so
-  // that logicalTop() - paginationStrut() == the original position in the previous column before
-  // deciding to break.
+  // A pagination strut is the amount of space needed to push an in-flow block-
+  // level object (or float) to the logical top of the next page or column. It
+  // will be set both for forced breaks (e.g. page-break-before:always) and soft
+  // breaks (when there's not enough space in the current page / column for the
+  // object). The strut is baked into the logicalTop() of the object, so that
+  // logicalTop() - paginationStrut() == the original position in the previous
+  // column before deciding to break.
   //
-  // Pagination struts are either set in front of a block-level box (here) or before a line
-  // (RootInlineBox::paginationStrut()).
+  // Pagination struts are either set in front of a block-level box (here) or
+  // before a line (RootInlineBox::paginationStrut()).
   LayoutUnit paginationStrut() const {
     return m_rareData ? m_rareData->m_paginationStrut : LayoutUnit();
   }
   void setPaginationStrut(LayoutUnit);
   void resetPaginationStrut() {
     if (m_rareData)
       m_rareData->m_paginationStrut = LayoutUnit();
   }
 
-  // Is the specified break-before or break-after value supported on this object? It needs to be
-  // in-flow all the way up to a fragmentation context that supports the specified value.
+  // Is the specified break-before or break-after value supported on this
+  // object? It needs to be in-flow all the way up to a fragmentation context
+  // that supports the specified value.
   bool isBreakBetweenControllable(EBreak) const;
 
-  // Is the specified break-inside value supported on this object? It needs to be contained by a
-  // fragmentation context that supports the specified value.
+  // Is the specified break-inside value supported on this object? It needs to
+  // be contained by a fragmentation context that supports the specified value.
   bool isBreakInsideControllable(EBreak) const;
 
   virtual EBreak breakAfter() const;
   virtual EBreak breakBefore() const;
   EBreak breakInside() const;
 
-  // Join two adjacent break values specified on break-before and/or break-after. avoid* values
-  // win over auto values, and forced break values win over avoid* values. |firstValue| is
-  // specified on an element earlier in the flow than |secondValue|. This method is used at class
-  // A break points [1], to join the values of the previous break-after and the next
-  // break-before, to figure out whether we may, must, or should not, break at that point. It is
-  // also used when propagating break-before values from first children and break-after values on
-  // last children to their container.
+  // Join two adjacent break values specified on break-before and/or break-
+  // after. avoid* values win over auto values, and forced break values win over
+  // avoid* values. |firstValue| is specified on an element earlier in the flow
+  // than |secondValue|. This method is used at class A break points [1], to
+  // join the values of the previous break-after and the next break-before, to
+  // figure out whether we may, must, or should not, break at that point. It is
+  // also used when propagating break-before values from first children and
+  // break-after values on last children to their container.
   //
   // [1] https://drafts.csswg.org/css-break/#possible-breaks
   static EBreak joinFragmentainerBreakValues(EBreak firstValue,
                                              EBreak secondValue);
 
   static bool isForcedFragmentainerBreakValue(EBreak);
 
   EBreak classABreakPointValue(EBreak previousBreakAfterValue) const;
 
-  // Return true if we should insert a break in front of this box. The box needs to start at a
-  // valid class A break point in order to allow a forced break. To determine whether or not to
-  // break, we also need to know the break-after value of the previous in-flow sibling.
+  // Return true if we should insert a break in front of this box. The box needs
+  // to start at a valid class A break point in order to allow a forced break.
+  // To determine whether or not to break, we also need to know the break-after
+  // value of the previous in-flow sibling.
   bool needsForcedBreakBefore(EBreak previousBreakAfterValue) const;
 
   bool paintedOutputOfObjectHasNoEffectRegardlessOfSize() const override;
   LayoutRect localOverflowRectForPaintInvalidation() const override;
   bool mapToVisualRectInAncestorSpace(
       const LayoutBoxModelObject* ancestor,
       LayoutRect&,
       VisualRectFlags = DefaultVisualRectFlags) const override;
 
   LayoutUnit containingBlockLogicalHeightForGetComputedStyle() const;
 
   LayoutUnit containingBlockLogicalWidthForContent() const override;
   LayoutUnit containingBlockLogicalHeightForContent(
       AvailableLogicalHeightType) const;
 
   LayoutUnit containingBlockAvailableLineWidth() const;
   LayoutUnit perpendicularContainingBlockLogicalHeight() const;
 
   virtual void updateLogicalWidth();
   void updateLogicalHeight();
   virtual void computeLogicalHeight(LayoutUnit logicalHeight,
                                     LayoutUnit logicalTop,
                                     LogicalExtentComputedValues&) const;
-  // This function will compute the logical border-box height, without laying out the box. This means that the result
-  // is only "correct" when the height is explicitly specified. This function exists so that intrinsic width calculations
-  // have a way to deal with children that have orthogonal flows.
-  // When there is no explicit height, this function assumes a content height of zero (and returns just border+padding)
+  // This function will compute the logical border-box height, without laying
+  // out the box. This means that the result is only "correct" when the height
+  // is explicitly specified. This function exists so that intrinsic width
+  // calculations have a way to deal with children that have orthogonal flows.
+  // When there is no explicit height, this function assumes a content height of
+  // zero (and returns just border+padding).
   LayoutUnit computeLogicalHeightWithoutLayout() const;
 
   void computeLogicalWidth(LogicalExtentComputedValues&) const;
 
   bool stretchesToViewport() const {
     return document().inQuirksMode() && stretchesToViewportInQuirksMode();
   }
 
   virtual LayoutSize intrinsicSize() const { return LayoutSize(); }
   LayoutUnit intrinsicLogicalWidth() const {
     return style()->isHorizontalWritingMode() ? intrinsicSize().width()
                                               : intrinsicSize().height();
   }
   LayoutUnit intrinsicLogicalHeight() const {
     return style()->isHorizontalWritingMode() ? intrinsicSize().height()
                                               : intrinsicSize().width();
   }
   virtual LayoutUnit intrinsicContentLogicalHeight() const {
     return m_intrinsicContentLogicalHeight;
   }
 
-  // Whether or not the element shrinks to its intrinsic width (rather than filling the width
-  // of a containing block).  HTML4 buttons, <select>s, <input>s, legends, and floating/compact elements do this.
+  // Whether or not the element shrinks to its intrinsic width (rather than
+  // filling the width of a containing block). HTML4 buttons, <select>s,
+  // <input>s, legends, and floating/compact elements do this.
   bool sizesLogicalWidthToFitContent(const Length& logicalWidth) const;
 
   LayoutUnit shrinkLogicalWidthToAvoidFloats(LayoutUnit childMarginStart,
                                              LayoutUnit childMarginEnd,
                                              const LayoutBlockFlow* cb) const;
 
   LayoutUnit computeLogicalWidthUsing(SizeType,
                                       const Length& logicalWidth,
                                       LayoutUnit availableLogicalWidth,
                                       const LayoutBlock* containingBlock) const;
@@ skipping 19 matching lines @@
       LayoutUnit logicalHeight) const;
 
   virtual LayoutUnit computeReplacedLogicalWidth(
       ShouldComputePreferred = ComputeActual) const;
   virtual LayoutUnit computeReplacedLogicalHeight(
       LayoutUnit estimatedUsedWidth = LayoutUnit()) const;
 
   bool percentageLogicalHeightIsResolvable() const;
   LayoutUnit computePercentageLogicalHeight(const Length& height) const;
 
-  // Block flows subclass availableWidth/Height to handle multi column layout (shrinking the width/height available to children when laying out.)
+  // Block flows subclass availableWidth/Height to handle multi column layout
+  // (shrinking the width/height available to children when laying out.)
   LayoutUnit availableLogicalWidth() const { return contentLogicalWidth(); }
   LayoutUnit availableLogicalHeight(AvailableLogicalHeightType) const;
   LayoutUnit availableLogicalHeightUsing(const Length&,
                                          AvailableLogicalHeightType) const;
 
-  // There are a few cases where we need to refer specifically to the available physical width and available physical height.
-  // Relative positioning is one of those cases, since left/top offsets are physical.
+  // There are a few cases where we need to refer specifically to the available
+  // physical width and available physical height. Relative positioning is one
+  // of those cases, since left/top offsets are physical.
   LayoutUnit availableWidth() const {
     return style()->isHorizontalWritingMode()
                ? availableLogicalWidth()
                : availableLogicalHeight(IncludeMarginBorderPadding);
   }
   LayoutUnit availableHeight() const {
     return style()->isHorizontalWritingMode()
                ? availableLogicalHeight(IncludeMarginBorderPadding)
                : availableLogicalWidth();
   }
@@ skipping 44 matching lines @@
   }
   virtual bool scrollsOverflowX() const {
     return hasOverflowClip() && (style()->overflowX() == OverflowScroll ||
                                  hasAutoHorizontalScrollbar());
   }
   virtual bool scrollsOverflowY() const {
     return hasOverflowClip() && (style()->overflowY() == OverflowScroll ||
                                  hasAutoVerticalScrollbar());
   }
 
-  // Elements such as the <input> field override this to specify that they are scrollable
-  // outside the context of the CSS overflow style
+  // Elements such as the <input> field override this to specify that they are
+  // scrollable outside the context of the CSS overflow style
   virtual bool isIntrinsicallyScrollable(
       ScrollbarOrientation orientation) const {
     return false;
   }
 
   bool hasUnsplittableScrollingOverflow() const;
 
   // Page / column breakability inside block-level objects.
   enum PaginationBreakability {
-    AllowAnyBreaks,  // No restrictions on breaking. May examine children to find possible break points.
-    ForbidBreaks,    // Forbid breaks inside this object. Content cannot be split nicely into smaller pieces.
-    AvoidBreaks      // Preferably avoid breaks. If not possible, examine children to find possible break points.
+    AllowAnyBreaks,  // No restrictions on breaking. May examine children to
+                     // find possible break points.
+    ForbidBreaks,  // Forbid breaks inside this object. Content cannot be split
+                   // nicely into smaller pieces.
+    AvoidBreaks    // Preferably avoid breaks. If not possible, examine children
+                   // to find possible break points.
   };
   PaginationBreakability getPaginationBreakability() const;
 
   LayoutRect localCaretRect(
       InlineBox*,
       int caretOffset,
       LayoutUnit* extraWidthToEndOfLine = nullptr) override;
 
   virtual LayoutRect overflowClipRect(
       const LayoutPoint& location,
       OverlayScrollbarClipBehavior = IgnoreOverlayScrollbarSize) const;
   LayoutRect clipRect(const LayoutPoint& location) const;
   virtual bool hasControlClip() const { return false; }
   virtual LayoutRect controlClipRect(const LayoutPoint&) const {
     return LayoutRect();
   }
 
-  // Returns the combination of overflow clip, contain: paint clip and CSS clip for this object, in local space.
+  // Returns the combination of overflow clip, contain: paint clip and CSS clip
+  // for this object, in local space.
   LayoutRect clippingRect() const;
 
   virtual void paintBoxDecorationBackground(const PaintInfo&,
                                             const LayoutPoint&) const;
   virtual void paintMask(const PaintInfo&, const LayoutPoint&) const;
   void imageChanged(WrappedImagePtr, const IntRect* = nullptr) override;
   ResourcePriority computeResourcePriority() const final;
 
   void logicalExtentAfterUpdatingLogicalWidth(const LayoutUnit& logicalTop,
                                               LogicalExtentComputedValues&);
 
   PositionWithAffinity positionForPoint(const LayoutPoint&) override;
 
   void removeFloatingOrPositionedChildFromBlockLists();
 
   PaintLayer* enclosingFloatPaintingLayer() const;
 
   virtual int firstLineBoxBaseline() const { return -1; }
   virtual int inlineBlockBaseline(LineDirectionMode) const {
     return -1;
-  }  // Returns -1 if we should skip this box when computing the baseline of an inline-block.
+  }  // Returns -1 if we should skip this box when computing the baseline of an
+     // inline-block.
 
   virtual Node* nodeForHitTest() const { return node(); }
 
   bool shrinkToAvoidFloats() const;
   virtual bool avoidsFloats() const;
 
   void markChildForPaginationRelayoutIfNeeded(LayoutBox& child,
                                               SubtreeLayoutScope&);
 
   bool isWritingModeRoot() const {
@@ skipping 31 matching lines @@
       bool firstLine,
       LineDirectionMode,
       LinePositionMode = PositionOnContainingLine) const override;
 
   LayoutUnit offsetLeft(const Element*) const override;
   LayoutUnit offsetTop(const Element*) const override;
 
   LayoutPoint flipForWritingModeForChild(const LayoutBox* child,
                                          const LayoutPoint&) const;
   LayoutUnit flipForWritingMode(LayoutUnit position) const WARN_UNUSED_RETURN {
-    // The offset is in the block direction (y for horizontal writing modes, x for vertical writing modes).
+    // The offset is in the block direction (y for horizontal writing modes, x
+    // for vertical writing modes).
     if (!UNLIKELY(hasFlippedBlocksWritingMode()))
       return position;
     return logicalHeight() - position;
   }
   LayoutPoint flipForWritingMode(const LayoutPoint& position) const
       WARN_UNUSED_RETURN {
     if (!UNLIKELY(hasFlippedBlocksWritingMode()))
       return position;
     return isHorizontalWritingMode()
                ? LayoutPoint(position.x(), m_frameRect.height() - position.y())
@@ skipping 46 matching lines @@
   bool hasVisualOverflow() const {
     return m_overflow && !borderBoxRect().contains(visualOverflowRect());
   }
 
   virtual bool needsPreferredWidthsRecalculation() const;
 
   // See README.md for an explanation of scroll origin.
   virtual IntSize originAdjustmentForScrollbars() const;
   IntSize scrolledContentOffset() const;
 
-  // Maps a rect in scrolling contents space to box space and apply overflow clip if needed.
-  // Returns true if no clipping applied or the rect actually intersects the clipping region.
-  // If edgeInclusive is true, then this method may return true even
-  // if the resulting rect has zero area.
+  // Maps a rect in scrolling contents space to box space and apply overflow
+  // clip if needed. Returns true if no clipping applied or the rect actually
+  // intersects the clipping region. If edgeInclusive is true, then this method
+  // may return true even if the resulting rect has zero area.
   bool mapScrollingContentsRectToBoxSpace(
       LayoutRect&,
       ApplyOverflowClipFlag,
       VisualRectFlags = DefaultVisualRectFlags) const;
 
   virtual bool hasRelativeLogicalWidth() const;
   virtual bool hasRelativeLogicalHeight() const;
 
   bool hasHorizontalLayoutOverflow() const {
     if (!m_overflow)
@@ skipping 84 matching lines @@
   void willBeRemovedFromTree() override;
 
   void styleWillChange(StyleDifference, const ComputedStyle& newStyle) override;
   void styleDidChange(StyleDifference, const ComputedStyle* oldStyle) override;
   void updateFromStyle() override;
 
   virtual ItemPosition selfAlignmentNormalBehavior() const {
     return ItemPositionStretch;
   }
 
-  // Returns false if it could not cheaply compute the extent (e.g. fixed background), in which case the returned rect may be incorrect.
-  // FIXME: make this a const method once the LayoutBox reference in BoxPainter is const.
+  // Returns false if it could not cheaply compute the extent (e.g. fixed
+  // background), in which case the returned rect may be incorrect.
+  // FIXME: make this a const method once the LayoutBox reference in BoxPainter
+  // is const.
   bool getBackgroundPaintedExtent(LayoutRect&) const;
   virtual bool foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect,
                                                  unsigned maxDepthToTest) const;
   bool computeBackgroundIsKnownToBeObscured() const override;
 
   virtual void computePositionedLogicalWidth(
       LogicalExtentComputedValues&) const;
 
   LayoutUnit computeIntrinsicLogicalWidthUsing(
       const Length& logicalWidthLength,
@@ skipping 112 matching lines @@
       const Length& logicalBottom,
       const Length& marginLogicalTop,
       const Length& marginLogicalBottom,
       LogicalExtentComputedValues&) const;
 
   LayoutUnit fillAvailableMeasure(LayoutUnit availableLogicalWidth) const;
   LayoutUnit fillAvailableMeasure(LayoutUnit availableLogicalWidth,
                                   LayoutUnit& marginStart,
                                   LayoutUnit& marginEnd) const;
 
-  // Calculates the intrinsic(https://drafts.csswg.org/css-sizing-3/#intrinsic) logical widths for this layout box.
+  // Calculates the intrinsic(https://drafts.csswg.org/css-sizing-3/#intrinsic)
+  // logical widths for this layout box.
   //
   // intrinsicWidth is defined as:
-  //     intrinsic size of content (without our border and padding) + scrollbarWidth.
+  //     intrinsic size of content (without our border and padding) +
+  //     scrollbarWidth.
   //
   // preferredWidth is defined as:
   //     fixedWidth OR (intrinsicWidth plus border and padding).
   //     Note: fixedWidth includes border and padding and scrollbarWidth.
   virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth,
                                              LayoutUnit& maxLogicalWidth) const;
 
   // This function calculates the preferred widths for an object.
   //
   // This function is only expected to be called if
@@ skipping 120 matching lines @@
 }
 
 inline LayoutBox* LayoutBox::nextSiblingMultiColumnBox() const {
   ASSERT(isLayoutMultiColumnSpannerPlaceholder() || isLayoutMultiColumnSet());
   return nextSiblingBox();
 }
 
 inline void LayoutBox::setInlineBoxWrapper(InlineBox* boxWrapper) {
   if (boxWrapper) {
     ASSERT(!m_inlineBoxWrapper);
-    // m_inlineBoxWrapper should already be nullptr. Deleting it is a safeguard against security issues.
-    // Otherwise, there will two line box wrappers keeping the reference to this layoutObject, and
-    // only one will be notified when the layoutObject is getting destroyed. The second line box wrapper
+    // m_inlineBoxWrapper should already be nullptr. Deleting it is a safeguard
+    // against security issues. Otherwise, there will two line box wrappers
+    // keeping the reference to this layoutObject, and only one will be notified
+    // when the layoutObject is getting destroyed. The second line box wrapper
     // will keep a stale reference.
     if (UNLIKELY(m_inlineBoxWrapper != nullptr))
       deleteLineBoxWrapper();
   }
 
   m_inlineBoxWrapper = boxWrapper;
 }
 
 inline bool LayoutBox::isForcedFragmentainerBreakValue(EBreak breakValue) {
   return breakValue == BreakColumn || breakValue == BreakLeft ||
          breakValue == BreakPage || breakValue == BreakRecto ||
          breakValue == BreakRight || breakValue == BreakVerso;
 }
 
 }  // namespace blink
 
 #endif  // LayoutBox_h