Attachment #161073 for bug #95255

View Details Raw Unified Return to Bug 95255

| Differences between



2012-08-28  Tony Chang  <tony@chromium.org>

        Make RenderBox::computeInlineDirectionMargins const
        https://bugs.webkit.org/show_bug.cgi?id=95255

        Reviewed by NOBODY (OOPS!).

        This is part of making computeLogical{Height,Width} return computed values rather than
        mutating the RenderBox directly. This makes a submethod const.

        Tests: fast/block/margins-perpendicular-containing-block.html
               fast/table/margins-flipped-text-direction.html
               fast/table/margins-perpendicular-containing-block.html

        * rendering/RenderBox.cpp:
        (WebCore::RenderBox::computeLogicalWidthInRegion): Handle flipped text direction manually.
        (WebCore::RenderBox::computeInlineDirectionMargins): Make const with out parameters.
        No longer need to call setMargin{Start,End}ForChild.
        (WebCore::shouldFlipBeforeAfterMargins): Helper function to figure out how to map a logical
        writing mode direction to another logical writing mode direction.
        (WebCore::RenderBox::computeLogicalHeight): Use const method. This also makes it more
        obvious that when computing the height, we only modify the before/after margins.
        * rendering/RenderBox.h:
        (RenderBox): Make computeInlineDirectionMargins const with out parameters.
        * rendering/RenderTable.cpp:
        (WebCore::RenderTable::computeLogicalWidth): Same as RenderBox::comptueLogicalWidthInregion.

2012-08-24  James Robinson  <jamesr@chromium.org>

        [chromium] Clean up dependencies of WebScrollbar and WebScrollbarLayer



        LayoutUnit containerLogicalWidthForAutoMargins = containerLogicalWidth;
        if (avoidsFloats() && cb->containsFloats())
            containerLogicalWidthForAutoMargins = containingBlockAvailableLineWidthInRegion(region, offsetFromLogicalTopOfFirstPage);
        ComputedMarginValues marginValues;
        computeInlineDirectionMargins(cb, containerLogicalWidthForAutoMargins, logicalWidth(),
            cb->style()->isLeftToRightDirection() == style()->isLeftToRightDirection() ? marginValues.m_start : marginValues.m_end,
            cb->style()->isLeftToRightDirection() == style()->isLeftToRightDirection() ? marginValues.m_end : marginValues.m_start);
        setMarginStart(marginValues.m_start);
        setMarginEnd(marginValues.m_end);
    }
    
    if (!hasPerpendicularContainingBlock && containerLogicalWidth && containerLogicalWidth != (logicalWidth() + marginStart() + marginEnd())

    return false;
}

void RenderBox::computeInlineDirectionMargins(RenderBlock* containingBlock, LayoutUnit containerWidth, LayoutUnit childWidth, LayoutUnit& marginStart, LayoutUnit& marginEnd) const
{
    const RenderStyle* containingBlockStyle = containingBlock->style();
    Length marginStartLength = style()->marginStartUsing(containingBlockStyle);


    if (isFloating() || isInline()) {
        // Inline blocks/tables and floats don't have their margins increased.
        marginStart = minimumValueForLength(marginStartLength, containerWidth, renderView);
        marginEnd = minimumValueForLength(marginEndLength, containerWidth, renderView);
        return;
    }


        LayoutUnit marginStartWidth = minimumValueForLength(marginStartLength, containerWidth, renderView);
        LayoutUnit marginEndWidth = minimumValueForLength(marginEndLength, containerWidth, renderView);
        LayoutUnit centeredMarginBoxStart = max<LayoutUnit>(0, (containerWidth - childWidth - marginStartWidth - marginEndWidth) / 2);
        marginStart = centeredMarginBoxStart + marginStartWidth;
        marginEnd = containerWidth - childWidth - marginStart + marginEndWidth;
        return;
    } 
    
    // Case Two: The object is being pushed to the start of the containing block's available logical width.
    if (marginEndLength.isAuto() && childWidth < containerWidth) {
        marginStart = valueForLength(marginStartLength, containerWidth, renderView);
        marginEnd = containerWidth - childWidth - marginStart;
        return;
    } 
    

    bool pushToEndFromTextAlign = !marginEndLength.isAuto() && ((!containingBlockStyle->isLeftToRightDirection() && containingBlockStyle->textAlign() == WEBKIT_LEFT)
        || (containingBlockStyle->isLeftToRightDirection() && containingBlockStyle->textAlign() == WEBKIT_RIGHT));
    if ((marginStartLength.isAuto() && childWidth < containerWidth) || pushToEndFromTextAlign) {
        marginEnd = valueForLength(marginEndLength, containerWidth, renderView);
        marginStart = containerWidth - childWidth - marginEnd;
        return;
    } 
    
    // Case Four: Either no auto margins, or our width is >= the container width (css2.1, 10.3.3).  In that case
    // auto margins will just turn into 0.
    marginStart = minimumValueForLength(marginStartLength, containerWidth, renderView);
    marginEnd = minimumValueForLength(marginEndLength, containerWidth, renderView);
}

