Reformat comments in core/layout up until LayoutBox

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003-2013 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ skipping 145 matching lines @@
     return static_cast<RootInlineBox*>(lastLineBox());
   }
 
   LayoutUnit logicalLeftSelectionOffset(const LayoutBlock* rootBlock,
                                         LayoutUnit position) const override;
   LayoutUnit logicalRightSelectionOffset(const LayoutBlock* rootBlock,
                                          LayoutUnit position) const override;
 
   RootInlineBox* createAndAppendRootInlineBox();
 
-  // Return the number of lines in *this* block flow. Does not recurse into block flow children.
-  // Will start counting from the first line, and stop counting right after |stopRootInlineBox|,
-  // if specified.
+  // Return the number of lines in *this* block flow. Does not recurse into
+  // block flow children.
+  // Will start counting from the first line, and stop counting right after
+  // |stopRootInlineBox|, if specified.
   int lineCount(const RootInlineBox* stopRootInlineBox = nullptr) const;
 
   int firstLineBoxBaseline() const override;
   int inlineBlockBaseline(LineDirectionMode) const override;
 
   void removeFloatingObjectsFromDescendants();
   void markAllDescendantsWithFloatsForLayout(LayoutBox* floatToRemove = nullptr,
                                              bool inLayout = true);
   void markSiblingsWithFloatsForLayout(LayoutBox* floatToRemove = nullptr);
 
@@ skipping 92 matching lines @@
   LayoutMultiColumnFlowThread* multiColumnFlowThread() const {
     return m_rareData ? m_rareData->m_multiColumnFlowThread : 0;
   }
   void resetMultiColumnFlowThread() {
     if (m_rareData)
       m_rareData->m_multiColumnFlowThread = nullptr;
   }
 
   void addOverflowFromInlineChildren();
 
-  // FIXME: This should be const to avoid a const_cast, but can modify child dirty bits and LayoutTextCombine
+  // FIXME: This should be const to avoid a const_cast, but can modify child
+  // dirty bits and LayoutTextCombine.
   void computeInlinePreferredLogicalWidths(LayoutUnit& minLogicalWidth,
                                            LayoutUnit& maxLogicalWidth);
 
   bool allowsPaginationStrut() const;
-  // Pagination strut caused by the first line or child block inside this block-level object.
+  // Pagination strut caused by the first line or child block inside this
+  // block-level object.
   //
-  // When the first piece of content (first child block or line) inside an object wants to insert
-  // a soft page or column break, rather than setting a pagination strut on itself it normally
-  // propagates the strut to its containing block (|this|), as long as our implementation can
-  // handle it. The idea is that we want to push the entire object to the next page or column
-  // along with the child content that caused the break, instead of leaving unusable space at the
-  // beginning of the object at the end of one column or page and just push the first line or
-  // block to the next column or page. That would waste space in the container for no good
-  // reason, and it would also be a spec violation, since there is no break opportunity defined
-  // between the content logical top of an object and its first child or line (only *between*
-  // blocks or lines).
+  // When the first piece of content (first child block or line) inside an
+  // object wants to insert a soft page or column break, rather than setting a
+  // pagination strut on itself it normally propagates the strut to its
+  // containing block (|this|), as long as our implementation can handle it.
+  // The idea is that we want to push the entire object to the next page or
+  // column along with the child content that caused the break, instead of
+  // leaving unusable space at the beginning of the object at the end of one
+  // column or page and just push the first line or block to the next column or
+  // page. That would waste space in the container for no good reason, and it
+  // would also be a spec violation, since there is no break opportunity defined
+  // between the content logical top of an object and its first child or line
+  // (only *between* blocks or lines).
   LayoutUnit paginationStrutPropagatedFromChild() const {
     return m_rareData ? m_rareData->m_paginationStrutPropagatedFromChild
                       : LayoutUnit();
   }
   void setPaginationStrutPropagatedFromChild(LayoutUnit);
 
   void positionSpannerDescendant(LayoutMultiColumnSpannerPlaceholder& child);
 
   bool avoidsFloats() const override;
 
@@ skipping 148 matching lines @@
                            LayoutUnit afterEdge);
 
   void markDescendantsWithFloatsForLayoutIfNeeded(
       LayoutBlockFlow& child,
       LayoutUnit newLogicalTop,
       LayoutUnit previousFloatLogicalBottom);
   bool positionAndLayoutOnceIfNeeded(LayoutBox& child,
                                      LayoutUnit newLogicalTop,
                                      BlockChildrenLayoutInfo&);
 
