Reformat comments in core/layout up until LayoutMultiColumnFlowThread

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2006, 2007, 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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 127 matching lines @@
   // This is the only way layers should ever be destroyed.
   void destroyLayer();
 
   LayoutSize relativePositionOffset() const;
   LayoutSize relativePositionLogicalOffset() const {
     return style()->isHorizontalWritingMode()
                ? relativePositionOffset()
                : relativePositionOffset().transposedSize();
   }
 
-  // Populates StickyPositionConstraints, setting the sticky box rect, containing block rect and updating
-  // the constraint offsets according to the available space.
+  // Populates StickyPositionConstraints, setting the sticky box rect,
+  // containing block rect and updating the constraint offsets according to the
+  // available space.
   FloatRect computeStickyConstrainingRect() const;
   void updateStickyPositionConstraints() const;
   LayoutSize stickyPositionOffset() const;
 
   LayoutSize offsetForInFlowPosition() const;
 
-  // 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
+  // (LayoutInline) to return the remaining width on a given line (and the height
+  // of a single line).
   virtual LayoutUnit offsetLeft(const Element*) const;
   virtual LayoutUnit offsetTop(const Element*) const;
   virtual LayoutUnit offsetWidth() const = 0;
   virtual LayoutUnit offsetHeight() const = 0;
 
   int pixelSnappedOffsetLeft(const Element* parent) const {
     return roundToInt(offsetLeft(parent));
   }
   int pixelSnappedOffsetTop(const Element* parent) const {
     return roundToInt(offsetTop(parent));
   }
   virtual int pixelSnappedOffsetWidth(const Element*) const;
   virtual int pixelSnappedOffsetHeight(const Element*) const;
 
   bool hasSelfPaintingLayer() const;
   PaintLayer* layer() const { return m_layer.get(); }
   PaintLayerScrollableArea* getScrollableArea() const;
 
   virtual void updateFromStyle();
 
-  // The type of PaintLayer to instantiate.
-  // Any value returned from this function other than NoPaintLayer
-  // will populate |m_layer|.
+  // The type of PaintLayer to instantiate. Any value returned from this
+  // function other than NoPaintLayer will populate |m_layer|.
   virtual PaintLayerType layerTypeRequired() const = 0;
 
-  // This will work on inlines to return the bounding box of all of the lines' border boxes.
+  // This will work on inlines to return the bounding box of all of the lines'
+  // border boxes.
   virtual IntRect borderBoundingBox() const = 0;
 
   virtual LayoutRect visualOverflowRect() const = 0;
 
-  // Checks if this box, or any of it's descendants, or any of it's continuations,
-  // will take up space in the layout of the page.
+  // Checks if this box, or any of it's descendants, or any of it's
+  // continuations, will take up space in the layout of the page.
   bool hasNonEmptyLayoutSize() const;
   bool usesCompositedScrolling() const;
 
   // Checks if all of the background's layers can be painted as locally
   // attached.
   bool hasLocalEquivalentBackground() const;
 
   // These return the CSS computed padding values.
   LayoutUnit computedCSSPaddingTop() const {
     return computedCSSPadding(style()->paddingTop());
@@ skipping 21 matching lines @@
   }
   LayoutUnit computedCSSPaddingOver() const {
     return computedCSSPadding(style()->paddingOver());
   }
   LayoutUnit computedCSSPaddingUnder() const {
     return computedCSSPadding(style()->paddingUnder());
   }
 
   // These functions are used during layout.
   // - Table cells override them to include the intrinsic padding (see
-  // explanations in LayoutTableCell).
+  //   explanations in LayoutTableCell).
   // - Table override them to exclude padding with collapsing borders.
   virtual LayoutUnit paddingTop() const { return computedCSSPaddingTop(); }
   virtual LayoutUnit paddingBottom() const {
     return computedCSSPaddingBottom();
   }
   virtual LayoutUnit paddingLeft() const { return computedCSSPaddingLeft(); }
   virtual LayoutUnit paddingRight() const { return computedCSSPaddingRight(); }
   virtual LayoutUnit paddingBefore() const {
     return computedCSSPaddingBefore();
   }
@@ skipping 145 matching lines @@
 
   // Returns true if the background is painted opaque in the given rect.
   // The query rect is given in local coordinate system.
   virtual bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const {
     return false;
   }
 
   void invalidateTreeIfNeeded(const PaintInvalidationState&) override;
 
   // http://www.w3.org/TR/css3-background/#body-background