RenderBoxRegionInfo* RenderBox::renderBoxRegionInfo(RenderRegion* region, LayoutUnit offsetFromLogicalTopOfFirstPage, RenderBoxRegionInfoFlags cacheFlag) const

    return new RenderBoxRegionInfo(logicalLeftOffset, logicalWidthInRegion, isShifted);
}

static bool shouldFlipBeforeAfterMargins(WritingMode containingBlock, WritingMode child)
{
    if ((containingBlock == TopToBottomWritingMode && child == LeftToRightWritingMode)
        || (containingBlock == BottomToTopWritingMode && child == LeftToRightWritingMode)
        || (containingBlock == RightToLeftWritingMode && child == TopToBottomWritingMode)
        || (containingBlock == LeftToRightWritingMode && child == TopToBottomWritingMode))
        return false;
    if ((containingBlock == TopToBottomWritingMode && child == RightToLeftWritingMode)
        || (containingBlock == BottomToTopWritingMode && child == RightToLeftWritingMode)
        || (containingBlock == RightToLeftWritingMode && child == BottomToTopWritingMode)
        || (containingBlock == LeftToRightWritingMode && child == BottomToTopWritingMode))
        return true;
    ASSERT_NOT_REACHED(); // Writing modes should be perpendicular.
    return false;
}

void RenderBox::computeLogicalHeight()
{
    // Cell height is managed by the table and inline non-replaced elements do not support a height property.


        // For tables, calculate margins only.
        if (isTable()) {
            if (hasPerpendicularContainingBlock) {
                ComputedMarginValues marginValues;
                computeInlineDirectionMargins(cb, containingBlockLogicalWidthForContent(), logicalHeight(),
                    shouldFlipBeforeAfterMargins(cb->style()->writingMode(), style()->writingMode()) ? marginValues.m_after : marginValues.m_before,
                    shouldFlipBeforeAfterMargins(cb->style()->writingMode(), style()->writingMode()) ? marginValues.m_before : marginValues.m_after);
                setMarginBefore(marginValues.m_before);
                setMarginAfter(marginValues.m_after);
            }
            return;
        }



        setLogicalHeight(heightResult);
        
        if (hasPerpendicularContainingBlock) {
            ComputedMarginValues marginValues;
            computeInlineDirectionMargins(cb, containingBlockLogicalWidthForContent(), heightResult,
                    shouldFlipBeforeAfterMargins(cb->style()->writingMode(), style()->writingMode()) ? marginValues.m_after : marginValues.m_before,
                    shouldFlipBeforeAfterMargins(cb->style()->writingMode(), style()->writingMode()) ? marginValues.m_before : marginValues.m_after);
            setMarginBefore(marginValues.m_before);
            setMarginAfter(marginValues.m_after);
        }
    }

    // WinIE quirk: The <html> block always fills the entire canvas in quirks mode.  The <body> always fills the

Lines 332-338 public: a/Source/WebCore/rendering/RenderBox.h_sec1
- a/Source/WebCore/rendering/RenderBox.h -1 / +1 lines
332	};	332	};
333	// Resolve auto margins in the inline direction of the containing block so that objects can be pushed to the start, middle or end	333	// Resolve auto margins in the inline direction of the containing block so that objects can be pushed to the start, middle or end
334	// of the containing block.	334	// of the containing block.
335	void computeInlineDirectionMargins(RenderBlock* containingBlock, LayoutUnit containerWidth, LayoutUnit childWidth);	335	void computeInlineDirectionMargins(RenderBlock* containingBlock, LayoutUnit containerWidth, LayoutUnit childWidth, LayoutUnit& marginStart, LayoutUnit& marginEnd) const;
336		336
337	// Used to resolve margins in the containing block's block-flow direction.	337	// Used to resolve margins in the containing block's block-flow direction.
338	void computeBlockDirectionMargins(const RenderBlock* containingBlock);	338	void computeBlockDirectionMargins(const RenderBlock* containingBlock);