-  // Handle breaking policy before the child, and insert a forced break in front of it if needed.
+  // Handle breaking policy before the child, and insert a forced break in front
+  // of it if needed.
   void insertForcedBreakBeforeChildIfNeeded(LayoutBox& child,
                                             BlockChildrenLayoutInfo&);
 
   void layoutBlockChild(LayoutBox& child, BlockChildrenLayoutInfo&);
   void adjustPositionedBlock(LayoutBox& child, const BlockChildrenLayoutInfo&);
   void adjustFloatingBlock(const MarginInfo&);
 
   LayoutPoint computeLogicalLocationForFloat(const FloatingObject&,
                                              LayoutUnit logicalTopOffset) const;
 
@@ skipping 51 matching lines @@
   bool isPagedOverflow(const ComputedStyle&);
 
   enum FlowThreadType { NoFlowThread, MultiColumnFlowThread, PagedFlowThread };
 
   FlowThreadType getFlowThreadType(const ComputedStyle&);
 
   LayoutMultiColumnFlowThread* createMultiColumnFlowThread(FlowThreadType);
   void createOrDestroyMultiColumnFlowThreadIfNeeded(
       const ComputedStyle* oldStyle);
 
-  // Merge children of |siblingThatMayBeDeleted| into this object if possible, and delete
-  // |siblingThatMayBeDeleted|. Returns true if we were able to merge. In that case,
-  // |siblingThatMayBeDeleted| will be dead. We'll only be able to merge if both blocks are
-  // anonymous.
+  // Merge children of |siblingThatMayBeDeleted| into this object if possible,
+  // and delete |siblingThatMayBeDeleted|. Returns true if we were able to
+  // merge. In that case, |siblingThatMayBeDeleted| will be dead. We'll only be
+  // able to merge if both blocks are anonymous.
   bool mergeSiblingContiguousAnonymousBlock(
       LayoutBlockFlow* siblingThatMayBeDeleted);
 
