Re-land Reformat comments in core/layout up until LayoutBox

third_party/WebKit/Source/core/layout/LayoutBlock.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, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
@@ skipping 65 matching lines @@
 // certain tree walks (e.g. layout()). The rule is that anything that
 // cares about containing blocks should skip the out-of-flow elements
 // in the normal tree walk and do an optional follow-up pass for them
 // using LayoutBlock::positionedObjects().
 // Not doing so will result in passing the wrong containing
 // block as tree walks will always pass the parent as the
 // containing block.
 //
 // Sample code of how to handle positioned objects in LayoutBlock:
 //
-// for (LayoutObject* child = firstChild(); child; child = child->nextSibling()) {
+// for (LayoutObject* child = firstChild(); child; child = child->nextSibling())
+// {
 //     if (child->isOutOfFlowPositioned())
 //         continue;
 //
 //     // Handle normal flow children.
 //     ...
 // }
 // for (LayoutBox* positionedObject : positionedObjects()) {
 //     // Handle out-of-flow positioned objects.
 //     ...
 // }
@@ skipping 31 matching lines @@
       LinePositionMode = PositionOnContainingLine) const override;
 
   LayoutUnit minLineHeightForReplacedObject(bool isFirstLine,
                                             LayoutUnit replacedHeight) const;
 
   bool createsNewFormattingContext() const;
 
   const char* name() const override;
 
  protected:
-  // Insert a child correctly into the tree when |beforeDescendant| isn't a direct child of
-  // |this|. This happens e.g. when there's an anonymous block child of |this| and
-  // |beforeDescendant| has been reparented into that one. Such things are invisible to the DOM,
-  // and addChild() is typically called with the DOM tree (and not the layout tree) in mind.
+  // Insert a child correctly into the tree when |beforeDescendant| isn't a
+  // direct child of |this|. This happens e.g. when there's an anonymous block
+  // child of |this| and |beforeDescendant| has been reparented into that one.
+  // Such things are invisible to the DOM, and addChild() is typically called
+  // with the DOM tree (and not the layout tree) in mind.
   void addChildBeforeDescendant(LayoutObject* newChild,
                                 LayoutObject* beforeDescendant);
 
  public:
   void addChild(LayoutObject* newChild,
                 LayoutObject* beforeChild = nullptr) override;
 
   virtual void layoutBlock(bool relayoutChildren);
 
   void insertPositionedObject(LayoutBox*);
@@ skipping 64 matching lines @@
       EDisplay = EDisplay::Block);
   LayoutBlock* createAnonymousBlock(EDisplay display = EDisplay::Block) const {
     return createAnonymousWithParentAndDisplay(this, display);
   }
 
   LayoutBox* createAnonymousBoxWithSameTypeAs(
       const LayoutObject* parent) const override;
 
   int columnGap() const;
 
-  // Accessors for logical width/height and margins in the containing block's block-flow direction.
+  // Accessors for logical width/height and margins in the containing block's
+  // block-flow direction.
   LayoutUnit logicalWidthForChild(const LayoutBox& child) const {
     return logicalWidthForChildSize(child.size());
   }
   LayoutUnit logicalWidthForChildSize(LayoutSize childSize) const {
     return isHorizontalWritingMode() ? childSize.width() : childSize.height();
   }
   LayoutUnit logicalHeightForChild(const LayoutBox& child) const {
     return isHorizontalWritingMode() ? child.size().height()
                                      : child.size().width();
   }
@@ skipping 85 matching lines @@
   //   #enclosingFirstLineStyleBlock::first-line { ... }
   // </style>
   // <div id="enclosingFirstLineStyleBlock">
   //   <div>
   //     <div id="nearestInnerBlockWithFirstLine">
   //       [<span>]first line text[</span>]
   //     </div>
   //   </div>
   // </div>
 
-  // Returns the nearest enclosing block (including this block) that contributes a first-line style to our first line.
+  // Returns the nearest enclosing block (including this block) that contributes
+  // a first-line style to our first line.
   const LayoutBlock* enclosingFirstLineStyleBlock() const;
-  // Returns this block or the nearest inner block containing the actual first line.
+  // Returns this block or the nearest inner block containing the actual first
+  // line.
   LayoutBlockFlow* nearestInnerBlockWithFirstLine();
 
  protected:
   void willBeDestroyed() override;
 
   void dirtyForLayoutFromPercentageHeightDescendants(SubtreeLayoutScope&);
 
   void layout() override;
 
   enum PositionedLayoutBehavior {
@@ skipping 51 matching lines @@
                        const LayoutPoint& accumulatedOffset,
                        HitTestAction) override;
   void updateHitTestResult(HitTestResult&, const LayoutPoint&) override;
 
   void updateAfterLayout();
 
   void styleWillChange(StyleDifference, const ComputedStyle& newStyle) override;
   void styleDidChange(StyleDifference, const ComputedStyle* oldStyle) override;
   void updateFromStyle() override;
 
