Rename some functions about layout locations

third_party/WebKit/Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1954 matching lines @@
   LayoutBoxModelObject::mapAncestorToLocal(ancestor, transformState, mode);
 }
 
 LayoutSize LayoutBox::offsetFromContainer(const LayoutObject* o) const {
   ASSERT(o == container());
 
   LayoutSize offset;
   if (isInFlowPositioned())
     offset += offsetForInFlowPosition();
 
-  offset += topLeftLocationOffset();
+  offset += physicalLocationOffset();
 
   if (o->hasOverflowClip())
     offset -= toLayoutBox(o)->scrolledContentOffset();
 
   if (style()->position() == AbsolutePosition && o->isInFlowPositioned() &&
       o->isLayoutInline())
     offset += toLayoutInline(o)->offsetForInFlowPositionedInline(*this);
 
   return offset;
 }
@@ skipping 32 matching lines @@
       layer()->setStaticBlockPosition(box->logicalTop());
     }
 
     if (container()->isLayoutInline())
       moveWithEdgeOfInlineContainerIfNecessary(box->isHorizontal());
 
     // Nuke the box.
     box->remove(DontMarkLineBoxes);
     box->destroy();
   } else if (isAtomicInlineLevel()) {
-    setLocationAndUpdateOverflowControlsIfNeeded(box->topLeft());
+    setLocationAndUpdateOverflowControlsIfNeeded(box->location());
     setInlineBoxWrapper(box);
   }
 }
 
 void LayoutBox::moveWithEdgeOfInlineContainerIfNecessary(bool isHorizontal) {
   ASSERT(isOutOfFlowPositioned() && container()->isLayoutInline() &&
          container()->isInFlowPositioned());
   // If this object is inside a relative positioned inline and its inline
   // position is an explicit offset from the edge of its container then it will
   // need to move if its inline container has changed width. We do not track if
@@ skipping 273 matching lines @@
     // Use enclosingIntRect because we cannot properly compute pixel snapping
     // for painted elements within the transform since we don't know the desired
     // subpixel accumulation at this point, and the transform may include a
     // scale.
     FloatRect floatRect =
         rect.isEmpty() ? FloatRect(rect) : FloatRect(enclosingIntRect(rect));
     rect = LayoutRect(layer()->transform()->mapRect(floatRect));
   }
   LayoutPoint topLeft = rect.location();
   if (container->isBox()) {
-    topLeft.moveBy(topLeftLocation(toLayoutBox(container)));
+    topLeft.moveBy(physicalLocation(toLayoutBox(container)));
     // If the row is the ancestor, however, add its offset back in. In effect,
     // this passes from the joint <td> / <tr> coordinate space to the parent
     // space, then back to <tr> / <td>.
-    if (tableRowContainer)
+    if (tableRowContainer) {
       topLeft.moveBy(
-          -tableRowContainer->topLeftLocation(toLayoutBox(container)));
+          -tableRowContainer->physicalLocation(toLayoutBox(container)));
+    }
   } else if (container->isRuby()) {
     // TODO(wkorman): Generalize Ruby specialization and/or document more
     // clearly. See the accompanying specialization in
     // LayoutInline::mapToVisualRectInAncestorSpace.
-    topLeft.moveBy(topLeftLocation());
+    topLeft.moveBy(physicalLocation());
   } else {
     topLeft.moveBy(location());
   }
 
   const ComputedStyle& styleToUse = styleRef();
   EPosition position = styleToUse.position();
   if (position == AbsolutePosition && container->isInFlowPositioned() &&
       container->isLayoutInline()) {
     topLeft +=
         toLayoutInline(container)->offsetForInFlowPositionedInline(*this);
@@ skipping 2805 matching lines @@
 LayoutRect LayoutBox::visualOverflowRect() const {
   if (!m_overflow)
     return borderBoxRect();
   if (hasOverflowClip())
     return m_overflow->selfVisualOverflowRect();
   return unionRect(m_overflow->selfVisualOverflowRect(),
                    m_overflow->contentsVisualOverflowRect());
 }
 
 LayoutUnit LayoutBox::offsetLeft(const Element* parent) const {
-  return adjustedPositionRelativeTo(topLeftLocation(), parent).x();
+  return adjustedPositionRelativeTo(physicalLocation(), parent).x();
 }
 
 LayoutUnit LayoutBox::offsetTop(const Element* parent) const {
-  return adjustedPositionRelativeTo(topLeftLocation(), parent).y();
+  return adjustedPositionRelativeTo(physicalLocation(), parent).y();
 }
 
 LayoutPoint LayoutBox::flipForWritingModeForChild(
     const LayoutBox* child,
     const LayoutPoint& point) const {
   if (!style()->isFlippedBlocksWritingMode())
     return point;
 
   // The child is going to add in its x(), so we have to make sure it ends up in
   // the right place.
   return LayoutPoint(point.x() + size().width() - child->size().width() -
                          (2 * child->location().x()),
                      point.y());
 }
 
 LayoutBox* LayoutBox::locationContainer() const {
   // Location of a non-root SVG object derived from LayoutBox should not be
   // affected by writing-mode of the containing box (SVGRoot).
   if (isSVG() && !isSVGRoot())
     return nullptr;
 
   // Normally the box's location is relative to its containing box.
   LayoutObject* container = this->container();
   while (container && !container->isBox())
     container = container->container();
   return toLayoutBox(container);
 }
 
-LayoutPoint LayoutBox::topLeftLocation(
+LayoutPoint LayoutBox::physicalLocation(
     const LayoutBox* flippedBlocksContainer) const {
   const LayoutBox* containerBox;
   if (flippedBlocksContainer) {
     DCHECK(flippedBlocksContainer == locationContainer());
     containerBox = flippedBlocksContainer;
   } else {
     containerBox = locationContainer();
   }
   if (!containerBox)
     return location();
@@ skipping 421 matching lines @@
   LayoutRect rect = frameRect();
 
   LayoutBlock* block = containingBlock();
   if (block)
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 }  // namespace blink