-  // Reparent subsequent or preceding adjacent floating or out-of-flow siblings into this object.
+  // Reparent subsequent or preceding adjacent floating or out-of-flow siblings
+  // into this object.
   void reparentSubsequentFloatingOrOutOfFlowSiblings();
   void reparentPrecedingFloatingOrOutOfFlowSiblings();
 
   void makeChildrenInlineIfPossible();
 
   void makeChildrenNonInline(LayoutObject* insertionPoint = nullptr);
   void childBecameNonInline(LayoutObject* child) final;
 
   void updateLogicalWidthForAlignment(const ETextAlign&,
                                       const RootInlineBox*,
@@ skipping 185 matching lines @@
   virtual ETextAlign textAlignmentForLine(bool endsWithSoftBreak) const;
 
  private:
   LayoutUnit collapsedMarginBefore() const final {
     return maxPositiveMarginBefore() - maxNegativeMarginBefore();
   }
   LayoutUnit collapsedMarginAfter() const final {
     return maxPositiveMarginAfter() - maxNegativeMarginAfter();
   }
 
-  // Floats' margins do not collapse with page or column boundaries, and we therefore need to
-  // treat them specially in some cases.
+  // Floats' margins do not collapse with page or column boundaries, and we
+  // therefore need to treat them specially in some cases.
   LayoutUnit marginBeforeIfFloating() const {
     return isFloating() ? marginBefore() : LayoutUnit();
   }
 
   LayoutUnit collapseMargins(LayoutBox& child,
                              MarginInfo&,
                              bool childIsSelfCollapsing,
                              bool childDiscardMarginBefore,
                              bool childDiscardMarginAfter);
   LayoutUnit clearFloatsIfNeeded(LayoutBox& child,
                                  MarginInfo&,
                                  LayoutUnit oldTopPosMargin,
                                  LayoutUnit oldTopNegMargin,
                                  LayoutUnit yPos,
                                  bool childIsSelfCollapsing,
                                  bool childDiscardMargin);
   LayoutUnit estimateLogicalTopPosition(LayoutBox& child,
                                         const BlockChildrenLayoutInfo&,
                                         LayoutUnit& estimateWithoutPagination);
   void marginBeforeEstimateForChild(LayoutBox&,
                                     LayoutUnit&,
                                     LayoutUnit&,
                                     bool&) const;
   void handleAfterSideOfBlock(LayoutBox* lastChild,
                               LayoutUnit top,
                               LayoutUnit bottom,
                               MarginInfo&);
   void setCollapsedBottomMargin(const MarginInfo&);
 
-  // Apply any forced fragmentainer break that's set on the current class A break point.
+  // Apply any forced fragmentainer break that's set on the current class A
+  // break point.
   LayoutUnit applyForcedBreak(LayoutUnit logicalOffset, EBreak);
 
   void setBreakBefore(EBreak);
   void setBreakAfter(EBreak);
   EBreak breakBefore() const override;
   EBreak breakAfter() const override;
 
   LayoutUnit adjustBlockChildForPagination(LayoutUnit logicalTop,
                                            LayoutBox& child,
                                            BlockChildrenLayoutInfo&,
                                            bool atBeforeSideOfBlock);
-  // Computes a deltaOffset value that put a line at the top of the next page if it doesn't fit on the current page.
+  // Computes a deltaOffset value that put a line at the top of the next page if
+  // it doesn't fit on the current page.
   void adjustLinePositionForPagination(RootInlineBox&, LayoutUnit& deltaOffset);
-  // If the child is unsplittable and can't fit on the current page, return the top of the next page/column.
+  // If the child is unsplittable and can't fit on the current page, return the
+  // top of the next page/column.
   LayoutUnit adjustForUnsplittableChild(LayoutBox&,
                                         LayoutUnit logicalOffset) const;
 
   // Used to store state between styleWillChange and styleDidChange
   static bool s_canPropagateFloatIntoSibling;
 
-  LineBoxList
-      m_lineBoxes;  // All of the root line boxes created for this block flow.  For example, <div>Hello<br>world.</div> will have two total lines for the <div>.
+  LineBoxList m_lineBoxes;  // All of the root line boxes created for this block
+                            // flow.  For example, <div>Hello<br>world.</div>
+                            // will have two total lines for the <div>.
 
   LayoutBlockFlowRareData& ensureRareData();
 
   bool isSelfCollapsingBlock() const override;
   bool checkIfIsSelfCollapsingBlock() const;
 
  protected:
   std::unique_ptr<LayoutBlockFlowRareData> m_rareData;
   std::unique_ptr<FloatingObjects> m_floatingObjects;
 
   friend class MarginInfo;
   friend class LineWidth;  // needs to know FloatingObject
 
-  // LayoutRubyBase objects need to be able to split and merge, moving their children around
-  // (calling makeChildrenNonInline).
+  // LayoutRubyBase objects need to be able to split and merge, moving their
+  // children around (calling makeChildrenNonInline).
   // TODO(mstensho): Try to get rid of this friendship.
   friend class LayoutRubyBase;
 
   // FIXME-BLOCKFLOW: These methods have implementations in
   // LayoutBlockFlowLine. They should be moved to the proper header once the
   // line layout code is separated from LayoutBlock and LayoutBlockFlow.
   // START METHODS DEFINED IN LayoutBlockFlowLine
  private:
   InlineFlowBox* createLineBoxes(LineLayoutItem,
                                  const LineInfo&,
@@ skipping 61 matching lines @@
   bool checkPaginationAndFloatsAtEndLine(LineLayoutState&);
   bool matchedEndLine(LineLayoutState&,
                       const InlineBidiResolver&,
                       const InlineIterator& endLineStart,
                       const BidiStatus& endLineStatus);
   void deleteEllipsisLineBoxes();
   void checkLinesForTextOverflow();
   void markLinesDirtyInBlockRange(LayoutUnit logicalTop,
                                   LayoutUnit logicalBottom,
                                   RootInlineBox* highest = nullptr);
-  // Positions new floats and also adjust all floats encountered on the line if any of them
-  // have to move to the next page/column.
+  // Positions new floats and also adjust all floats encountered on the line if
+  // any of them have to move to the next page/column.
   void positionDialog();
 
   // END METHODS DEFINED IN LayoutBlockFlowLine
 };
 
 DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutBlockFlow, isLayoutBlockFlow());
 
 }  // namespace blink
 
 #endif  // LayoutBlockFlow_h