Remove flipForWritingMode.

sky/engine/core/rendering/RenderBox.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
  * modify it under the terms of the GNU Library General Public
@@ skipping 641 matching lines @@
     ASSERT(hasOverflowClip());
     ASSERT(hasLayer());
     return layer()->scrollableArea()->scrollOffset();
 }
 
 void RenderBox::applyCachedClipAndScrollOffsetForPaintInvalidation(LayoutRect& paintRect) const
 {
     ASSERT(hasLayer());
     ASSERT(hasOverflowClip());
 
-    flipForWritingMode(paintRect);
     paintRect.move(-scrolledContentOffset()); // For overflow:auto/scroll/hidden.
 
     // Do not clip scroll layer contents to reduce the number of paint invalidations while scrolling.
-    if (usesCompositedScrolling()) {
-        flipForWritingMode(paintRect);
+    if (usesCompositedScrolling())
         return;
-    }
 
     // height() is inaccurate if we're in the middle of a layout of this RenderBox, so use the
     // layer's size instead. Even if the layer's size is wrong, the layer itself will issue paint invalidations
     // anyway if its size does change.
     LayoutRect clipRect(LayoutPoint(), layer()->size());
     paintRect = intersection(paintRect, clipRect);
-    flipForWritingMode(paintRect);
 }
 
 void RenderBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
     minLogicalWidth = minPreferredLogicalWidth() - borderAndPaddingLogicalWidth();
     maxLogicalWidth = maxPreferredLogicalWidth() - borderAndPaddingLogicalWidth();
 }
 
 LayoutUnit RenderBox::minPreferredLogicalWidth() const
 {
@@ skipping 966 matching lines @@
 LayoutRect RenderBox::clippedOverflowRectForPaintInvalidation(const RenderLayerModelObject* paintInvalidationContainer, const PaintInvalidationState* paintInvalidationState) const
 {
     LayoutRect r = visualOverflowRect();
     mapRectToPaintInvalidationBacking(paintInvalidationContainer, r, paintInvalidationState);
     return r;
 }
 
 void RenderBox::mapRectToPaintInvalidationBacking(const RenderLayerModelObject* paintInvalidationContainer, LayoutRect& rect, const PaintInvalidationState* paintInvalidationState) const
 {
     // The rect we compute at each step is shifted by our x/y offset in the parent container's coordinate space.
-    // Only when we cross a writing mode boundary will we have to possibly flipForWritingMode (to convert into a more appropriate
-    // offset corner for the enclosing container). This allows for a fully RL or BT document to issue paint invalidations
-    // properly even during layout, since the rect remains flipped all the way until the end.
     //
     // RenderView::computeRectForPaintInvalidation then converts the rect to physical coordinates. We also convert to
     // physical when we hit a paintInvalidationContainer boundary. Therefore the final rect returned is always in the
     // physical coordinate space of the paintInvalidationContainer.
     RenderStyle* styleToUse = style();
 
     EPosition position = styleToUse->position();
 
     // We need to inflate the paint invalidation rect before we use paintInvalidationState,
     // else we would forget to inflate it for the current renderer. FIXME: If these were
@@ skipping 17 matching lines @@
 
     if (paintInvalidationContainer == this) {
         return;
     }
 
     bool containerSkipped;
     RenderObject* o = container(paintInvalidationContainer, &containerSkipped);
     if (!o)
         return;
 
-    if (isWritingModeRoot())
-        flipForWritingMode(rect);
-
     LayoutPoint topLeft = rect.location();
     topLeft.move(locationOffset());
 
     // We are now in our parent container's coordinate space.  Apply our transform to obtain a bounding box
     // in the parent's coordinate space that encloses us.
     if (hasLayer() && layer()->transform()) {
         rect = layer()->transform()->mapRect(pixelSnappedIntRect(rect));
         topLeft = rect.location();
         topLeft.move(locationOffset());
     }
@@ skipping 2103 matching lines @@
     // We want to include the margin, but only when it adds height. Quirky margins don't contribute height
     // nor do the margins of self-collapsing blocks.
     if (!style()->hasMarginAfterQuirk() && !isSelfCollapsingBlock())
         rect.expand(LayoutSize(LayoutUnit(), marginAfter()));
 
     if (!hasOverflowClip())
         rect.unite(layoutOverflowRect());
 
     bool hasTransform = hasLayer() && layer()->transform();
     if (isRelPositioned() || hasTransform) {
-        // If we are relatively positioned or if we have a transform, then we have to convert
-        // this rectangle into physical coordinates, apply relative positioning and transforms
-        // to it, and then convert it back.
-        flipForWritingMode(rect);
-
         if (hasTransform)
             rect = layer()->currentTransform().mapRect(rect);
 
         if (isRelPositioned())
             rect.move(offsetForInFlowPosition());
-
-        // Now we need to flip back.
-        flipForWritingMode(rect);
     }
 
     return rect;
 }
 
 LayoutRect RenderBox::noOverflowRect() const
 {
     // Because of the special coordinate system used for overflow rectangles and many other
     // rectangles (not quite logical, not quite physical), we need to flip the block progression
     // coordinate in vertical-rl and horizontal-bt writing modes. In other words, the rectangle
     // returned is physical, except for the block direction progression coordinate (y in horizontal
     // writing modes, x in vertical writing modes), which is always "logical top". Apart from the
     // flipping, this method does the same as clientBoxRect().
 
     const int scrollBarWidth = verticalScrollbarWidth();
     const int scrollBarHeight = horizontalScrollbarHeight();
     LayoutUnit left = borderLeft() + (style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft() ? scrollBarWidth : 0);
     LayoutUnit top = borderTop();
     LayoutUnit right = borderRight();
     LayoutUnit bottom = borderBottom();
     LayoutRect rect(left, top, width() - left - right, height() - top - bottom);
-    flipForWritingMode(rect);
     // Subtract space occupied by scrollbars. Order is important here: first flip, then subtract
     // scrollbars. This may seem backwards and weird, since one would think that a horizontal
     // scrollbar at the physical bottom in horizontal-bt ought to be at the logical top (physical
     // bottom), between the logical top (physical bottom) border and the logical top (physical
     // bottom) padding. But this is how the rest of the code expects us to behave. This is highly
     // related to https://bugs.webkit.org/show_bug.cgi?id=76129
     // FIXME: when the above mentioned bug is fixed, it should hopefully be possible to call
     // clientBoxRect() or paddingBoxRect() in this method, rather than fiddling with the edges on
     // our own.
     if (style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
@@ skipping 17 matching lines @@
 LayoutUnit RenderBox::offsetLeft() const
 {
     return adjustedPositionRelativeToOffsetParent(topLeftLocation()).x();
 }
 
 LayoutUnit RenderBox::offsetTop() const
 {
     return adjustedPositionRelativeToOffsetParent(topLeftLocation()).y();
 }
 
-LayoutPoint RenderBox::flipForWritingModeForChild(const RenderBox* child, const LayoutPoint& point) const
-{
-    // FIXME(sky): Remove
-    return point;
-}
-
-void RenderBox::flipForWritingMode(LayoutRect& rect) const
-{
-    // FIXME(sky): Remove
-}
-
-LayoutUnit RenderBox::flipForWritingMode(LayoutUnit position) const
-{
-    // FIXME(sky): Remove
-    return position;
-}
-
-LayoutPoint RenderBox::flipForWritingMode(const LayoutPoint& position) const
-{
-    // FIXME(sky): Remove
-    return position;
-}
-
-LayoutPoint RenderBox::flipForWritingModeIncludingColumns(const LayoutPoint& point) const
-{
-    // FIXME(sky): Remove
-    return point;
-}
-
-LayoutSize RenderBox::flipForWritingMode(const LayoutSize& offset) const
-{
-    // FIXME(sky): Remove
-    return offset;
-}
-
-FloatPoint RenderBox::flipForWritingMode(const FloatPoint& position) const
-{
-    // FIXME(sky): Remove
-    return position;
-}
-
-void RenderBox::flipForWritingMode(FloatRect& rect) const
-{
-    // FIXME(sky): Remove
-}
-
 LayoutPoint RenderBox::topLeftLocation() const
 {
-    RenderBlock* containerBlock = containingBlock();
-    if (!containerBlock || containerBlock == this)
-        return location();
-    return containerBlock->flipForWritingModeForChild(this, location());
+    // FIXME(sky): Remove this.
+    return location();
 }
 
 LayoutSize RenderBox::topLeftLocationOffset() const
 {
-    RenderBlock* containerBlock = containingBlock();
-    if (!containerBlock || containerBlock == this)
-        return locationOffset();
-
-    LayoutRect rect(frameRect());
-    containerBlock->flipForWritingMode(rect); // FIXME: This is wrong if we are an absolutely positioned object enclosed by a relative-positioned inline.
-    return LayoutSize(rect.x(), rect.y());
+    // FIXME(sky): Remove this.
+    return locationOffset();
 }
 
 bool RenderBox::hasRelativeLogicalHeight() const
 {
     return style()->logicalHeight().isPercent()
         || style()->logicalMinHeight().isPercent()
         || style()->logicalMaxHeight().isPercent();
 }
 
 static void markBoxForRelayoutAfterSplit(RenderBox* box)
@@ skipping 75 matching lines @@
 
 RenderBox::BoxDecorationData::BoxDecorationData(const RenderStyle& style)
 {
     backgroundColor = style.colorIncludingFallback(CSSPropertyBackgroundColor);
     hasBackground = backgroundColor.alpha() || style.hasBackgroundImage();
     ASSERT(hasBackground == style.hasBackground());
     hasBorder = style.hasBorder();
 }
 
 } // namespace blink