Lines 260-266 void RenderTable::computeLogicalWidth() a/Source/WebCore/rendering/RenderTable.cpp_sec1
- a/Source/WebCore/rendering/RenderTable.cpp -1 / +6 lines
260	LayoutUnit containerLogicalWidthForAutoMargins = availableLogicalWidth;	260	LayoutUnit containerLogicalWidthForAutoMargins = availableLogicalWidth;
261	if (avoidsFloats() && cb->containsFloats())	261	if (avoidsFloats() && cb->containsFloats())
262	containerLogicalWidthForAutoMargins = containingBlockAvailableLineWidthInRegion(0, 0); // FIXME: Work with regions someday.	262	containerLogicalWidthForAutoMargins = containingBlockAvailableLineWidthInRegion(0, 0); // FIXME: Work with regions someday.
263	computeInlineDirectionMargins(cb, containerLogicalWidthForAutoMargins, logicalWidth());	263	ComputedMarginValues marginValues;
		264	computeInlineDirectionMargins(cb, containerLogicalWidthForAutoMargins, logicalWidth(),
		265	cb->style()->isLeftToRightDirection() == style()->isLeftToRightDirection() ? marginValues.m_start : marginValues.m_end,
		266	cb->style()->isLeftToRightDirection() == style()->isLeftToRightDirection() ? marginValues.m_end : marginValues.m_start);
		267	setMarginStart(marginValues.m_start);
		268	setMarginEnd(marginValues.m_end);
