Rename some functions about layout locations

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

 /*
  * 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,
@@ skipping 55 matching lines @@
             bool extracted,
             bool isHorizontal,
             InlineBox* next,
             InlineBox* prev,
             InlineFlowBox* parent)
       : m_bitfields(firstLine, constructed, dirty, extracted, isHorizontal),
         m_next(next),
         m_prev(prev),
         m_parent(parent),
         m_lineLayoutItem(item),
-        m_topLeft(topLeft),
+        m_location(topLeft),
         m_logicalWidth(logicalWidth)
 #if ENABLE(ASSERT)
         ,
         m_hasBadParent(false)
 #endif
   {
   }
 
   virtual ~InlineBox();
 
@@ skipping 129 matching lines @@
 
   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.
-  void setX(LayoutUnit x) { m_topLeft.setX(x); }
-  LayoutUnit x() const { return m_topLeft.x(); }
-  LayoutUnit left() const { return m_topLeft.x(); }
+  // x() is the location of the box in the containing block's "physical
+  // coordinates with flipped block-flow direction".
+  // See../README.md#Coordinate-Spaces for the definition.
+  void setX(LayoutUnit x) { m_location.setX(x); }
+  LayoutUnit x() const { return m_location.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(); }
+  // y() is the top side of the box in the containing block's physical
+  // coordinates. It's actually in the same coordinate space as x() but for y()
+  // physical coordinates and "physical coordinates with flipped block-flow
+  // direction" are the same.
+  void setY(LayoutUnit y) { m_location.setY(y); }
+  LayoutUnit y() const { return m_location.y(); }
 
-  const LayoutPoint& topLeft() const { return m_topLeft; }
+  // x() and y() in one LayoutPoint, in the containing block's "physical
+  // coordinates with flipped block-flow direction".
+  const LayoutPoint& location() const { return m_location; }
 
   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.
   LayoutUnit logicalLeft() const {
-    return isHorizontal() ? m_topLeft.x() : m_topLeft.y();
+    return isHorizontal() ? m_location.x() : m_location.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.
   LayoutUnit logicalTop() const {
-    return isHorizontal() ? m_topLeft.y() : m_topLeft.x();
+    return isHorizontal() ? m_location.y() : m_location.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.
   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.
   LayoutUnit logicalHeight() const;
 
   LayoutRect logicalFrameRect() const {
-    return isHorizontal() ? LayoutRect(m_topLeft.x(), m_topLeft.y(),
+    return isHorizontal() ? LayoutRect(m_location.x(), m_location.y(),
                                        m_logicalWidth, logicalHeight())
-                          : LayoutRect(m_topLeft.y(), m_topLeft.x(),
+                          : LayoutRect(m_location.y(), m_location.x(),
                                        m_logicalWidth, logicalHeight());
   }
 
   virtual int baselinePosition(FontBaseline baselineType) const;
   virtual LayoutUnit lineHeight() const;
 
   virtual int caretMinOffset() const;
   virtual int caretMaxOffset() const;
 
   unsigned char bidiLevel() const { return m_bitfields.bidiEmbeddingLevel(); }
@@ skipping 51 matching lines @@
                                      ->verticalAlign();
   }
 
   // Use with caution! The type is not checked!
   LineLayoutBoxModel boxModelObject() const {
     if (!getLineLayoutItem().isText())
       return LineLayoutBoxModel(m_lineLayoutItem);
     return LineLayoutBoxModel(nullptr);
   }
 
-  LayoutPoint locationIncludingFlipping() const;
+  // Physical location of the top-left corner of the box in the containing
+  // block.
+  LayoutPoint physicalLocation() 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.
   void logicalRectToPhysicalRect(LayoutRect&) const;
 
   // TODO(szager): The Rect versions should return a rect, not modify the
   // argument.
   void flipForWritingMode(FloatRect&) const;
   FloatPoint flipForWritingMode(const FloatPoint&) const;
@@ skipping 114 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.
-  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.
 
   InlineFlowBox* m_parent;  // The box that contains us.
   LineLayoutItem m_lineLayoutItem;
 
@@ skipping 26 matching lines @@
   void setCanHaveLeadingExpansion(bool canHaveLeadingExpansion) {
     m_bitfields.setHasSelectedChildrenOrCanHaveLeadingExpansion(
         canHaveLeadingExpansion);
   }
   signed expansion() { return m_bitfields.expansion(); }
   void setExpansion(signed expansion) { m_bitfields.setExpansion(expansion); }
 
   // For InlineFlowBox and InlineTextBox
   bool extracted() const { return m_bitfields.extracted(); }
 
-  LayoutPoint m_topLeft;
+  LayoutPoint m_location;
   LayoutUnit m_logicalWidth;
 
  private:
 #if ENABLE(ASSERT)
   bool m_hasBadParent;
 #endif
 };
 
 #if !ENABLE(ASSERT)
 inline InlineBox::~InlineBox() {}
@@ skipping 15 matching lines @@
 
 }  // 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