-  // Returns true if non-visible overflow should be respected. Otherwise hasOverflowClip() will be
-  // false and we won't create scrollable area for this object even if overflow is non-visible.
+  // Returns true if non-visible overflow should be respected. Otherwise
+  // hasOverflowClip() will be false and we won't create scrollable area for
+  // this object even if overflow is non-visible.
   virtual bool allowsOverflowClip() const;
 
   virtual bool hasLineIfEmpty() const;
 
   bool simplifiedLayout();
   virtual void simplifiedNormalFlowLayout();
 
  public:
   virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool = false);
 
  protected:
   virtual void addOverflowFromChildren();
   void addOverflowFromPositionedObjects();
   void addOverflowFromBlockChildren();
   void addVisualOverflowFromTheme();
 
   void addOutlineRects(Vector<LayoutRect>&,
                        const LayoutPoint& additionalOffset,
                        IncludeBlockVisualOverflowOrNot) const override;
 
   void updateBlockChildDirtyBitsBeforeLayout(bool relayoutChildren, LayoutBox&);
 
-  // TODO(jchaffraix): We should rename this function as inline-flex and inline-grid as also covered.
-  // Alternatively it should be removed as we clarify the meaning of isAtomicInlineLevel to imply
-  // isInline.
+  // TODO(jchaffraix): We should rename this function as inline-flex and
+  // inline-grid as also covered.
+  // Alternatively it should be removed as we clarify the meaning of
+  // isAtomicInlineLevel to imply isInline.
   bool isInlineBlockOrInlineTable() const final {
     return isInline() && isAtomicInlineLevel();
   }
 
  private:
   LayoutObjectChildList* virtualChildren() final { return children(); }
   const LayoutObjectChildList* virtualChildren() const final {
     return children();
   }
 
@@ skipping 49 matching lines @@
 
  protected:
   bool isPageLogicalHeightKnown(LayoutUnit logicalOffset) const {
     return pageLogicalHeightForOffset(logicalOffset);
   }
 
   // Returns the logical offset at the top of the next page, for a given offset.
   LayoutUnit nextPageLogicalTop(LayoutUnit logicalOffset) const;
 
   // Paginated content inside this block was laid out.
-  // |logicalBottomOffsetAfterPagination| is the logical bottom offset of the child content after
-  // applying any forced or unforced breaks as needed.
+  // |logicalBottomOffsetAfterPagination| is the logical bottom offset of the
+  // child content after applying any forced or unforced breaks as needed.
   void paginatedContentWasLaidOut(
       LayoutUnit logicalBottomOffsetAfterPagination);
 
   // Adjust from painting offsets to the local coords of this layoutObject
   void offsetForContents(LayoutPoint&) const;
 
   PositionWithAffinity positionForPointRespectingEditingBoundaries(
       LineLayoutBox child,
       const LayoutPoint& pointInParentCoordinates);
   PositionWithAffinity positionForPointIfOutsideAtomicInlineLevel(
       const LayoutPoint&);
 
   virtual bool updateLogicalWidthAndColumnWidth();
 
   LayoutObjectChildList m_children;
 
-  unsigned
-      m_hasMarginBeforeQuirk : 1;  // Note these quirk values can't be put in LayoutBlockRareData since they are set too frequently.
+  unsigned m_hasMarginBeforeQuirk : 1;  // Note these quirk values can't be put
+                                        // in LayoutBlockRareData since they are
+                                        // set too frequently.
   unsigned m_hasMarginAfterQuirk : 1;
   unsigned m_beingDestroyed : 1;
   unsigned m_hasMarkupTruncation : 1;
   unsigned m_widthAvailableToChildrenChanged : 1;
   unsigned m_heightAvailableToChildrenChanged : 1;
-  unsigned
-      m_isSelfCollapsing : 1;  // True if margin-before and margin-after are adjoining.
+  unsigned m_isSelfCollapsing : 1;  // True if margin-before and margin-after
+                                    // are adjoining.
   unsigned m_descendantsWithFloatsMarkedForLayout : 1;
 
   unsigned m_hasPositionedObjects : 1;
   unsigned m_hasPercentHeightDescendants : 1;
 
   // FIXME: This is temporary as we move code that accesses block flow
   // member variables out of LayoutBlock and into LayoutBlockFlow.
   friend class LayoutBlockFlow;
 
   // This is necessary for now for interoperability between the old and new
   // layout code. Primarily for calling layoutPositionedObjects at the moment.
   friend class NGBox;
 
  public:
-  // TODO(lunalu): Temporary in order to ensure compatibility with existing layout test
-  // results.
+  // TODO(lunalu): Temporary in order to ensure compatibility with existing
+  // layout test results.
   virtual void adjustChildDebugRect(LayoutRect&) const {}
 };
 
 DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutBlock, isLayoutBlock());
 
 }  // namespace blink
 
 #endif  // LayoutBlock_h