264	} else {	269	} else {
265	setMarginStart(minimumValueForLength(style()->marginStart(), availableLogicalWidth, renderView));	270	setMarginStart(minimumValueForLength(style()->marginStart(), availableLogicalWidth, renderView));
266	setMarginEnd(minimumValueForLength(style()->marginEnd(), availableLogicalWidth, renderView));	271	setMarginEnd(minimumValueForLength(style()->marginEnd(), availableLogicalWidth, renderView));



2012-08-28  Tony Chang  <tony@chromium.org>

        Make RenderBox::computeInlineDirectionMargins const
        https://bugs.webkit.org/show_bug.cgi?id=95255

        Reviewed by NOBODY (OOPS!).

        Add test cases for setting margins with perpendicular blocks or flipped text.

        * fast/block/margins-perpendicular-containing-block-expected.txt: Added.
        * fast/block/margins-perpendicular-containing-block.html: Added.
        * fast/table/margins-flipped-text-direction-expected.txt: Added.
        * fast/table/margins-flipped-text-direction.html: Added.
        * fast/table/margins-perpendicular-containing-block-expected.txt: Added.
        * fast/table/margins-perpendicular-containing-block.html: Added.

2012-08-27  Mark Lam  <mark.lam@apple.com>

        Gardening: Skipping tests due to JSC::Bindings::Instance::createRuntimeObject(JSC::ExecState*) crashes.



Hello
Hello
PASS
Hello
Hello
PASS
Hello
Hello
PASS
Hello
Hello
PASS



<!DOCTYPE html>
<html>
<head>
<style>
.horizontal, .vertical {
    position: relative;
}
.horizontal div {
    margin-left: 10px;
    margin-right: 20px;
}
.vertical div {
    margin-top: 10px;
    margin-bottom: 20px;
}
</style>
<script src="../../resources/check-layout.js"></script>
<script>
if (window.testRunner)
    testRunner.dumpAsText();
</script>
</head>

<body onload="checkLayout('.horizontal, .vertical')">
<div style="-webkit-writing-mode: horizontal-tb" class="horizontal">
<div data-offset-x=10 style="-webkit-writing-mode: vertical-rl">
    <tr><td>Hello</td></tr>
</div>
<div data-offset-x=10 style="-webkit-writing-mode: vertical-lr">
    <tr><td>Hello</td></tr>
</div>
</div>

<div style="-webkit-writing-mode: horizontal-bt" class="horizontal">
<div data-offset-x=10 style="-webkit-writing-mode: vertical-rl">
    <tr><td>Hello</td></tr>
</div>
<div data-offset-x=10 style="-webkit-writing-mode: vertical-lr">
    <tr><td>Hello</td></tr>
</div>
</div>

<div style="-webkit-writing-mode: vertical-rl" class="vertical">
<div data-offset-y=10 style="-webkit-writing-mode: horizontal-tb">
    <tr><td>Hello</td></tr>
</div>
<div data-offset-y=10 style="-webkit-writing-mode: horizontal-bt">
    <tr><td>Hello</td></tr>
</div>
</div>

<div style="-webkit-writing-mode: vertical-lr" class="vertical">
<div data-offset-y=10 style="-webkit-writing-mode: horizontal-tb">
    <tr><td>Hello</td></tr>
</div>
<div data-offset-y=10 style="-webkit-writing-mode: horizontal-bt">
    <tr><td>Hello</td></tr>
</div>
</div>
</body>
</html>

Line 0 a/LayoutTests/fast/table/margins-flipped-text-direction-expected.txt_sec1
- a/LayoutTests/fast/table/margins-flipped-text-direction-expected.txt +6 lines
	1	Hello
	2	Hello
	3	PASS
	4	Hello
	5	Hello
	6	PASS



<!DOCTYPE html>
<html>
<head>
<style>
div {
    position: relative;
    width: 600px;
}
table {
    margin-left: 10px;
    margin-right: 20px;
    width: 200px;
    border: 1px solid black;
}
</style>
<script src="../../resources/check-layout.js"></script>
<script>
if (window.testRunner)
    testRunner.dumpAsText();
</script>
</head>

<body onload="checkLayout('div')">
<div style="direction: ltr">
<table data-offset-x=10 style="direction: ltr">
    <tr><td>Hello</td></tr>
</table>
<table data-offset-x=10 style="direction: rtl">
    <tr><td>Hello</td></tr>
</table>
</div>

<div style="direction: rtl">
<table data-offset-x=380 style="direction: ltr">
    <tr><td>Hello</td></tr>
</table>
<table data-offset-x=380 style="direction: rtl">
    <tr><td>Hello</td></tr>
</table>
</div>

</div>
</body>
</html>



Hello
Hello
PASS
Hello
Hello
PASS
Hello
Hello
PASS
Hello
Hello
PASS



<!DOCTYPE html>
<html>
<head>
<style>
div {
    position: relative;
}
.horizontal table {
    margin-left: 10px;
    margin-right: 20px;
}
.vertical table {
    margin-top: 10px;
    margin-bottom: 20px;
}
</style>
<script src="../../resources/check-layout.js"></script>
<script>
if (window.testRunner)
    testRunner.dumpAsText();
</script>
</head>

<body onload="checkLayout('div')">
<div style="-webkit-writing-mode: horizontal-tb" class="horizontal">
<table data-offset-x=10 style="-webkit-writing-mode: vertical-rl">
    <tr><td>Hello</td></tr>
</table>
<table data-offset-x=10 style="-webkit-writing-mode: vertical-lr">
    <tr><td>Hello</td></tr>
</table>
</div>

<div style="-webkit-writing-mode: horizontal-bt" class="horizontal">
<table data-offset-x=10 style="-webkit-writing-mode: vertical-rl">
    <tr><td>Hello</td></tr>
</table>
<table data-offset-x=10 style="-webkit-writing-mode: vertical-lr">
    <tr><td>Hello</td></tr>
</table>
</div>

<div style="-webkit-writing-mode: vertical-rl" class="vertical">
<table data-offset-y=10 style="-webkit-writing-mode: horizontal-tb">
    <tr><td>Hello</td></tr>
</table>
<table data-offset-y=10 style="-webkit-writing-mode: horizontal-bt">
    <tr><td>Hello</td></tr>
</table>
</div>

<div style="-webkit-writing-mode: vertical-lr" class="vertical">
<table data-offset-y=10 style="-webkit-writing-mode: horizontal-tb">
    <tr><td>Hello</td></tr>
</table>
<table data-offset-y=10 style="-webkit-writing-mode: horizontal-bt">
    <tr><td>Hello</td></tr>
</table>
</div>
</body>
</html>

Return to Bug 95255

Lines 1712-1718 void RenderBox::computeLogicalWidthInRegion(RenderRegion* region, LayoutUnit off a/Source/WebCore/rendering/RenderBox.cpp_sec1
- a/Source/WebCore/rendering/RenderBox.cpp -16 / +49 lines
1712	LayoutUnit containerLogicalWidthForAutoMargins = containerLogicalWidth;	1712	LayoutUnit containerLogicalWidthForAutoMargins = containerLogicalWidth;
1713	if (avoidsFloats() && cb->containsFloats())	1713	if (avoidsFloats() && cb->containsFloats())
1714	containerLogicalWidthForAutoMargins = containingBlockAvailableLineWidthInRegion(region, offsetFromLogicalTopOfFirstPage);	1714	containerLogicalWidthForAutoMargins = containingBlockAvailableLineWidthInRegion(region, offsetFromLogicalTopOfFirstPage);
1715	computeInlineDirectionMargins(cb, containerLogicalWidthForAutoMargins, logicalWidth());	1715	ComputedMarginValues marginValues;
		1716	computeInlineDirectionMargins(cb, containerLogicalWidthForAutoMargins, logicalWidth(),
		1717	cb->style()->isLeftToRightDirection() == style()->isLeftToRightDirection() ? marginValues.m_start : marginValues.m_end,
		1718	cb->style()->isLeftToRightDirection() == style()->isLeftToRightDirection() ? marginValues.m_end : marginValues.m_start);
		1719	setMarginStart(marginValues.m_start);
		1720	setMarginEnd(marginValues.m_end);
1716	}	1721	}
1717		1722
1718	if (!hasPerpendicularContainingBlock && containerLogicalWidth && containerLogicalWidth != (logicalWidth() + marginStart() + marginEnd())	1723	if (!hasPerpendicularContainingBlock && containerLogicalWidth && containerLogicalWidth != (logicalWidth() + marginStart() + marginEnd())
Lines 1820-1826 bool RenderBox::sizesLogicalWidthToFitContent(SizeType widthType) const a/Source/WebCore/rendering/RenderBox.cpp_sec2
1820	return false;	1825	return false;
1821	}	1826	}
1822		1827
1823	void RenderBox::computeInlineDirectionMargins(RenderBlock* containingBlock, LayoutUnit containerWidth, LayoutUnit childWidth)	1828	void RenderBox::computeInlineDirectionMargins(RenderBlock* containingBlock, LayoutUnit containerWidth, LayoutUnit childWidth, LayoutUnit& marginStart, LayoutUnit& marginEnd) const
1824	{	1829	{
1825	const RenderStyle* containingBlockStyle = containingBlock->style();	1830	const RenderStyle* containingBlockStyle = containingBlock->style();
1826	Length marginStartLength = style()->marginStartUsing(containingBlockStyle);	1831	Length marginStartLength = style()->marginStartUsing(containingBlockStyle);
Lines 1829-1836 void RenderBox::computeInlineDirectionMargins(RenderBlock* containingBlock, Layo a/Source/WebCore/rendering/RenderBox.cpp_sec3
1829		1834
1830	if (isFloating() \|\| isInline()) {	1835	if (isFloating() \|\| isInline()) {
1831	// Inline blocks/tables and floats don't have their margins increased.	1836	// Inline blocks/tables and floats don't have their margins increased.
1832	containingBlock->setMarginStartForChild(this, minimumValueForLength(marginStartLength, containerWidth, renderView));	1837	marginStart = minimumValueForLength(marginStartLength, containerWidth, renderView);
1833	containingBlock->setMarginEndForChild(this, minimumValueForLength(marginEndLength, containerWidth, renderView));	1838	marginEnd = minimumValueForLength(marginEndLength, containerWidth, renderView);
1834	return;	1839	return;
1835	}	1840	}
1836		1841
Lines 1841-1855 void RenderBox::computeInlineDirectionMargins(RenderBlock* containingBlock, Layo a/Source/WebCore/rendering/RenderBox.cpp_sec4
1841	LayoutUnit marginStartWidth = minimumValueForLength(marginStartLength, containerWidth, renderView);	1846	LayoutUnit marginStartWidth = minimumValueForLength(marginStartLength, containerWidth, renderView);
1842	LayoutUnit marginEndWidth = minimumValueForLength(marginEndLength, containerWidth, renderView);	1847	LayoutUnit marginEndWidth = minimumValueForLength(marginEndLength, containerWidth, renderView);
1843	LayoutUnit centeredMarginBoxStart = max<LayoutUnit>(0, (containerWidth - childWidth - marginStartWidth - marginEndWidth) / 2);	1848	LayoutUnit centeredMarginBoxStart = max<LayoutUnit>(0, (containerWidth - childWidth - marginStartWidth - marginEndWidth) / 2);
1844	containingBlock->setMarginStartForChild(this, centeredMarginBoxStart + marginStartWidth);	1849	marginStart = centeredMarginBoxStart + marginStartWidth;
1845	containingBlock->setMarginEndForChild(this, containerWidth - childWidth - containingBlock->marginStartForChild(this) + marginEndWidth);	1850	marginEnd = containerWidth - childWidth - marginStart + marginEndWidth;
1846	return;	1851	return;
1847	}	1852	}
1848		1853
1849	// Case Two: The object is being pushed to the start of the containing block's available logical width.	1854	// Case Two: The object is being pushed to the start of the containing block's available logical width.
1850	if (marginEndLength.isAuto() && childWidth < containerWidth) {	1855	if (marginEndLength.isAuto() && childWidth < containerWidth) {
1851	containingBlock->setMarginStartForChild(this, valueForLength(marginStartLength, containerWidth, renderView));	1856	marginStart = valueForLength(marginStartLength, containerWidth, renderView);
1852	containingBlock->setMarginEndForChild(this, containerWidth - childWidth - containingBlock->marginStartForChild(this));	1857	marginEnd = containerWidth - childWidth - marginStart;
1853	return;	1858	return;
1854	}	1859	}
1855		1860
Lines 1857-1871 void RenderBox::computeInlineDirectionMargins(RenderBlock* containingBlock, Layo a/Source/WebCore/rendering/RenderBox.cpp_sec5
1857	bool pushToEndFromTextAlign = !marginEndLength.isAuto() && ((!containingBlockStyle->isLeftToRightDirection() && containingBlockStyle->textAlign() == WEBKIT_LEFT)	1862	bool pushToEndFromTextAlign = !marginEndLength.isAuto() && ((!containingBlockStyle->isLeftToRightDirection() && containingBlockStyle->textAlign() == WEBKIT_LEFT)
1858	\|\| (containingBlockStyle->isLeftToRightDirection() && containingBlockStyle->textAlign() == WEBKIT_RIGHT));	1863	\|\| (containingBlockStyle->isLeftToRightDirection() && containingBlockStyle->textAlign() == WEBKIT_RIGHT));
1859	if ((marginStartLength.isAuto() && childWidth < containerWidth) \|\| pushToEndFromTextAlign) {	1864	if ((marginStartLength.isAuto() && childWidth < containerWidth) \|\| pushToEndFromTextAlign) {
1860	containingBlock->setMarginEndForChild(this, valueForLength(marginEndLength, containerWidth, renderView));	1865	marginEnd = valueForLength(marginEndLength, containerWidth, renderView);
1861	containingBlock->setMarginStartForChild(this, containerWidth - childWidth - containingBlock->marginEndForChild(this));	1866	marginStart = containerWidth - childWidth - marginEnd;
1862	return;	1867	return;
1863	}	1868	}
1864		1869
1865	// Case Four: Either no auto margins, or our width is >= the container width (css2.1, 10.3.3). In that case	1870	// Case Four: Either no auto margins, or our width is >= the container width (css2.1, 10.3.3). In that case
1866	// auto margins will just turn into 0.	1871	// auto margins will just turn into 0.
1867	containingBlock->setMarginStartForChild(this, minimumValueForLength(marginStartLength, containerWidth, renderView));	1872	marginStart = minimumValueForLength(marginStartLength, containerWidth, renderView);
1868	containingBlock->setMarginEndForChild(this, minimumValueForLength(marginEndLength, containerWidth, renderView));	1873	marginEnd = minimumValueForLength(marginEndLength, containerWidth, renderView);
1869	}	1874	}
1870		1875
1871	RenderBoxRegionInfo* RenderBox::renderBoxRegionInfo(RenderRegion* region, LayoutUnit offsetFromLogicalTopOfFirstPage, RenderBoxRegionInfoFlags cacheFlag) const	1876	RenderBoxRegionInfo* RenderBox::renderBoxRegionInfo(RenderRegion* region, LayoutUnit offsetFromLogicalTopOfFirstPage, RenderBoxRegionInfoFlags cacheFlag) const
Lines 1953-1958 RenderBoxRegionInfo* RenderBox::renderBoxRegionInfo(RenderRegion* region, Layout a/Source/WebCore/rendering/RenderBox.cpp_sec6
1953	return new RenderBoxRegionInfo(logicalLeftOffset, logicalWidthInRegion, isShifted);	1958	return new RenderBoxRegionInfo(logicalLeftOffset, logicalWidthInRegion, isShifted);
1954	}	1959	}
1955		1960
		1961	static bool shouldFlipBeforeAfterMargins(WritingMode containingBlock, WritingMode child)
		1962	{
		1963	if ((containingBlock == TopToBottomWritingMode && child == LeftToRightWritingMode)
		1964	\|\| (containingBlock == BottomToTopWritingMode && child == LeftToRightWritingMode)
		1965	\|\| (containingBlock == RightToLeftWritingMode && child == TopToBottomWritingMode)
		1966	\|\| (containingBlock == LeftToRightWritingMode && child == TopToBottomWritingMode))
		1967	return false;
		1968	if ((containingBlock == TopToBottomWritingMode && child == RightToLeftWritingMode)
		1969	\|\| (containingBlock == BottomToTopWritingMode && child == RightToLeftWritingMode)
		1970	\|\| (containingBlock == RightToLeftWritingMode && child == BottomToTopWritingMode)
		1971	\|\| (containingBlock == LeftToRightWritingMode && child == BottomToTopWritingMode))
		1972	return true;
		1973	ASSERT_NOT_REACHED(); // Writing modes should be perpendicular.
		1974	return false;
		1975	}
		1976
