Reformat comments in core/layout/line

third_party/WebKit/Source/core/layout/line/InlineBox.h

 /*
- * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011 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 71 matching lines @@
   virtual ~InlineBox();
 
   virtual void destroy();
 
   virtual void deleteLine();
   virtual void extractLine();
   virtual void attachLine();
 
   virtual bool isLineBreak() const { return false; }
 
-  // These methods are called when the caller wants to move the position of InlineBox without full layout of it.
-  // The implementation should update the position of the whole subtree (e.g. position of descendants and overflow etc.
-  // should also be moved accordingly).
+  // These methods are called when the caller wants to move the position of
+  // InlineBox without full layout of it. The implementation should update the
+  // position of the whole subtree (e.g. position of descendants and overflow
+  // etc. should also be moved accordingly).
   virtual void move(const LayoutSize& delta);
   DISABLE_CFI_PERF void moveInLogicalDirection(
       const LayoutSize& deltaInLogicalDirection) {
     move(isHorizontal() ? deltaInLogicalDirection
                         : deltaInLogicalDirection.transposedSize());
   }
   void moveInInlineDirection(LayoutUnit delta) {
     moveInLogicalDirection(LayoutSize(delta, LayoutUnit()));
   }
   void moveInBlockDirection(LayoutUnit delta) {
@@ skipping 90 matching lines @@
     m_prev = prev;
   }
   bool nextOnLineExists() const;
 
   virtual bool isLeaf() const { return true; }
 
   InlineBox* nextLeafChild() const;
   InlineBox* prevLeafChild() const;
 
   // Helper functions for editing and hit-testing code.
-  // FIXME: These two functions should be moved to RenderedPosition once the code to convert between
-  // Position and inline box, offset pair is moved to RenderedPosition.
+  // FIXME: These two functions should be moved to RenderedPosition once the
+  // code to convert between Position and inline box, offset pair is moved to
+  // RenderedPosition.
   InlineBox* nextLeafChildIgnoringLineBreak() const;
   InlineBox* prevLeafChildIgnoringLineBreak() const;
 
   LineLayoutItem getLineLayoutItem() const { return m_lineLayoutItem; }
 
   InlineFlowBox* parent() const {
     ASSERT(!m_hasBadParent);
     return m_parent;
   }
   void setParent(InlineFlowBox* par) { m_parent = par; }
 
   const RootInlineBox& root() const;
   RootInlineBox& root();
 
-  // x() is the left side of the box in the containing block's coordinate system.
+  // x() is the left side of the box in the containing block's coordinate
+  // system.
   void setX(LayoutUnit x) { m_topLeft.setX(x); }
   LayoutUnit x() const { return m_topLeft.x(); }
   LayoutUnit left() const { return m_topLeft.x(); }
 
   // y() is the top side of the box in the containing block's coordinate system.
   void setY(LayoutUnit y) { m_topLeft.setY(y); }
   LayoutUnit y() const { return m_topLeft.y(); }
   LayoutUnit top() const { return m_topLeft.y(); }
 
   const LayoutPoint& topLeft() const { return m_topLeft; }
 
   LayoutUnit width() const {
     return isHorizontal() ? logicalWidth() : logicalHeight();
   }
   LayoutUnit height() const {
     return isHorizontal() ? logicalHeight() : logicalWidth();
   }
   LayoutSize size() const { return LayoutSize(width(), height()); }
   LayoutUnit right() const { return left() + width(); }
   LayoutUnit bottom() const { return top() + height(); }
 
-  // The logicalLeft position is the left edge of the line box in a horizontal line and the top edge in a vertical line.
+  // The logicalLeft position is the left edge of the line box in a horizontal
+  // line and the top edge in a vertical line.
   LayoutUnit logicalLeft() const {
     return isHorizontal() ? m_topLeft.x() : m_topLeft.y();
   }
   LayoutUnit logicalRight() const { return logicalLeft() + logicalWidth(); }
   void setLogicalLeft(LayoutUnit left) {
     if (isHorizontal())
       setX(left);
     else
       setY(left);
   }
   int pixelSnappedLogicalLeft() const { return logicalLeft().toInt(); }
   int pixelSnappedLogicalRight() const { return logicalRight().ceil(); }
   int pixelSnappedLogicalTop() const { return logicalTop().toInt(); }
   int pixelSnappedLogicalBottom() const { return logicalBottom().ceil(); }
 
-  // The logicalTop[ position is the top edge of the line box in a horizontal line and the left edge in a vertical line.
+  // The logicalTop[ position is the top edge of the line box in a horizontal
+  // line and the left edge in a vertical line.
   LayoutUnit logicalTop() const {
     return isHorizontal() ? m_topLeft.y() : m_topLeft.x();
   }
   LayoutUnit logicalBottom() const { return logicalTop() + logicalHeight(); }
   void setLogicalTop(LayoutUnit top) {
     if (isHorizontal())
       setY(top);
     else
       setX(top);
   }
 
-  // The logical width is our extent in the line's overall inline direction, i.e., width for horizontal text and height for vertical text.
+  // The logical width is our extent in the line's overall inline direction,
+  // i.e., width for horizontal text and height for vertical text.
   void setLogicalWidth(LayoutUnit w) { m_logicalWidth = w; }
   LayoutUnit logicalWidth() const { return m_logicalWidth; }
 
-  // The logical height is our extent in the block flow direction, i.e., height for horizontal text and width for vertical text.
+  // The logical height is our extent in the block flow direction, i.e., height
+  // for horizontal text and width for vertical text.
   LayoutUnit logicalHeight() const;
 
   LayoutRect logicalFrameRect() const {
     return isHorizontal() ? LayoutRect(m_topLeft.x(), m_topLeft.y(),
                                        m_logicalWidth, logicalHeight())
                           : LayoutRect(m_topLeft.y(), m_topLeft.x(),
                                        m_logicalWidth, logicalHeight());
   }
 
   virtual int baselinePosition(FontBaseline baselineType) const;
@@ skipping 59 matching lines @@
 
   // Use with caution! The type is not checked!
   LineLayoutBoxModel boxModelObject() const {
     if (!getLineLayoutItem().isText())
       return LineLayoutBoxModel(m_lineLayoutItem);
     return LineLayoutBoxModel(nullptr);
   }
 
   LayoutPoint locationIncludingFlipping() const;
 
-  // Converts from a rect in the logical space of the InlineBox to one in the physical space
-  // of the containing block. The logical space of an InlineBox may be transposed for vertical text and
-  // flipped for right-to-left text.
+  // Converts from a rect in the logical space of the InlineBox to one in the
+  // physical space of the containing block. The logical space of an InlineBox
+  // may be transposed for vertical text and flipped for right-to-left text.
   void logicalRectToPhysicalRect(LayoutRect&) const;
 
-  // TODO(szager): The Rect versions should return a rect, not modify the argument.
+  // TODO(szager): The Rect versions should return a rect, not modify the
+  // argument.
   void flipForWritingMode(FloatRect&) const;
   FloatPoint flipForWritingMode(const FloatPoint&) const;
   void flipForWritingMode(LayoutRect&) const;
   LayoutPoint flipForWritingMode(const LayoutPoint&) const;
 
   bool knownToHaveNoOverflow() const {
     return m_bitfields.knownToHaveNoOverflow();
   }
   void clearKnownToHaveNoOverflow();
 
   bool dirOverride() const { return m_bitfields.dirOverride(); }
   void setDirOverride(bool dirOverride) {
     m_bitfields.setDirOverride(dirOverride);
   }
 
-  // Set all LineLayoutItems in the inline box subtree should do full paint invalidation.
+  // Set all LineLayoutItems in the inline box subtree should do full paint
+  // invalidation.
   void setShouldDoFullPaintInvalidationRecursively();
 
 #define ADD_BOOLEAN_BITFIELD(name, Name) \
  private:                                \
   unsigned m_##name : 1;                 \
                                          \
  public:                                 \
   bool name() const { return m_##name; } \
   void set##Name(bool name) { m_##name = name; }
 
@@ skipping 16 matching lines @@
           m_endsWithBreak(false),
           m_hasSelectedChildrenOrCanHaveLeadingExpansion(false),
           m_knownToHaveNoOverflow(true),
           m_hasEllipsisBoxOrHyphen(false),
           m_dirOverride(false),
           m_isText(false),
           m_determinedIfNextOnLineExists(false),
           m_nextOnLineExists(false),
           m_expansion(0) {}
 
-    // Some of these bits are actually for subclasses and moved here to compact the structures.
+    // Some of these bits are actually for subclasses and moved here to compact
+    // the structures.
     // for this class
     ADD_BOOLEAN_BITFIELD(firstLine, FirstLine);
     ADD_BOOLEAN_BITFIELD(constructed, Constructed);
 
    private:
-    unsigned
-        m_bidiEmbeddingLevel : 6;  // The maximium bidi level is 62: http://unicode.org/reports/tr9/#Explicit_Levels_and_Directions
+    // The maximium bidi level is 62:
+    // http://unicode.org/reports/tr9/#Explicit_Levels_and_Directions
+    unsigned m_bidiEmbeddingLevel : 6;
 
    public:
     unsigned char bidiEmbeddingLevel() const { return m_bidiEmbeddingLevel; }
     void setBidiEmbeddingLevel(unsigned char bidiEmbeddingLevel) {
       m_bidiEmbeddingLevel = bidiEmbeddingLevel;
     }
 
     ADD_BOOLEAN_BITFIELD(dirty, Dirty);
     ADD_BOOLEAN_BITFIELD(extracted, Extracted);
     ADD_BOOLEAN_BITFIELD(hasVirtualLogicalHeight, HasVirtualLogicalHeight);
     ADD_BOOLEAN_BITFIELD(isHorizontal, IsHorizontal);
     // for RootInlineBox
     ADD_BOOLEAN_BITFIELD(endsWithBreak,
                          EndsWithBreak);  // Whether the line ends with a <br>.
     // shared between RootInlineBox and InlineTextBox
     ADD_BOOLEAN_BITFIELD(hasSelectedChildrenOrCanHaveLeadingExpansion,
                          HasSelectedChildrenOrCanHaveLeadingExpansion);
 
-    // This boolean will never be set if there is potential for overflow,
-    // but it will be eagerly cleared in the opposite case. As such, it's
-    // a conservative tracking of the absence of overflow.
+    // This boolean will never be set if there is potential for overflow, but it
+    // will be eagerly cleared in the opposite case. As such, it's a
+    // conservative tracking of the absence of overflow.
     //
     // For whether we have overflow, callers should use m_overflow on
     // InlineFlowBox.
     ADD_BOOLEAN_BITFIELD(knownToHaveNoOverflow, KnownToHaveNoOverflow);
     ADD_BOOLEAN_BITFIELD(hasEllipsisBoxOrHyphen, HasEllipsisBoxOrHyphen);
     // for InlineTextBox
     ADD_BOOLEAN_BITFIELD(dirOverride, DirOverride);
-    ADD_BOOLEAN_BITFIELD(
-        isText,
-        IsText);  // Whether or not this object represents text with a non-zero height. Includes non-image list markers, text boxes.
+    // Whether or not this object represents text with a non-zero height.
+    // Includes non-image list markers, text boxes.
+    ADD_BOOLEAN_BITFIELD(isText, IsText);
 
    private:
     mutable unsigned m_determinedIfNextOnLineExists : 1;
 
    public:
     bool determinedIfNextOnLineExists() const {
       return m_determinedIfNextOnLineExists;
     }
     void setDeterminedIfNextOnLineExists(
         bool determinedIfNextOnLineExists) const {
@@ skipping 12 matching lines @@
    private:
     unsigned m_expansion : 12;  // for justified text
 
    public:
     signed expansion() const { return m_expansion; }
     void setExpansion(signed expansion) { m_expansion = expansion; }
   };
 #undef ADD_BOOLEAN_BITFIELD
 
  private:
-  // Converts the given (top-left) position from the logical space of the InlineBox to the physical space of the
-  // containing block. The size indicates the size of the box whose point is being flipped.
+  // Converts the given (top-left) position from the logical space of the
+  // InlineBox to the physical space of the containing block. The size indicates
+  // the size of the box whose point is being flipped.
   LayoutPoint logicalPositionToPhysicalPoint(const LayoutPoint&,
                                              const LayoutSize&) const;
 
   void setLineLayoutItemShouldDoFullPaintInvalidationIfNeeded();
 
   InlineBoxBitfields m_bitfields;
 
   InlineBox* m_next;  // The next element on the same line as us.
   InlineBox* m_prev;  // The previous element on the same line as us.
 
@@ skipping 52 matching lines @@
 #if ENABLE(ASSERT)
 inline void InlineBox::setHasBadParent() {
   m_hasBadParent = true;
 }
 #endif
 
 #define DEFINE_INLINE_BOX_TYPE_CASTS(typeName)                     \
   DEFINE_TYPE_CASTS(typeName, InlineBox, box, box->is##typeName(), \
                     box.is##typeName())
 
-// Allow equality comparisons of InlineBox's by reference or pointer, interchangeably.
+// Allow equality comparisons of InlineBox's by reference or pointer,
+// interchangeably.
 DEFINE_COMPARISON_OPERATORS_WITH_REFERENCES(InlineBox)
 
 }  // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showTree(const blink::InlineBox*);
 void showLineTree(const blink::InlineBox*);
 #endif
 
 #endif  // InlineBox_h