-  // <html> root element with no background steals background from its first <body> child.
-  // The used background for such body element should be the initial value. (i.e. transparent)
+  // <html> root element with no background steals background from its first
+  // <body> child. The used background for such body element should be the
+  // initial value. (i.e. transparent)
   bool backgroundStolenForBeingBody(
       const ComputedStyle* rootElementStyle = nullptr) const;
 
  protected:
   void willBeDestroyed() override;
 
   LayoutPoint adjustedPositionRelativeTo(const LayoutPoint&,
                                          const Element*) const;
 
   // Returns the continuation associated with |this|.
@@ skipping 34 matching lines @@
                             const PaintLayer*,
                             const LayoutPoint&,
                             const LayoutRect&) const override;
 
   void styleWillChange(StyleDifference, const ComputedStyle& newStyle) override;
   void styleDidChange(StyleDifference, const ComputedStyle* oldStyle) override;
 
   void invalidateStickyConstraints();
 
  public:
-  // These functions are only used internally to manipulate the layout tree structure via remove/insert/appendChildNode.
-  // Since they are typically called only to move objects around within anonymous blocks (which only have layers in
-  // the case of column spans), the default for fullRemoveInsert is false rather than true.
+  // These functions are only used internally to manipulate the layout tree
+  // structure via remove/insert/appendChildNode.
+  // Since they are typically called only to move objects around within
+  // anonymous blocks (which only have layers in the case of column spans), the
+  // default for fullRemoveInsert is false rather than true.
   void moveChildTo(LayoutBoxModelObject* toBoxModelObject,
                    LayoutObject* child,
                    LayoutObject* beforeChild,
                    bool fullRemoveInsert = false);
   void moveChildTo(LayoutBoxModelObject* toBoxModelObject,
                    LayoutObject* child,
                    bool fullRemoveInsert = false) {
     moveChildTo(toBoxModelObject, child, 0, fullRemoveInsert);
   }
   void moveAllChildrenTo(LayoutBoxModelObject* toBoxModelObject,
                          bool fullRemoveInsert = false) {
     moveAllChildrenTo(toBoxModelObject, 0, fullRemoveInsert);
   }
   void moveAllChildrenTo(LayoutBoxModelObject* toBoxModelObject,
                          LayoutObject* beforeChild,
                          bool fullRemoveInsert = false) {
     moveChildrenTo(toBoxModelObject, slowFirstChild(), 0, beforeChild,
                    fullRemoveInsert);
   }
-  // Move all of the kids from |startChild| up to but excluding |endChild|. 0 can be passed as the |endChild| to denote
-  // that all the kids from |startChild| onwards should be moved.
+  // Move all of the kids from |startChild| up to but excluding |endChild|. 0
+  // can be passed as the |endChild| to denote that all the kids from
+  // |startChild| onwards should be moved.
   void moveChildrenTo(LayoutBoxModelObject* toBoxModelObject,
                       LayoutObject* startChild,
                       LayoutObject* endChild,
                       bool fullRemoveInsert = false) {
     moveChildrenTo(toBoxModelObject, startChild, endChild, 0, fullRemoveInsert);
   }
   virtual void moveChildrenTo(LayoutBoxModelObject* toBoxModelObject,
                               LayoutObject* startChild,
                               LayoutObject* endChild,
                               LayoutObject* beforeChild,
                               bool fullRemoveInsert = false);
 
  private:
   void createLayer();
 
   LayoutUnit computedCSSPadding(const Length&) const;
   bool isBoxModelObject() const final { return true; }
 
   LayoutBoxModelObjectRareData& ensureRareData() {
     if (!m_rareData)
       m_rareData = wrapUnique(new LayoutBoxModelObjectRareData());
     return *m_rareData.get();
   }
 
   bool hasAutoHeightOrContainingBlockWithAutoHeight(
       bool checkingContainingBlock) const;
 
-  // The PaintLayer associated with this object.
-  // |m_layer| can be nullptr depending on the return value of layerTypeRequired().
+  // The PaintLayer associated with this object. |m_layer| can be nullptr
+  // depending on the return value of layerTypeRequired().
   std::unique_ptr<PaintLayer> m_layer;
 
   std::unique_ptr<LayoutBoxModelObjectRareData> m_rareData;
 };
 
 DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutBoxModelObject, isBoxModelObject());
 
 }  // namespace blink
 
 #endif  // LayoutBoxModelObject_h