1956	void RenderBox::computeLogicalHeight()	1977	void RenderBox::computeLogicalHeight()
1957	{	1978	{
1958	// Cell height is managed by the table and inline non-replaced elements do not support a height property.	1979	// Cell height is managed by the table and inline non-replaced elements do not support a height property.
Lines 1977-1984 void RenderBox::computeLogicalHeight() a/Source/WebCore/rendering/RenderBox.cpp_sec7
1977		1998
1978	// For tables, calculate margins only.	1999	// For tables, calculate margins only.
1979	if (isTable()) {	2000	if (isTable()) {
1980	if (hasPerpendicularContainingBlock)	2001	if (hasPerpendicularContainingBlock) {
1981	computeInlineDirectionMargins(cb, containingBlockLogicalWidthForContent(), logicalHeight());	2002	ComputedMarginValues marginValues;
		2003	computeInlineDirectionMargins(cb, containingBlockLogicalWidthForContent(), logicalHeight(),
		2004	shouldFlipBeforeAfterMargins(cb->style()->writingMode(), style()->writingMode()) ? marginValues.m_after : marginValues.m_before,
		2005	shouldFlipBeforeAfterMargins(cb->style()->writingMode(), style()->writingMode()) ? marginValues.m_before : marginValues.m_after);
		2006	setMarginBefore(marginValues.m_before);
		2007	setMarginAfter(marginValues.m_after);
		2008	}
1982	return;	2009	return;
1983	}	2010	}
1984		2011
Lines 2026-2033 void RenderBox::computeLogicalHeight() a/Source/WebCore/rendering/RenderBox.cpp_sec8
2026		2053
2027	setLogicalHeight(heightResult);	2054	setLogicalHeight(heightResult);
2028		2055
2029	if (hasPerpendicularContainingBlock)	2056	if (hasPerpendicularContainingBlock) {
2030	computeInlineDirectionMargins(cb, containingBlockLogicalWidthForContent(), heightResult);	2057	ComputedMarginValues marginValues;
		2058	computeInlineDirectionMargins(cb, containingBlockLogicalWidthForContent(), heightResult,
		2059	shouldFlipBeforeAfterMargins(cb->style()->writingMode(), style()->writingMode()) ? marginValues.m_after : marginValues.m_before,
		2060	shouldFlipBeforeAfterMargins(cb->style()->writingMode(), style()->writingMode()) ? marginValues.m_before : marginValues.m_after);
		2061	setMarginBefore(marginValues.m_before);
		2062	setMarginAfter(marginValues.m_after);
		2063	}
2031	}	2064	}
2032		2065
2033	// WinIE quirk: The <html> block always fills the entire canvas in quirks mode. The <body> always fills the	2066	// WinIE quirk: The <html> block always fills the entire canvas in quirks mode. The <body> always fills the

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +27 lines
		1	2012-08-28 Tony Chang <tony@chromium.org>
		2
		3	Make RenderBox::computeInlineDirectionMargins const
		4	https://bugs.webkit.org/show_bug.cgi?id=95255
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This is part of making computeLogical{Height,Width} return computed values rather than
		9	mutating the RenderBox directly. This makes a submethod const.
		10
		11	Tests: fast/block/margins-perpendicular-containing-block.html
		12	fast/table/margins-flipped-text-direction.html
		13	fast/table/margins-perpendicular-containing-block.html
		14
		15	* rendering/RenderBox.cpp:
		16	(WebCore::RenderBox::computeLogicalWidthInRegion): Handle flipped text direction manually.
		17	(WebCore::RenderBox::computeInlineDirectionMargins): Make const with out parameters.
		18	No longer need to call setMargin{Start,End}ForChild.
		19	(WebCore::shouldFlipBeforeAfterMargins): Helper function to figure out how to map a logical
		20	writing mode direction to another logical writing mode direction.
		21	(WebCore::RenderBox::computeLogicalHeight): Use const method. This also makes it more
		22	obvious that when computing the height, we only modify the before/after margins.
		23	* rendering/RenderBox.h:
		24	(RenderBox): Make computeInlineDirectionMargins const with out parameters.
		25	* rendering/RenderTable.cpp:
		26	(WebCore::RenderTable::computeLogicalWidth): Same as RenderBox::comptueLogicalWidthInregion.
		27
