Fix scroll origin, overflow rects, and coordinate flipping for flexbox.

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

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 223 matching lines @@
 int LayoutFlexibleBox::inlineBlockBaseline(LineDirectionMode direction) const
 {
     int baseline = firstLineBoxBaseline();
     if (baseline != -1)
         return baseline;
 
     int marginAscent = direction == HorizontalLine ? marginTop() : marginRight();
     return synthesizedBaselineFromContentBox(*this, direction) + marginAscent;
 }
 
+IntSize LayoutFlexibleBox::originAdjustmentForScrollbars() const
+{
+    IntSize size;
+    int adjustmentWidth = verticalScrollbarWidth();
+    int adjustmentHeight = horizontalScrollbarHeight();
+    if (!adjustmentWidth && !adjustmentHeight)
+        return size;
+
+    EFlexDirection flexDirection = style()->flexDirection();
+    TextDirection textDirection = style()->direction();
+    WritingMode writingMode = style()->getWritingMode();
+
+    if (flexDirection == FlowRow) {
+        if (textDirection == RTL) {
+            if (writingMode == TopToBottomWritingMode)
+                size.expand(adjustmentWidth, 0);
+            else
+                size.expand(0, adjustmentHeight);
+        }
+        if (writingMode == RightToLeftWritingMode)
+            size.expand(adjustmentWidth, 0);
+    } else if (flexDirection == FlowRowReverse) {
+        if (textDirection == LTR) {
+            if (writingMode == TopToBottomWritingMode)
+                size.expand(adjustmentWidth, 0);
+            else
+                size.expand(0, adjustmentHeight);
+        }
+        if (writingMode == RightToLeftWritingMode)
+            size.expand(adjustmentWidth, 0);
+    } else if (flexDirection == FlowColumn) {
+        if (writingMode == RightToLeftWritingMode)
+            size.expand(adjustmentWidth, 0);
+    } else {
+        if (writingMode == TopToBottomWritingMode)
+            size.expand(0, adjustmentHeight);
+        else if (writingMode == LeftToRightWritingMode)
+            size.expand(adjustmentWidth, 0);
+    }
+    return size;
+}
+
+bool LayoutFlexibleBox::hasTopOverflow() const
+{
+    EFlexDirection flexDirection = style()->flexDirection();
+    if (isHorizontalWritingMode())
+        return flexDirection == FlowColumnReverse;
+    return flexDirection == (style()->isLeftToRightDirection() ? FlowRowReverse : FlowRow);
+}
+
+bool LayoutFlexibleBox::hasLeftOverflow() const
+{
+    EFlexDirection flexDirection = style()->flexDirection();
+    if (isHorizontalWritingMode())
+        return flexDirection == (style()->isLeftToRightDirection() ? FlowRowReverse : FlowRow);
+    return flexDirection == FlowColumnReverse;
+}
+
 void LayoutFlexibleBox::removeChild(LayoutObject* child)
 {
     LayoutBlock::removeChild(child);
     m_intrinsicSizeAlongMainAxis.remove(child);
 }
 
 void LayoutFlexibleBox::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     LayoutBlock::styleDidChange(diff, oldStyle);
 
@@ skipping 1271 matching lines @@
 {
     ASSERT(childSizes.size() == children.size());
 
     ContentPosition position = styleRef().resolvedJustifyContentPosition(normalValueBehavior());
     ContentDistributionType distribution = styleRef().resolvedJustifyContentDistribution(normalValueBehavior());
 
     size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
     LayoutUnit autoMarginOffset = autoMarginOffsetInMainAxis(children, availableFreeSpace);
     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
     mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, position, distribution, numberOfChildrenForJustifyContent);
-    if (style()->flexDirection() == FlowRowReverse)
+    if (style()->flexDirection() == FlowRowReverse && shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
 
     LayoutUnit totalMainExtent = mainAxisExtent();
+    if (!shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
+        totalMainExtent -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
     LayoutUnit maxAscent, maxDescent; // Used when align-items: baseline.
     LayoutUnit maxChildCrossAxisExtent;
     size_t seenInFlowPositionedChildren = 0;
     bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
     for (size_t i = 0; i < children.size(); ++i) {
         LayoutBox* child = children[i];
 
         if (child->isOutOfFlowPositioned()) {
             prepareChildForPositionedLayout(*child);
             continue;
@@ skipping 43 matching lines @@
             setLogicalHeight(std::max(logicalHeight(), crossAxisOffset + flowAwareBorderAfter() + flowAwarePaddingAfter() + childCrossAxisMarginBoxExtent + crossAxisScrollbarExtent()));
         maxChildCrossAxisExtent = std::max(maxChildCrossAxisExtent, childCrossAxisMarginBoxExtent);
 
         mainAxisOffset += flowAwareMarginStartForChild(*child);
 
         LayoutUnit childMainExtent = mainAxisExtentForChild(*child);
         // In an RTL column situation, this will apply the margin-right/margin-end on the left.
         // This will be fixed later in flipForRightToLeftColumn.
         LayoutPoint childLocation(shouldFlipMainAxis ? totalMainExtent - mainAxisOffset - childMainExtent : mainAxisOffset,
             crossAxisOffset + flowAwareMarginBeforeForChild(*child));
-
         setFlowAwareLocationForChild(*child, childLocation);
         mainAxisOffset += childMainExtent + flowAwareMarginEndForChild(*child);
 
         ++seenInFlowPositionedChildren;
         if (seenInFlowPositionedChildren < numberOfChildrenForJustifyContent)
             mainAxisOffset += justifyContentSpaceBetweenChildren(availableFreeSpace, distribution, numberOfChildrenForJustifyContent);
     }
 
     if (isColumnFlow())
         setLogicalHeight(std::max(logicalHeight(), mainAxisOffset + flowAwareBorderEnd() + flowAwarePaddingEnd() + scrollbarLogicalHeight()));
@@ skipping 207 matching lines @@
         return;
 
     LayoutUnit crossExtent = crossAxisExtent();
     for (LayoutBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
         if (child->isOutOfFlowPositioned())
             continue;
         LayoutPoint location = flowAwareLocationForChild(*child);
         // For vertical flows, setFlowAwareLocationForChild will transpose x and y,
         // so using the y axis for a column cross axis extent is correct.
         location.setY(crossExtent - crossAxisExtentForChild(*child) - location.y());
+        if (!isHorizontalWritingMode())
+            location.move(LayoutSize(0, -horizontalScrollbarHeight()));
         setFlowAwareLocationForChild(*child, location);
     }
 }
 
 void LayoutFlexibleBox::flipForWrapReverse(const Vector<LineContext>& lineContexts, LayoutUnit crossAxisStartEdge)
 {
     LayoutUnit contentExtent = crossAxisContentExtent();
     LayoutBox* child = m_orderIterator.first();
     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = m_orderIterator.next()) {
             ASSERT(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(*child, newOffset - originalOffset);
         }
     }
 }
 
 } // namespace blink