1	2012-08-24 James Robinson <jamesr@chromium.org>	28	2012-08-24 James Robinson <jamesr@chromium.org>
2		29
3	[chromium] Clean up dependencies of WebScrollbar and WebScrollbarLayer	30	[chromium] Clean up dependencies of WebScrollbar and WebScrollbarLayer

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +16 lines
		1	2012-08-28 Tony Chang <tony@chromium.org>
		2
		3	Make RenderBox::computeInlineDirectionMargins const
		4	https://bugs.webkit.org/show_bug.cgi?id=95255
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Add test cases for setting margins with perpendicular blocks or flipped text.
		9
		10	* fast/block/margins-perpendicular-containing-block-expected.txt: Added.
		11	* fast/block/margins-perpendicular-containing-block.html: Added.
		12	* fast/table/margins-flipped-text-direction-expected.txt: Added.
		13	* fast/table/margins-flipped-text-direction.html: Added.
		14	* fast/table/margins-perpendicular-containing-block-expected.txt: Added.
		15	* fast/table/margins-perpendicular-containing-block.html: Added.
		16
1	2012-08-27 Mark Lam <mark.lam@apple.com>	17	2012-08-27 Mark Lam <mark.lam@apple.com>
2		18
3	Gardening: Skipping tests due to JSC::Bindings::Instance::createRuntimeObject(JSC::ExecState*) crashes.	19	Gardening: Skipping tests due to JSC::Bindings::Instance::createRuntimeObject(JSC::ExecState*) crashes.

Line 0 a/LayoutTests/fast/block/margins-perpendicular-containing-block-expected.txt_sec1
- a/LayoutTests/fast/block/margins-perpendicular-containing-block-expected.txt +12 lines
	1	Hello
	2	Hello
	3	PASS
	4	Hello
	5	Hello
	6	PASS
	7	Hello
	8	Hello
	9	PASS
	10	Hello
	11	Hello
	12	PASS

Line 0 a/LayoutTests/fast/block/margins-perpendicular-containing-block.html_sec1
- a/LayoutTests/fast/block/margins-perpendicular-containing-block.html +61 lines
	1	<!DOCTYPE html>
	2	<html>
	3	<head>
	4	<style>
	5	.horizontal, .vertical {
	6	position: relative;
	7	}
	8	.horizontal div {
	9	margin-left: 10px;
	10	margin-right: 20px;
	11	}
	12	.vertical div {
	13	margin-top: 10px;
	14	margin-bottom: 20px;
	15	}
	16	</style>
	17	<script src="../../resources/check-layout.js"></script>
	18	<script>
	19	if (window.testRunner)
	20	testRunner.dumpAsText();
	21	</script>
	22	</head>
	23
	24	<body onload="checkLayout('.horizontal, .vertical')">
	25	<div style="-webkit-writing-mode: horizontal-tb" class="horizontal">
	26	<div data-offset-x=10 style="-webkit-writing-mode: vertical-rl">
	27	<tr><td>Hello</td></tr>
	28	</div>
	29	<div data-offset-x=10 style="-webkit-writing-mode: vertical-lr">
	30	<tr><td>Hello</td></tr>
	31	</div>
	32	</div>
	33
	34	<div style="-webkit-writing-mode: horizontal-bt" class="horizontal">
	35	<div data-offset-x=10 style="-webkit-writing-mode: vertical-rl">
	36	<tr><td>Hello</td></tr>
	37	</div>
	38	<div data-offset-x=10 style="-webkit-writing-mode: vertical-lr">
	39	<tr><td>Hello</td></tr>
	40	</div>
	41	</div>
	42
	43	<div style="-webkit-writing-mode: vertical-rl" class="vertical">
	44	<div data-offset-y=10 style="-webkit-writing-mode: horizontal-tb">
	45	<tr><td>Hello</td></tr>
	46	</div>
	47	<div data-offset-y=10 style="-webkit-writing-mode: horizontal-bt">
	48	<tr><td>Hello</td></tr>
	49	</div>
	50	</div>
	51
	52	<div style="-webkit-writing-mode: vertical-lr" class="vertical">
	53	<div data-offset-y=10 style="-webkit-writing-mode: horizontal-tb">
	54	<tr><td>Hello</td></tr>
	55	</div>
	56	<div data-offset-y=10 style="-webkit-writing-mode: horizontal-bt">
	57	<tr><td>Hello</td></tr>
	58	</div>
	59	</div>
	60	</body>
	61	</html>

Line 0 a/LayoutTests/fast/table/margins-perpendicular-containing-block-expected.txt_sec1
- a/LayoutTests/fast/table/margins-perpendicular-containing-block-expected.txt +12 lines
	1	Hello
	2	Hello
	3	PASS
	4	Hello
	5	Hello
	6	PASS
	7	Hello
	8	Hello
	9	PASS
	10	Hello
	11	Hello
	12	PASS