Attachment #192654 for bug #91554

View Details Raw Unified Return to Bug 91554

| Differences between



2013-03-11  Timothy Loh  <timloh@chromium.org>

        viewport units (vw, vh) don't work in CSS transforms
        https://bugs.webkit.org/show_bug.cgi?id=91554

        Reviewed by NOBODY (OOPS!).

        WIP.
        Change optional RenderView* parameter in valueForLength functions to a const IntSize&.
        Add equivalent valueForLength functions to RenderObject which call the regular ones,
        so we don't have to compute the viewportSize all the time.

        No new tests (OOPS!).

        * accessibility/atk/WebKitAccessibleInterfaceText.cpp:
        (getAttributeSetForAccessibilityObject):
        * css/CSSCalculationValue.cpp:
        (WebCore::unitCategory):
        (WebCore::CSSCalcValue::computeLengthPx):
        (WebCore::CSSCalcPrimitiveValue::toCalcValue):
        (WebCore::CSSCalcPrimitiveValue::computeLengthPx):
        (WebCore::CSSCalcBinaryOperation::computeLengthPx):
        * css/CSSCalculationValue.h:
        (CSSCalcValue):
        * css/CSSComputedStyleDeclaration.cpp:
        (WebCore::getPositionOffsetValue):
        (WebCore::getBorderRadiusCornerValues):
        (WebCore::getBorderRadiusCornerValue):
        (WebCore::getBorderRadiusShorthandValue):
        (WebCore::computedTransform):
        (WebCore::valueForCustomFilterTransformParameter):
        (WebCore::valueForGridTrackBreadth):
        (WebCore::valueForGridTrackMinMax):
        (WebCore::valueForGridTrackGroup):
        (WebCore::valueForGridTrackList):
        (WebCore::lineHeightFromStyle):
        (WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):
        * css/CSSGradientValue.cpp:
        (WebCore::CSSGradientValue::addStops):
        (WebCore::positionFromValue):
        (WebCore::CSSGradientValue::computeEndPoint):
        (WebCore::CSSLinearGradientValue::createGradient):
        (WebCore::CSSRadialGradientValue::resolveRadius):
        (WebCore::CSSRadialGradientValue::createGradient):
        * css/CSSGradientValue.h:
        (CSSGradientValue):
        (CSSRadialGradientValue):
        * css/CSSPrimitiveValue.cpp:
        (WebCore::CSSPrimitiveValue::computeLength):
        (WebCore::CSSPrimitiveValue::computeLengthDouble):
        (WebCore::CSSPrimitiveValue::equals):
        * css/CSSPrimitiveValue.h:
        (CSSPrimitiveValue):
        * css/CSSPrimitiveValueMappings.h:
        (WebCore::CSSPrimitiveValue::convertToLength):
        * css/CSSToStyleMap.cpp:
        (WebCore::CSSToStyleMap::mapFillXPosition):
        (WebCore::CSSToStyleMap::mapFillYPosition):
        (WebCore::CSSToStyleMap::mapNinePieceImageQuad):
        * css/LengthFunctions.cpp:
        (WebCore::minimumIntValueForLength):
        (WebCore::intValueForLength):
        (WebCore::minimumValueForLength):
        (WebCore::valueForLength):
        (WebCore::floatValueForLength):
        * css/LengthFunctions.h:
        (WebCore):
        * css/MediaQueryEvaluator.cpp:
        (WebCore::computeLength):
        (WebCore::device_heightMediaFeatureEval):
        (WebCore::device_widthMediaFeatureEval):
        (WebCore::heightMediaFeatureEval):
        (WebCore::widthMediaFeatureEval):
        * css/SVGCSSStyleSelector.cpp:
        (WebCore::StyleResolver::applySVGProperty):
        * css/StyleBuilder.cpp:
        (WebCore::ApplyPropertyAuto::applyValue):
        (WebCore::ApplyPropertyLength::applyValue):
        (WebCore::ApplyPropertyBorderRadius::applyValue):
        (WebCore::ApplyPropertyComputeLength::applyValue):
        (WebCore::ApplyPropertyFontSize::applyValue):
        (WebCore::ApplyPropertyLineHeight::applyValue):
        (WebCore::ApplyPropertyPageSize::mmLength):
        (WebCore::ApplyPropertyPageSize::inchLength):
        (WebCore::ApplyPropertyPageSize::applyValue):
        * css/StyleResolver.cpp:
        (WebCore::StyleResolver::applyProperty):
        (WebCore::StyleResolver::createFilterOperations):
        * css/StyleResolver.h:
        (StyleResolver):
        * css/WebKitCSSMatrix.cpp:
        (WebCore::WebKitCSSMatrix::setMatrixValue):
        * dom/Document.cpp:
        (WebCore::Document::pageSizeAndMarginsInPixels):
        * html/HTMLAreaElement.cpp:
        (WebCore::HTMLAreaElement::getRegion):
        * page/animation/CSSPropertyAnimation.cpp:
        (WebCore::blendFunc):
        * platform/CalculationValue.cpp:
        (WebCore::CalcExpressionBinaryOperation::evaluate):
        (WebCore::CalculationValue::evaluate):
        * platform/CalculationValue.h:
        (CalcExpressionNode):
        (CalculationValue):
        (WebCore::CalcExpressionNumber::evaluate):
        (WebCore::CalcExpressionLength::evaluate):
        (CalcExpressionBinaryOperation):
        (WebCore::CalcExpressionBlendLength::evaluate):
        * platform/Length.cpp:
        (WebCore::Length::nonNanCalculatedValue):
        * platform/Length.h:
        (Length):
        * platform/graphics/GraphicsLayer.h:
        (WebCore::GraphicsLayer::addAnimation):
        * platform/graphics/GraphicsLayerAnimation.cpp:
        (WebCore::blendFunc):
        (WebCore::applyFilterAnimation):
        (WebCore::applyTransformAnimation):
        (WebCore::GraphicsLayerAnimation::applyInternal):
        (WebCore::GraphicsLayerAnimation::apply):
        (WebCore::GraphicsLayerAnimations::apply):
        * platform/graphics/GraphicsLayerAnimation.h:
        (GraphicsLayerAnimation):
        (GraphicsLayerAnimations):
        * platform/graphics/chromium/AnimationTranslationUtil.cpp:
        (WebCore::toWebTransformOperations):
        (WebCore::appendKeyframeWithStandardTimingFunction):
        (WebCore::appendKeyframeWithCustomBezierTimingFunction):
        (WebCore::WebTransformAnimationCurve):
        (WebCore::createWebAnimation):
        * platform/graphics/chromium/AnimationTranslationUtil.h:
        (WebCore):
        * platform/graphics/chromium/GraphicsLayerChromium.cpp:
        (WebCore::GraphicsLayerChromium::addAnimation):
        * platform/graphics/chromium/GraphicsLayerChromium.h:
        (GraphicsLayerChromium):
        * platform/graphics/filters/CustomFilterArrayParameter.h:
        (WebCore::CustomFilterArrayParameter::blend):
        * platform/graphics/filters/CustomFilterNumberParameter.h:
        (WebCore::CustomFilterNumberParameter::blend):
        * platform/graphics/filters/CustomFilterOperation.cpp:
        (WebCore::CustomFilterOperation::blend):
        * platform/graphics/filters/CustomFilterOperation.h:
        (CustomFilterOperation):
        * platform/graphics/filters/CustomFilterParameter.h:
        (CustomFilterParameter):
        * platform/graphics/filters/CustomFilterParameterList.cpp:
        (WebCore::CustomFilterParameterList::blend):
        * platform/graphics/filters/CustomFilterParameterList.h:
        (CustomFilterParameterList):
        * platform/graphics/filters/CustomFilterRenderer.cpp:
        (WebCore::CustomFilterRenderer::bindProgramTransformParameter):
        * platform/graphics/filters/CustomFilterTransformParameter.h:
        (WebCore::CustomFilterTransformParameter::blend):
        (WebCore::CustomFilterTransformParameter::applyTransform):
        * platform/graphics/filters/FilterOperation.h:
        (WebCore::FilterOperation::FilterOperation::blend):
        * platform/graphics/filters/FilterOperations.cpp:
        (WebCore::FilterOperations::outsets):
        * platform/graphics/filters/ValidatedCustomFilterOperation.cpp:
        (WebCore::ValidatedCustomFilterOperation::blend):
        * platform/graphics/filters/ValidatedCustomFilterOperation.h:
        (ValidatedCustomFilterOperation):
        * platform/graphics/transforms/IdentityTransformOperation.h:
        (WebCore::IdentityTransformOperation::apply):
        (WebCore::IdentityTransformOperation::blend):
        * platform/graphics/transforms/Matrix3DTransformOperation.cpp:
        (WebCore::Matrix3DTransformOperation::blend):
        * platform/graphics/transforms/Matrix3DTransformOperation.h:
        (WebCore::Matrix3DTransformOperation::apply):
        (Matrix3DTransformOperation):
        * platform/graphics/transforms/MatrixTransformOperation.cpp:
        (WebCore::MatrixTransformOperation::blend):
        * platform/graphics/transforms/MatrixTransformOperation.h:
        (WebCore::MatrixTransformOperation::apply):
        (MatrixTransformOperation):
        * platform/graphics/transforms/PerspectiveTransformOperation.cpp:
        (WebCore::PerspectiveTransformOperation::blend):
        * platform/graphics/transforms/PerspectiveTransformOperation.h:
        (WebCore::PerspectiveTransformOperation::isIdentity):
        (WebCore::PerspectiveTransformOperation::apply):
        (PerspectiveTransformOperation):
        * platform/graphics/transforms/RotateTransformOperation.cpp:
        (WebCore::RotateTransformOperation::blend):
        * platform/graphics/transforms/RotateTransformOperation.h:
        (WebCore::RotateTransformOperation::apply):
        (RotateTransformOperation):
        * platform/graphics/transforms/ScaleTransformOperation.cpp:
        (WebCore::ScaleTransformOperation::blend):
        * platform/graphics/transforms/ScaleTransformOperation.h:
        (WebCore::ScaleTransformOperation::apply):
        (ScaleTransformOperation):
        * platform/graphics/transforms/SkewTransformOperation.cpp:
        (WebCore::SkewTransformOperation::blend):
        * platform/graphics/transforms/SkewTransformOperation.h:
        (WebCore::SkewTransformOperation::apply):
        (SkewTransformOperation):
        * platform/graphics/transforms/TransformOperation.h:
        (TransformOperation):
        * platform/graphics/transforms/TransformOperations.cpp:
        (WebCore::TransformOperations::blendByMatchingOperations):
        (WebCore::TransformOperations::blendByUsingMatrixInterpolation):
        (WebCore::TransformOperations::blend):
        * platform/graphics/transforms/TransformOperations.h:
        (WebCore::TransformOperations::apply):
        (TransformOperations):
        * platform/graphics/transforms/TranslateTransformOperation.cpp:
        (WebCore::TranslateTransformOperation::blend):
        * platform/graphics/transforms/TranslateTransformOperation.h:
        (WebCore::TranslateTransformOperation::x):
        (WebCore::TranslateTransformOperation::y):
        (WebCore::TranslateTransformOperation::z):
        (WebCore::TranslateTransformOperation::isIdentity):
        (WebCore::TranslateTransformOperation::apply):
        (TranslateTransformOperation):
        * rendering/AutoTableLayout.cpp:
        (WebCore::AutoTableLayout::layout):
        * rendering/ClipPathOperation.h:
        (WebCore::ShapeClipPathOperation::path):
        * rendering/ExclusionShape.cpp:
        (WebCore::ExclusionShape::createExclusionShape):
        * rendering/ExclusionShape.h:
        (ExclusionShape):
        * rendering/ExclusionShapeInfo.cpp:
        (WebCore::::computedShape):
        * rendering/FilterEffectRenderer.cpp:
        (WebCore::FilterEffectRenderer::build):
        * rendering/FixedTableLayout.cpp:
        (WebCore::FixedTableLayout::layout):
        * rendering/RenderBlock.cpp:
        (WebCore::RenderBlock::textIndentOffset):
        (WebCore::RenderBlock::computeInlinePreferredLogicalWidths):
        * rendering/RenderBox.cpp:
        (WebCore::RenderBox::reflectionOffset):
        (WebCore::RenderBox::paintBoxDecorations):
        (WebCore::RenderBox::pushContentsClip):
        (WebCore::RenderBox::clipRect):
        (WebCore::RenderBox::computeLogicalWidthInRegion):
        (WebCore::RenderBox::fillAvailableMeasure):
        (WebCore::RenderBox::computeLogicalWidthInRegionUsing):
        (WebCore::RenderBox::computeInlineDirectionMargins):
        (WebCore::RenderBox::computeContentAndScrollbarLogicalHeightUsing):
        (WebCore::RenderBox::computeReplacedLogicalWidthUsing):
        (WebCore::RenderBox::computeReplacedLogicalHeightUsing):
        (WebCore::RenderBox::computeBlockDirectionMargins):
        (WebCore::RenderBox::computePositionedLogicalWidthUsing):
        (WebCore::RenderBox::computePositionedLogicalHeightUsing):
        (WebCore::RenderBox::computePositionedLogicalWidthReplaced):
        (WebCore::RenderBox::computePositionedLogicalHeightReplaced):
        * rendering/RenderBoxModelObject.cpp:
        (WebCore::RenderBoxModelObject::relativePositionOffset):
        (WebCore::RenderBoxModelObject::computeStickyPositionConstraints):
        (WebCore::RenderBoxModelObject::computedCSSPadding):
        (WebCore::RenderBoxModelObject::getBackgroundRoundedRect):
        (WebCore::RenderBoxModelObject::backgroundRoundedRectAdjustedForBleedAvoidance):
        (WebCore::RenderBoxModelObject::paintFillLayerExtended):
        (WebCore::RenderBoxModelObject::calculateFillTileSize):
        (WebCore::RenderBoxModelObject::calculateBackgroundImageGeometry):
        (WebCore::computeBorderImageSide):
        (WebCore::RenderBoxModelObject::paintNinePieceImage):
        (WebCore::RenderBoxModelObject::paintBorder):
        (WebCore::RenderBoxModelObject::drawBoxSideFromPath):
        (WebCore::RenderBoxModelObject::paintBoxShadow):
        * rendering/RenderFlexibleBox.cpp:
        (WebCore::RenderFlexibleBox::computeMainAxisExtentForChild):
        (WebCore::RenderFlexibleBox::computeChildMarginValue):
        * rendering/RenderGrid.cpp:
        (WebCore::RenderGrid::computeUsedBreadthOfSpecifiedLength):
        * rendering/RenderInline.cpp:
        (WebCore::computeMargin):
        * rendering/RenderLayer.cpp:
        (WebCore::RenderLayer::updateTransform):
        (WebCore::RenderLayer::currentTransform):
        (WebCore::RenderLayer::perspectiveTransform):
        (WebCore::RenderLayer::perspectiveOrigin):
        (WebCore::RenderLayer::clipToRect):
        (WebCore::RenderLayer::paintLayerContents):
        * rendering/RenderLayerBacking.cpp:
        (WebCore::RenderLayerBacking::updateTransform):
        (WebCore::RenderLayerBacking::computeTransformOrigin):
        (WebCore::RenderLayerBacking::computePerspectiveOrigin):
        (WebCore::RenderLayerBacking::startAnimation):
        (WebCore::RenderLayerBacking::startTransition):
        * rendering/RenderMarquee.cpp:
        (WebCore::RenderMarquee::timerFired):
        * rendering/RenderMenuList.cpp:
        (WebCore::RenderMenuList::updateOptionsWidth):
        * rendering/RenderObject.cpp:
        (WebCore::RenderObject::repaintAfterLayoutIfNeeded):
        (WebCore::optionalViewportSize):
        (WebCore):
        (WebCore::RenderObject::minimumIntValueForLength):
        (WebCore::RenderObject::intValueForLength):
        (WebCore::RenderObject::minimumValueForLength):
        (WebCore::RenderObject::valueForLength):
        (WebCore::RenderObject::floatValueForLength):
        * rendering/RenderObject.h:
        (RenderObject):
        * rendering/RenderReplaced.cpp:
        (WebCore::RenderReplaced::paint):
        * rendering/RenderScrollbarPart.cpp:
        (WebCore::calcScrollbarThicknessUsing):
        (WebCore::RenderScrollbarPart::computeScrollbarWidth):
        (WebCore::RenderScrollbarPart::computeScrollbarHeight):
        * rendering/RenderTable.cpp:
        (WebCore::RenderTable::updateLogicalWidth):
        (WebCore::RenderTable::convertStyleLogicalWidthToComputedWidth):
        (WebCore::RenderTable::convertStyleLogicalHeightToComputedHeight):
        * rendering/RenderTableCell.h:
        (WebCore::RenderTableCell::logicalHeightForRowSizing):
        * rendering/RenderTableSection.cpp:
        (WebCore::RenderTableSection::calcRowLogicalHeight):
        * rendering/RenderText.h:
        (WebCore::RenderText::marginLeft):
        (WebCore::RenderText::marginRight):
        * rendering/RenderThemeMacShared.mm:
        (WebCore::RenderThemeMacShared::paintMenuListButtonGradients):
        * rendering/RenderWidget.cpp:
        (WebCore::RenderWidget::paint):
        * rendering/RootInlineBox.cpp:
        (WebCore::RootInlineBox::verticalPositionForBox):
        * rendering/style/BasicShapes.cpp:
        (WebCore::BasicShapeRectangle::path):
        (WebCore::BasicShapeCircle::path):
        (WebCore::BasicShapeEllipse::path):
        (WebCore::BasicShapePolygon::path):
        * rendering/style/BasicShapes.h:
        (BasicShapeRectangle):
        (BasicShapeCircle):
        (BasicShapeEllipse):
        (BasicShapePolygon):
        * rendering/style/RenderStyle.cpp:
        (WebCore::RenderStyle::applyTransform):
        (WebCore::calcRadiiFor):
        (WebCore::RenderStyle::getRoundedBorderFor):
        (WebCore::RenderStyle::getRoundedInnerBorderFor):
        (WebCore::RenderStyle::computedLineHeight):
        * rendering/style/RenderStyle.h:
        * rendering/svg/RenderSVGRoot.cpp:
        (WebCore::resolveLengthAttributeForSVG):
        (WebCore::RenderSVGRoot::computeReplacedLogicalWidth):
        (WebCore::RenderSVGRoot::computeReplacedLogicalHeight):
        * rendering/svg/SVGRenderingContext.cpp:
        (WebCore::SVGRenderingContext::prepareToRenderSVGContent):
        * svg/SVGSVGElement.cpp:
        (WebCore::SVGSVGElement::currentViewBoxRect):
        (WebCore::SVGSVGElement::currentViewportSize):
        * svg/SVGStyledTransformableElement.cpp:
        (WebCore::SVGStyledTransformableElement::animatedLocalTransform):
        * svg/SVGTextElement.cpp:
        (WebCore::SVGTextElement::animatedLocalTransform):
        * svg/graphics/SVGImage.cpp:
        (WebCore::SVGImage::computeIntrinsicDimensions):

2013-03-10  Andreas Kling  <akling@apple.com>

        SVGDocumentExtensions should use OwnPtr for pending resource maps.



2013-03-11  Timothy Loh  <timloh@chromium.org>

        viewport units (vw, vh) don't work in CSS transforms
        https://bugs.webkit.org/show_bug.cgi?id=91554

        Reviewed by NOBODY (OOPS!).

        * tests/AnimationTranslationUtilTest.cpp:
        (WebKit::animationCanBeTranslated):

2013-03-09  Sadrul Habib Chowdhury  <sadrul@chromium.org>

        [chromium] Remove deprecated flingStart.sourceDevice from WebGestureEvent

Lines 246-252 static AtkAttributeSet* getAttributeSetForAccessibilityObject(const Accessibilit a/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.cpp_sec1
- a/Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.cpp -1 / +1 lines
246	}	246	}
247		247
248	if (!style->textIndent().isUndefined()) {	248	if (!style->textIndent().isUndefined()) {
249	int indentation = valueForLength(style->textIndent(), object->size().width(), renderer->view());	249	int indentation = renderer->valueForLength(style->textIndent(), object->size().width(), renderer);
250	buffer.set(g_strdup_printf("%i", indentation));	250	buffer.set(g_strdup_printf("%i", indentation));
251	result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_INDENT), buffer.get());	251	result = addToAtkAttributeSet(result, atk_text_attribute_get_name(ATK_TEXT_ATTR_INDENT), buffer.get());
252	}	252	}

Lines 31-36 a/Source/WebCore/css/CSSCalculationValue.cpp_sec1
- a/Source/WebCore/css/CSSCalculationValue.cpp -8 / +13 lines
31	#include "config.h"	31	#include "config.h"
32	#include "CSSCalculationValue.h"	32	#include "CSSCalculationValue.h"
33		33
		34	#include "CSSPrimitiveValueMappings.h"
34	#include "CSSValueList.h"	35	#include "CSSValueList.h"
35	#include "Length.h"	36	#include "Length.h"
36	#include "StyleResolver.h"	37	#include "StyleResolver.h"
Lines 68-73 static CalculationCategory unitCategory(CSSPrimitiveValue::UnitTypes type) a/Source/WebCore/css/CSSCalculationValue.cpp_sec2
68	case CSSPrimitiveValue::CSS_PC:	69	case CSSPrimitiveValue::CSS_PC:
69	case CSSPrimitiveValue::CSS_REMS:	70	case CSSPrimitiveValue::CSS_REMS:
70	case CSSPrimitiveValue::CSS_CHS:	71	case CSSPrimitiveValue::CSS_CHS:
		72	case CSSPrimitiveValue::CSS_VW:
		73	case CSSPrimitiveValue::CSS_VH:
		74	case CSSPrimitiveValue::CSS_VMIN:
		75	case CSSPrimitiveValue::CSS_VMAX:
71	return CalcLength;	76	return CalcLength;
72	#if ENABLE(CSS_VARIABLES)	77	#if ENABLE(CSS_VARIABLES)
73	case CSSPrimitiveValue::CSS_VARIABLE_NAME:	78	case CSSPrimitiveValue::CSS_VARIABLE_NAME:
Lines 128-136 double CSSCalcValue::doubleValue() const a/Source/WebCore/css/CSSCalculationValue.cpp_sec3
128	return clampToPermittedRange(m_expression->doubleValue());	133	return clampToPermittedRange(m_expression->doubleValue());
129	}	134	}
130		135
131	double CSSCalcValue::computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, double multiplier, bool computingFontSize) const	136	double CSSCalcValue::computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, const IntSize& viewportSize, double multiplier, bool computingFontSize) const
132	{	137	{
133	return clampToPermittedRange(m_expression->computeLengthPx(currentStyle, rootStyle, multiplier, computingFontSize));	138	return clampToPermittedRange(m_expression->computeLengthPx(currentStyle, rootStyle, viewportSize, multiplier, computingFontSize));
134	}	139	}
135		140
136	CSSCalcExpressionNode::~CSSCalcExpressionNode()	141	CSSCalcExpressionNode::~CSSCalcExpressionNode()
Lines 174-180 public: a/Source/WebCore/css/CSSCalculationValue.cpp_sec4
174	case CalcNumber:	179	case CalcNumber:
175	return adoptPtr(new CalcExpressionNumber(m_value->getFloatValue()));	180	return adoptPtr(new CalcExpressionNumber(m_value->getFloatValue()));
176	case CalcLength:	181	case CalcLength:
177	return adoptPtr(new CalcExpressionNumber(m_value->computeLength<float>(style, rootStyle, zoom)));	182	return adoptPtr(new CalcExpressionLength(m_value->convertToLength<AnyConversion & ~FixedIntegerConversion>(style, rootStyle, zoom)));
178	case CalcPercent:	183	case CalcPercent:
179	case CalcPercentLength:	184	case CalcPercentLength:
180	return adoptPtr(new CalcExpressionLength(StyleResolver::convertToFloatLength(m_value.get(), style, rootStyle, zoom)));	185	return adoptPtr(new CalcExpressionLength(StyleResolver::convertToFloatLength(m_value.get(), style, rootStyle, zoom)));
Lines 209-219 public: a/Source/WebCore/css/CSSCalculationValue.cpp_sec5
209	return 0;	214	return 0;
210	}	215	}
211		216
212	virtual double computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, double multiplier, bool computingFontSize) const	217	virtual double computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, const IntSize& viewportSize, double multiplier, bool computingFontSize) const
213	{	218	{
214	switch (m_category) {	219	switch (m_category) {
215	case CalcLength:	220	case CalcLength:
216	return m_value->computeLength<double>(currentStyle, rootStyle, multiplier, computingFontSize);	221	return m_value->computeLength<double>(currentStyle, rootStyle, viewportSize, multiplier, computingFontSize);
217	case CalcPercent:	222	case CalcPercent:
218	case CalcNumber:	223	case CalcNumber:
219	return m_value->getDoubleValue();	224	return m_value->getDoubleValue();
Lines 330-339 public: a/Source/WebCore/css/CSSCalculationValue.cpp_sec6
330	return evaluate(m_leftSide->doubleValue(), m_rightSide->doubleValue());	335	return evaluate(m_leftSide->doubleValue(), m_rightSide->doubleValue());
331	}	336	}
332		337
333	virtual double computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, double multiplier, bool computingFontSize) const	338	virtual double computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, const IntSize& viewportSize, double multiplier, bool computingFontSize) const
334	{	339	{
335	const double leftValue = m_leftSide->computeLengthPx(currentStyle, rootStyle, multiplier, computingFontSize);	340	const double leftValue = m_leftSide->computeLengthPx(currentStyle, rootStyle, viewportSize, multiplier, computingFontSize);
336	const double rightValue = m_rightSide->computeLengthPx(currentStyle, rootStyle, multiplier, computingFontSize);	341	const double rightValue = m_rightSide->computeLengthPx(currentStyle, rootStyle, viewportSize, multiplier, computingFontSize);
337	return evaluate(leftValue, rightValue);	342	return evaluate(leftValue, rightValue);
338	}	343	}
339		344



    virtual bool isZero() const = 0;
    virtual PassOwnPtr<CalcExpressionNode> toCalcValue(RenderStyle*, RenderStyle* rootStyle, double zoom = 1.0) const = 0;    
    virtual double doubleValue() const = 0;
    virtual double computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, const IntSize& viewportSize, double multiplier = 1.0, bool computingFontSize = false) const = 0;
    virtual String customCssText() const = 0;
#if ENABLE(CSS_VARIABLES)
    virtual String serializeResolvingVariables(const HashMap<AtomicString, String>&) const = 0;

    bool isInt() const { return m_expression->isInteger(); }    
    double doubleValue() const;
    bool isNegative() const { return m_expression->doubleValue() < 0; }
    double computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, const IntSize& viewportSize, double multiplier = 1.0, bool computingFontSize = false) const;
        
    String customCssText() const;
    bool equals(const CSSCalcValue&) const;



    return positionList.release();
}

static PassRefPtr<CSSValue> getPositionOffsetValue(RenderStyle* style, CSSPropertyID propertyID, const IntSize& viewportSize)
{
    if (!style)
        return 0;

        if (l.type() == WebCore::Fixed)
            return zoomAdjustedPixelValue(l.value(), style);
        else if (l.isViewportPercentage())
            return zoomAdjustedPixelValue(valueForLength(l, 0, viewportSize), style);
        return cssValuePool().createValue(l);
    }


    return cssValuePool().createColorValue(color.rgb());
}

static PassRefPtr<CSSValueList> getBorderRadiusCornerValues(LengthSize radius, const RenderStyle* style, const IntSize& viewportSize)
{
    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
    if (radius.width().type() == Percent)
        list->append(cssValuePool().createValue(radius.width().percent(), CSSPrimitiveValue::CSS_PERCENTAGE));
    else
        list->append(zoomAdjustedPixelValue(valueForLength(radius.width(), 0, viewportSize), style));
    if (radius.height().type() == Percent)
        list->append(cssValuePool().createValue(radius.height().percent(), CSSPrimitiveValue::CSS_PERCENTAGE));
    else
        list->append(zoomAdjustedPixelValue(valueForLength(radius.height(), 0, viewportSize), style));
    return list.release();
}

static PassRefPtr<CSSValue> getBorderRadiusCornerValue(LengthSize radius, const RenderStyle* style, const IntSize& viewportSize)
{
    if (radius.width() == radius.height()) {
        if (radius.width().type() == Percent)
            return cssValuePool().createValue(radius.width().percent(), CSSPrimitiveValue::CSS_PERCENTAGE);
        return zoomAdjustedPixelValue(valueForLength(radius.width(), 0, viewportSize), style);
    }
    return getBorderRadiusCornerValues(radius, style, viewportSize);
}

static PassRefPtr<CSSValueList> getBorderRadiusShorthandValue(const RenderStyle* style, const IntSize& viewportSize)
{
    RefPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
    bool showHorizontalBottomLeft = style->borderTopRightRadius().width() != style->borderBottomLeftRadius().width();

    bool showVerticalTopRight = (style->borderTopRightRadius().height() != style->borderTopLeftRadius().height()) || showVerticalBottomRight;
    bool showVerticalTopLeft = (style->borderTopLeftRadius().width() != style->borderTopLeftRadius().height());

    RefPtr<CSSValueList> topLeftRadius = getBorderRadiusCornerValues(style->borderTopLeftRadius(), style, viewportSize);
    RefPtr<CSSValueList> topRightRadius = getBorderRadiusCornerValues(style->borderTopRightRadius(), style, viewportSize);
    RefPtr<CSSValueList> bottomRightRadius = getBorderRadiusCornerValues(style->borderBottomRightRadius(), style, viewportSize);
    RefPtr<CSSValueList> bottomLeftRadius = getBorderRadiusCornerValues(style->borderBottomLeftRadius(), style, viewportSize);

    RefPtr<CSSValueList> horizontalRadii = CSSValueList::createSpaceSeparated();
    horizontalRadii->append(topLeftRadius->item(0));

        box = pixelSnappedIntRect(toRenderBox(renderer)->borderBoxRect());

    TransformationMatrix transform;
    style->applyTransform(transform, box.size(), renderer, RenderStyle::ExcludeTransformOrigin);
    // Note that this does not flatten to an affine transform if ENABLE(3D_RENDERING) is off, by design.

    // FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)

{
    IntSize size = renderer ? pixelSnappedIntRect(toRenderBox(renderer)->borderBoxRect()).size() : IntSize();
    TransformationMatrix transform;
    transformParameter->applyTransform(transform, size, renderer->view()->viewportSize());
    // FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)
    return matrixTransformValue(transform, style);
}

}
#endif

static PassRefPtr<CSSValue> valueForGridTrackBreadth(const Length& trackBreadth, const RenderStyle* style, const IntSize& viewportSize)
{
    if (trackBreadth.isAuto())
        return cssValuePool().createIdentifierValue(CSSValueAuto);
    if (trackBreadth.isViewportPercentage())
        return zoomAdjustedPixelValue(valueForLength(trackBreadth, 0, viewportSize), style);
    return zoomAdjustedPixelValueForLength(trackBreadth, style);
}

static PassRefPtr<CSSValue> valueForGridTrackMinMax(const GridTrackSize& trackSize, const RenderStyle* style, const IntSize& viewportSize)
{
    switch (trackSize.type()) {
    case LengthTrackSizing:
        return valueForGridTrackBreadth(trackSize.length(), style, viewportSize);
    case MinMaxTrackSizing:
        RefPtr<CSSValueList> minMaxTrackBreadths = CSSValueList::createCommaSeparated();
        minMaxTrackBreadths->append(valueForGridTrackBreadth(trackSize.minTrackBreadth(), style, viewportSize));
        minMaxTrackBreadths->append(valueForGridTrackBreadth(trackSize.maxTrackBreadth(), style, viewportSize));
        return CSSFunctionValue::create("minmax(", minMaxTrackBreadths);
    }
    ASSERT_NOT_REACHED();
    return 0;
}

static PassRefPtr<CSSValue> valueForGridTrackGroup(const Vector<GridTrackSize>& trackSizes, const RenderStyle* style, const IntSize& viewportSize)
{
    RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
    for (size_t i = 0; i < trackSizes.size(); ++i)
        list->append(valueForGridTrackMinMax(trackSizes[i], style, viewportSize));
    return list.release();
}

static PassRefPtr<CSSValue> valueForGridTrackList(const Vector<GridTrackSize>& trackSizes, const RenderStyle* style, const IntSize& viewportSize)
{
    // Handle the 'none' case here.
    if (!trackSizes.size())
        return cssValuePool().createIdentifierValue(CSSValueNone);

    return valueForGridTrackGroup(trackSizes, style, viewportSize);
}

static PassRefPtr<CSSValue> valueForGridPosition(const GridPosition& position)

    return list.release();
}

static PassRefPtr<CSSPrimitiveValue> lineHeightFromStyle(RenderStyle* style, const IntSize& viewportSize)
{
    Length length = style->lineHeight();
    if (length.isNegative())

        // On the other hand, since font-size doesn't include the zoom factor, we really can't do
        // that here either.
        return zoomAdjustedPixelValue(static_cast<int>(length.percent() * style->fontDescription().specifiedSize()) / 100, style);
    return zoomAdjustedPixelValue(valueForLength(length, 0, viewportSize), style);
}

static PassRefPtr<CSSPrimitiveValue> fontSizeFromStyle(RenderStyle* style)

        case CSSPropertyBorderLeftWidth:
            return zoomAdjustedPixelValue(style->borderLeftWidth(), style.get());
        case CSSPropertyBottom:
            return getPositionOffsetValue(style.get(), CSSPropertyBottom, m_node->document()->viewportSize());
        case CSSPropertyWebkitBoxAlign:
            return cssValuePool().createValue(style->boxAlign());
#if ENABLE(CSS_BOX_DECORATION_BREAK)

            computedFont->variant = fontVariantFromStyle(style.get());
            computedFont->weight = fontWeightFromStyle(style.get());
            computedFont->size = fontSizeFromStyle(style.get());
            computedFont->lineHeight = lineHeightFromStyle(style.get(), m_node->document()->viewportSize());
            computedFont->family = fontFamilyFromStyle(style.get());
            return computedFont.release();
        }

        case CSSPropertyWebkitGridAutoFlow:
            return cssValuePool().createValue(style->gridAutoFlow());
        case CSSPropertyWebkitGridColumns:
            return valueForGridTrackList(style->gridColumns(), style.get(), m_node->document()->viewportSize());
        case CSSPropertyWebkitGridRows:
            return valueForGridTrackList(style->gridRows(), style.get(), m_node->document()->viewportSize());

        case CSSPropertyWebkitGridStart:
            return valueForGridPosition(style->gridItemStart());

            return cssValuePool().createValue(style->imageResolution(), CSSPrimitiveValue::CSS_DPPX);
#endif
        case CSSPropertyLeft:
            return getPositionOffsetValue(style.get(), CSSPropertyLeft, m_node->document()->viewportSize());
        case CSSPropertyLetterSpacing:
            if (!style->letterSpacing())
                return cssValuePool().createIdentifierValue(CSSValueNormal);

                return cssValuePool().createIdentifierValue(CSSValueNone);
            return cssValuePool().createValue(style->lineClamp().value(), style->lineClamp().isPercentage() ? CSSPrimitiveValue::CSS_PERCENTAGE : CSSPrimitiveValue::CSS_NUMBER);
        case CSSPropertyLineHeight:
            return lineHeightFromStyle(style.get(), m_node->document()->viewportSize());
        case CSSPropertyListStyleImage:
            if (style->listStyleImage())
                return style->listStyleImage()->cssValue();

                // RenderBox gives a marginRight() that is the distance between the right-edge of the child box
                // and the right-edge of the containing box, when display == BLOCK. Let's calculate the absolute
                // value of the specified margin-right % instead of relying on RenderBox's marginRight() value.
                value = renderer->minimumValueForLength(marginRight, toRenderBox(renderer)->containingBlockLogicalWidthForContent());
            else
                value = toRenderBox(renderer)->marginRight();
            return zoomAdjustedPixelValue(value, style.get());

        case CSSPropertyPosition:
            return cssValuePool().createValue(style->position());
        case CSSPropertyRight:
            return getPositionOffsetValue(style.get(), CSSPropertyRight, m_node->document()->viewportSize());
        case CSSPropertyWebkitRubyPosition:
            return cssValuePool().createValue(style->rubyPosition());
        case CSSPropertyTableLayout:

        case CSSPropertyTextTransform:
            return cssValuePool().createValue(style->textTransform());
        case CSSPropertyTop:
            return getPositionOffsetValue(style.get(), CSSPropertyTop, m_node->document()->viewportSize());
        case CSSPropertyUnicodeBidi:
            return cssValuePool().createValue(style->unicodeBidi());
        case CSSPropertyVerticalAlign:

                if (renderer->isBox())
                    box = toRenderBox(renderer)->borderBoxRect();

                list->append(zoomAdjustedPixelValue(renderer->minimumValueForLength(style->perspectiveOriginX(), box.width()), style.get()));
                list->append(zoomAdjustedPixelValue(renderer->minimumValueForLength(style->perspectiveOriginY(), box.height()), style.get()));
                list->append(zoomAdjustedPixelValue(minimumValueForLength(style->perspectiveOriginY(), box.height(), renderView), style.get()));
            }
            else {
                list->append(zoomAdjustedPixelValueForLength(style->perspectiveOriginX(), style.get()));

        case CSSPropertyWebkitUserSelect:
            return cssValuePool().createValue(style->userSelect());
        case CSSPropertyBorderBottomLeftRadius:
            return getBorderRadiusCornerValue(style->borderBottomLeftRadius(), style.get(), m_node->document()->viewportSize());
        case CSSPropertyBorderBottomRightRadius:
            return getBorderRadiusCornerValue(style->borderBottomRightRadius(), style.get(), m_node->document()->viewportSize());
        case CSSPropertyBorderTopLeftRadius:
            return getBorderRadiusCornerValue(style->borderTopLeftRadius(), style.get(), m_node->document()->viewportSize());
        case CSSPropertyBorderTopRightRadius:
            return getBorderRadiusCornerValue(style->borderTopRightRadius(), style.get(), m_node->document()->viewportSize());
        case CSSPropertyClip: {
            if (!style->hasClip())
                return cssValuePool().createIdentifierValue(CSSValueAuto);

                if (renderer->isBox())
                    box = toRenderBox(renderer)->borderBoxRect();

                list->append(zoomAdjustedPixelValue(renderer->minimumValueForLength(style->transformOriginX(), box.width()), style.get()));
                list->append(zoomAdjustedPixelValue(renderer->minimumValueForLength(style->transformOriginY(), box.height()), style.get()));
                list->append(zoomAdjustedPixelValue(minimumValueForLength(style->transformOriginY(), box.height(), renderView), style.get()));
                if (style->transformOriginZ() != 0)
                    list->append(zoomAdjustedPixelValue(style->transformOriginZ(), style.get()));
            } else {

        case CSSPropertyBorderImage:
            return valueForNinePieceImage(style->borderImage());
        case CSSPropertyBorderRadius:
            return getBorderRadiusShorthandValue(style.get(), m_node->document()->viewportSize());
        case CSSPropertyBorderRight:
            return getCSSPropertyValuesForShorthandProperties(borderRightShorthand());
        case CSSPropertyBorderStyle:



#include "IntSizeHash.h"
#include "NodeRenderStyle.h"
#include "RenderObject.h"
#include "RenderView.h"
#include "StyleResolver.h"
#include "WebCoreMemoryInstrumentation.h"
#include <wtf/MemoryInstrumentationVector.h>

    }

    size_t numStops = m_stops.size();
    const IntSize& viewportSize = renderer->view()->viewportSize();

    Vector<GradientStop> stops(numStops);


                }
                float length;
                if (stop.m_position->isLength())
                    length = stop.m_position->computeLength<float>(style, rootStyle, viewportSize, style->effectiveZoom());
                else 
                    length = stop.m_position->cssCalcValue()->toCalcValue(style, rootStyle, style->effectiveZoom())->evaluate(gradientLength, viewportSize);
                stops[i].offset = (gradientLength > 0) ? length / gradientLength : 0;
            } else {
                ASSERT_NOT_REACHED();

    gradient->setStopsSorted(true);
}

static float positionFromValue(CSSPrimitiveValue* value, RenderStyle* style, RenderStyle* rootStyle, const IntSize& size, bool isHorizontal, const IntSize& viewportSize)
{
    float zoomFactor = style->effectiveZoom();


        return value->getFloatValue() / 100.f * edgeDistance;

    if (value->isCalculatedPercentageWithLength())
        return value->cssCalcValue()->toCalcValue(style, rootStyle, style->effectiveZoom())->evaluate(edgeDistance, viewportSize);

    switch (value->getIdent()) {
    case CSSValueTop:

        return size.width();
    }

    return value->computeLength<float>(style, rootStyle, viewportSize, zoomFactor);
}

FloatPoint CSSGradientValue::computeEndPoint(CSSPrimitiveValue* horizontal, CSSPrimitiveValue* vertical, RenderStyle* style, RenderStyle* rootStyle, const IntSize& size, const IntSize& viewportSize)
{
    FloatPoint result;

    if (horizontal)
        result.setX(positionFromValue(horizontal, style, rootStyle, size, true, viewportSize));

    if (vertical)
        result.setY(positionFromValue(vertical, style, rootStyle, size, false, viewportSize));

    return result;
}

        float angle = m_angle->getFloatValue(CSSPrimitiveValue::CSS_DEG);
        endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
    } else {
        const IntSize& viewportSize = renderer->view()->viewportSize();
        switch (m_gradientType) {
        case CSSDeprecatedLinearGradient:
            firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size, viewportSize);
            if (m_secondX || m_secondY)
                secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), renderer->style(), rootStyle, size, viewportSize);
            else {
                if (m_firstX)
                    secondPoint.setX(size.width() - firstPoint.x());

            }
            break;
        case CSSPrefixedLinearGradient:
            firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size, viewportSize);
            if (m_firstX)
                secondPoint.setX(size.width() - firstPoint.x());
            if (m_firstY)

                float angle = 90 - rad2deg(atan2(rise, run));
                endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
            } else if (m_firstX || m_firstY) { 
                secondPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size, viewportSize);
                if (m_firstX)
                    firstPoint.setX(size.width() - secondPoint.x());
                if (m_firstY)

    return result.toString();
}

float CSSRadialGradientValue::resolveRadius(CSSPrimitiveValue* radius, RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float* widthOrHeight)
{
    float zoomFactor = style->effectiveZoom();


    else if (widthOrHeight && radius->isPercentage())
        result = *widthOrHeight * radius->getFloatValue() / 100;
    else
        result = radius->computeLength<float>(style, rootStyle, viewportSize, zoomFactor);

    return result;
}

    ASSERT(!size.isEmpty());

    RenderStyle* rootStyle = renderer->document()->documentElement()->renderStyle();
    const IntSize& viewportSize = renderer->view()->viewportSize();

    FloatPoint firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size, viewportSize);
    if (!m_firstX)
        firstPoint.setX(size.width() / 2);
    if (!m_firstY)
        firstPoint.setY(size.height() / 2);

    FloatPoint secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), renderer->style(), rootStyle, size, viewportSize);
    if (!m_secondX)
        secondPoint.setX(size.width() / 2);
    if (!m_secondY)


    float firstRadius = 0;
    if (m_firstRadius)
        firstRadius = resolveRadius(m_firstRadius.get(), renderer->style(), rootStyle, viewportSize);

    float secondRadius = 0;
    float aspectRatio = 1; // width / height.
    if (m_secondRadius)
        secondRadius = resolveRadius(m_secondRadius.get(), renderer->style(), rootStyle, viewportSize);
    else if (m_endHorizontalSize) {
        float width = size.width();
        float height = size.height();
        secondRadius = resolveRadius(m_endHorizontalSize.get(), renderer->style(), rootStyle, viewportSize, &width);
        if (m_endVerticalSize)
            aspectRatio = secondRadius / resolveRadius(m_endVerticalSize.get(), renderer->style(), rootStyle, viewportSize, &height);
        else
            aspectRatio = 1;
    } else {



    void addStops(Gradient*, RenderObject*, RenderStyle* rootStyle, float maxLengthForRepeat = 0);

    // Resolve points/radii to front end values.
    FloatPoint computeEndPoint(CSSPrimitiveValue*, CSSPrimitiveValue*, RenderStyle*, RenderStyle* rootStyle, const IntSize&, const IntSize& viewportSize);

    bool isCacheable() const;




    // Resolve points/radii to front end values.
    float resolveRadius(CSSPrimitiveValue*, RenderStyle*, RenderStyle* rootStyle, const IntSize& viewportSize, float* widthOrHeight = 0);

    // These may be null for non-deprecated gradients.
    RefPtr<CSSPrimitiveValue> m_firstRadius;



    }
}

template<> int CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
{
    return roundForImpreciseConversion<int>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize));
}

template<> unsigned CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
{
    return roundForImpreciseConversion<unsigned>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize));
}

template<> Length CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
{
#if ENABLE(SUBPIXEL_LAYOUT)
    return Length(clampTo<float>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize), minValueForCssLength, maxValueForCssLength), Fixed);
#else
    return Length(clampTo<float>(roundForImpreciseConversion<float>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize)), minValueForCssLength, maxValueForCssLength), Fixed);
#endif
}

template<> short CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
{
    return roundForImpreciseConversion<short>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize));
}

template<> unsigned short CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
{
    return roundForImpreciseConversion<unsigned short>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize));
}

template<> float CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
{
    return static_cast<float>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize));
}

template<> double CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
{
    return computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize);
}

double CSSPrimitiveValue::computeLengthDouble(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
{
    if (m_primitiveUnitType == CSS_CALC)
        // The multiplier and factor is applied to each value in the calc expression individually
        return m_value.calc->computeLengthPx(style, rootStyle, viewportSize, multiplier, computingFontSize);
        
    double factor;


            // 1 pc == 12 pt
            factor = cssPixelsPerInch * 12.0 / 72.0;
            break;
        case CSS_VW:
            factor = viewportSize.width() / 100.0;
            break;
        case CSS_VH:
            factor = viewportSize.height() / 100.0;
            break;
        case CSS_VMIN:
            factor = std::min(viewportSize.width(), viewportSize.height()) / 100.0;
            break;
        case CSS_VMAX:
            factor = std::max(viewportSize.width(), viewportSize.height()) / 100.0;
            break;
        case CSS_CALC_PERCENTAGE_WITH_LENGTH:
        case CSS_CALC_PERCENTAGE_WITH_NUMBER:
            ASSERT_NOT_REACHED();

    case CSS_VW:
    case CSS_VH:
    case CSS_VMIN:
    case CSS_VMAX:
    case CSS_DIMENSION:
        return m_value.num == other.m_value.num;
    case CSS_IDENT:



     * this is screen/printer dependent, so we probably need a config option for this,
     * and some tool to calibrate.
     */
    template<typename T> T computeLength(RenderStyle* currStyle, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier = 1.0f, bool computingFontSize = false);

    // Converts to a Length, mapping various unit types appropriately.
    template<int> Length convertToLength(RenderStyle* currStyle, RenderStyle* rootStyle, double multiplier = 1.0, bool computingFontSize = false);

    void init(PassRefPtr<CSSCalcValue>);
    bool getDoubleValueInternal(UnitTypes targetUnitType, double* result) const;

    double computeLengthDouble(RenderStyle* currentStyle, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize);

    union {
        int ident;



#endif
    if ((supported & (FixedIntegerConversion | FixedFloatConversion)) && isFontRelativeLength() && (!style || !rootStyle))
        return Length(Undefined);
    if ((supported & CalculatedConversion) && isCalculated())
        return Length(cssCalcValue()->toCalcValue(style, rootStyle, multiplier));
    if ((supported & FixedIntegerConversion) && isLength())
        return computeLength<Length>(style, rootStyle, IntSize(), multiplier, computingFontSize);
    if ((supported & FixedFloatConversion) && isLength())
        return Length(computeLength<double>(style, rootStyle, IntSize(), multiplier), Fixed);
    if ((supported & PercentConversion) && isPercentage())
        return Length(getDoubleValue(), Percent);
    if ((supported & FractionConversion) && isNumber())
        return Length(getDoubleValue() * 100.0, Percent);
    if ((supported & AutoConversion) && getIdent() == CSSValueAuto)
        return Length(Auto);
    if ((supported & CalculatedConversion) && isCalculated())
        return Length(cssCalcValue()->toCalcValue(style, rootStyle, multiplier));
    if ((supported & ViewportPercentageConversion) && isViewportPercentageLength())
        return viewportPercentageLength();
    return Length(Undefined);




    Length length;
    if (primitiveValue->isLength())
        length = primitiveValue->computeLength<Length>(style(), rootElementStyle(), IntSize(), zoomFactor);
    else if (primitiveValue->isPercentage())
        length = Length(primitiveValue->getDoubleValue(), Percent);
    else if (primitiveValue->isCalculatedPercentageWithLength())


    Length length;
    if (primitiveValue->isLength())
        length = primitiveValue->computeLength<Length>(style(), rootElementStyle(), IntSize(), zoomFactor);
    else if (primitiveValue->isPercentage())
        length = Length(primitiveValue->getDoubleValue(), Percent);
    else if (primitiveValue->isCalculatedPercentageWithLength())

    else if (slices->top()->isPercentage())
        box.m_top = Length(slices->top()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
    else if (slices->top()->getIdent() != CSSValueAuto)
        box.m_top = slices->top()->convertToLength<FixedFloatConversion | ViewportPercentageConversion>(style(), rootElementStyle(), zoom);

    if (slices->right()->isNumber())
        box.m_right = Length(slices->right()->getIntValue(), Relative);
    else if (slices->right()->isPercentage())
        box.m_right = Length(slices->right()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
    else if (slices->right()->getIdent() != CSSValueAuto)
        box.m_right = slices->right()->convertToLength<FixedFloatConversion | ViewportPercentageConversion>(style(), rootElementStyle(), zoom);

    if (slices->bottom()->isNumber())
        box.m_bottom = Length(slices->bottom()->getIntValue(), Relative);
    else if (slices->bottom()->isPercentage())
        box.m_bottom = Length(slices->bottom()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
    else if (slices->bottom()->getIdent() != CSSValueAuto)
        box.m_bottom = slices->bottom()->convertToLength<FixedFloatConversion | ViewportPercentageConversion>(style(), rootElementStyle(), zoom);

    if (slices->left()->isNumber())
        box.m_left = Length(slices->left()->getIntValue(), Relative);
    else if (slices->left()->isPercentage())
        box.m_left = Length(slices->left()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
    else if (slices->left()->getIdent() != CSSValueAuto)
        box.m_left = slices->left()->convertToLength<FixedFloatConversion | ViewportPercentageConversion>(style(), rootElementStyle(), zoom);

    return box;
}




namespace WebCore {

int minimumIntValueForLength(const Length& length, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages)
{
    return static_cast<int>(minimumValueForLength(length, maximumValue, viewportSize, roundPercentages));
}

int intValueForLength(const Length& length, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages)
{
    return static_cast<int>(valueForLength(length, maximumValue, viewportSize, roundPercentages));
}

LayoutUnit minimumValueForLength(const Length& length, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages)
{
    switch (length.type()) {
    case Fixed:

        // Don't remove the extra cast to float. It is needed for rounding on 32-bit Intel machines that use the FPU stack.
        return static_cast<LayoutUnit>(static_cast<float>(maximumValue * length.percent() / 100.0f));
    case Calculated:
        return length.nonNanCalculatedValue(maximumValue, viewportSize);
    case ViewportPercentageWidth:
        return static_cast<LayoutUnit>(viewportSize.width() * length.viewportPercentageLength() / 100.0f);
            return static_cast<LayoutUnit>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
        return 0;
    case ViewportPercentageHeight:
        return static_cast<LayoutUnit>(viewportSize.height() * length.viewportPercentageLength() / 100.0f);
            return static_cast<LayoutUnit>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
        return 0;
    case ViewportPercentageMin:
        return static_cast<LayoutUnit>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
            IntSize viewportSize = renderView->viewportSize();
            return static_cast<LayoutUnit>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
        }
        return 0;
    case ViewportPercentageMax:
        return static_cast<LayoutUnit>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
            IntSize viewportSize = renderView->viewportSize();
            return static_cast<LayoutUnit>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
        }
        return 0;
    case FillAvailable:
    case Auto:
        return 0;

    return 0;
}

LayoutUnit valueForLength(const Length& length, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages)
{
    switch (length.type()) {
    case Fixed:

    case ViewportPercentageHeight:
    case ViewportPercentageMin:
    case ViewportPercentageMax:
        return minimumValueForLength(length, maximumValue, viewportSize, roundPercentages);
    case FillAvailable:
    case Auto:
        return maximumValue;

}

// FIXME: when subpixel layout is supported this copy of floatValueForLength() can be removed. See bug 71143.
float floatValueForLength(const Length& length, LayoutUnit maximumValue, const IntSize& viewportSize)
{
    switch (length.type()) {
    case Fixed:

    case Auto:
        return static_cast<float>(maximumValue);
    case Calculated:
        return length.nonNanCalculatedValue(maximumValue, viewportSize);
    case ViewportPercentageWidth:
        return static_cast<int>(viewportSize.width() * length.viewportPercentageLength() / 100.0f);
            return static_cast<int>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
        return 0;
    case ViewportPercentageHeight:
        return static_cast<float>(viewportSize.height() * length.viewportPercentageLength() / 100.0f);
            return static_cast<int>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
        return 0;
    case ViewportPercentageMin:
        return static_cast<float>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
            IntSize viewportSize = renderView->viewportSize();
            return static_cast<int>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
        }
        return 0;
    case ViewportPercentageMax:
        return static_cast<float>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
            IntSize viewportSize = renderView->viewportSize();
            return static_cast<int>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
        }
        return 0;
    case Relative:
    case Intrinsic:
    case MinIntrinsic:

    return 0;
}

float floatValueForLength(const Length& length, float maximumValue, const IntSize& viewportSize)
{
    switch (length.type()) {
    case Fixed:

    case Auto:
        return static_cast<float>(maximumValue);
    case Calculated:
        return length.nonNanCalculatedValue(maximumValue, viewportSize);
    case ViewportPercentageWidth:
        return static_cast<float>(viewportSize.width() * length.viewportPercentageLength() / 100.0f);
            return static_cast<int>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
        return 0;
    case ViewportPercentageHeight:
        return static_cast<float>(viewportSize.height() * length.viewportPercentageLength() / 100.0f);
            return static_cast<int>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
        return 0;
    case ViewportPercentageMin:
        return static_cast<float>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
            IntSize viewportSize = renderView->viewportSize();
            return static_cast<int>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
        }
        return 0;
    case ViewportPercentageMax:
        return static_cast<float>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
            IntSize viewportSize = renderView->viewportSize();
            return static_cast<int>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
        }
        return 0;
    case Relative:
    case Intrinsic:
    case MinIntrinsic:




namespace WebCore {

class IntSize;
class LayoutUnit;
class RenderView;
struct Length;

int minimumIntValueForLength(const Length&, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages = false);
int intValueForLength(const Length&, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages = false);
LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages = false);
LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages = false);
float floatValueForLength(const Length&, LayoutUnit maximumValue, const IntSize& viewportSize);
float floatValueForLength(const Length&, float maximumValue, const IntSize& viewportSize);

} // namespace WebCore




    return false;
}

static bool computeLength(CSSValue* value, bool strict, RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, int& result)
{
    if (!value->isPrimitiveValue())
        return false;

    }

    if (primitiveValue->isLength()) {
        result = primitiveValue->computeLength<int>(style, rootStyle, viewportSize);
        return true;
    }


        int length;
        long height = sg.height();
        InspectorInstrumentation::applyScreenHeightOverride(frame, &height);
        return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, frame->document()->viewportSize(), length) && compareValue(static_cast<int>(height), length, op);
    }
    // ({,min-,max-}device-height)
    // assume if we have a device, assume non-zero

        int length;
        long width = sg.width();
        InspectorInstrumentation::applyScreenWidthOverride(frame, &width);
        return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, frame->document()->viewportSize(), length) && compareValue(static_cast<int>(width), length, op);
    }
    // ({,min-,max-}device-width)
    // assume if we have a device, assume non-zero

            height = adjustForAbsoluteZoom(height, renderView);
        RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
        int length;
        return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, frame->document()->viewportSize(), length) && compareValue(height, length, op);
    }

    return view->layoutHeight() != 0;

            width = adjustForAbsoluteZoom(width, renderView);
        RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
        int length;
        return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, frame->document()->viewportSize(), length) && compareValue(width, length, op);
    }

    return view->layoutWidth() != 0;



            CSSValue* firstValue = list->itemWithoutBoundsCheck(0);
            if (!firstValue->isShadowValue())
                return;

            ShadowValue* item = static_cast<ShadowValue*>(firstValue);
            const IntSize& viewportSize = state.document()->viewportSize();
            IntPoint location(item->x->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize),
                item->y->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize));
            int blur = item->blur ? item->blur->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize) : 0;
            Color color;
            if (item->color)
                color = colorFromPrimitiveValue(item->color.get());



        else if (valueType == Number)
            setValue(styleResolver->style(), *primitiveValue);
        else if (valueType == ComputeLength)
            setValue(styleResolver->style(), primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), styleResolver->style()->effectiveZoom()));
    }

    static PropertyHandler createHandler() { return PropertyHandler(&applyInheritValue, &applyInitialValue, &applyValue); }

        if (autoEnabled && primitiveValue->getIdent() == CSSValueAuto)
            setValue(styleResolver->style(), Length());
        else if (primitiveValue->isLength()) {
            Length length = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), styleResolver->style()->effectiveZoom());
            length.setQuirk(primitiveValue->isQuirkValue());
            setValue(styleResolver->style(), length);
        } else if (primitiveValue->isPercentage())

        else if (pair->first()->isCalculatedPercentageWithLength())
            radiusWidth = Length((pair->first()->cssCalcValue()->toCalcValue(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom())));
        else
            radiusWidth = pair->first()->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), styleResolver->style()->effectiveZoom());
        if (pair->second()->isPercentage())
            radiusHeight = Length(pair->second()->getDoubleValue(), Percent);
        else if (pair->second()->isViewportPercentageLength())

        else if (pair->second()->isCalculatedPercentageWithLength())
            radiusHeight = Length((pair->second()->cssCalcValue()->toCalcValue(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom())));
        else
            radiusHeight = pair->second()->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), styleResolver->style()->effectiveZoom());
        int width = radiusWidth.value();
        int height = radiusHeight.value();
        if (width < 0 || height < 0)

            length = 5;
        } else if (ident == CSSValueInvalid) {
            float zoom = (svgZoomEnabled && styleResolver->useSVGZoomRules()) ? 1.0f : styleResolver->style()->effectiveZoom();
            const IntSize& viewportSize = styleResolver->document()->viewportSize();

            // Any original result that was >= 1 should not be allowed to fall below 1.
            // This keeps border lines from vanishing.
            length = primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), viewportSize, zoom);
            if (zoom < 1.0f && length < 1.0) {
                T originalLength = primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), viewportSize, 1.0);
                if (originalLength >= 1.0)
                    length = 1.0;
            }

            fontDescription.setIsAbsoluteSize(parentIsAbsoluteSize
                                              || !(primitiveValue->isPercentage() || primitiveValue->isFontRelativeLength()));
            if (primitiveValue->isLength())
                size = primitiveValue->computeLength<float>(styleResolver->parentStyle(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), 1.0, true);
            else if (primitiveValue->isPercentage())
                size = (primitiveValue->getFloatValue() * parentSize) / 100.0f;
            else if (primitiveValue->isCalculatedPercentageWithLength())
                size = primitiveValue->cssCalcValue()->toCalcValue(styleResolver->parentStyle(), styleResolver->rootElementStyle())->evaluate(parentSize, styleResolver->document()->viewportSize());
            else if (primitiveValue->isViewportPercentageLength())
                size = valueForLength(primitiveValue->viewportPercentageLength(), 0, styleResolver->document()->viewportSize());
            else
                return;
        }

            double multiplier = styleResolver->style()->effectiveZoom();
            if (Frame* frame = styleResolver->document()->frame())
                multiplier *= frame->textZoomFactor();
            lineHeight = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), multiplier);
        } else if (primitiveValue->isPercentage()) {
            // FIXME: percentage should not be restricted to an integer here.
            lineHeight = Length((styleResolver->style()->fontSize() * primitiveValue->getIntValue()) / 100, Fixed);


class ApplyPropertyPageSize {
private:
    static Length mmLength(double mm) { return CSSPrimitiveValue::create(mm, CSSPrimitiveValue::CSS_MM)->computeLength<Length>(0, 0, IntSize()); }
    static Length inchLength(double inch) { return CSSPrimitiveValue::create(inch, CSSPrimitiveValue::CSS_IN)->computeLength<Length>(0, 0, IntSize()); }
    static bool getPageSizeFromName(CSSPrimitiveValue* pageSizeName, CSSPrimitiveValue* pageOrientation, Length& width, Length& height)
    {
        DEFINE_STATIC_LOCAL(Length, a5Width, (mmLength(148)));

                // <length>{2}
                if (!second->isLength())
                    return;
                width = first->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize());
                height = second->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize());
            } else {
                // <page-size> <orientation>
                // The value order is guaranteed. See CSSParser::parseSizeParameter.

            if (primitiveValue->isLength()) {
                // <length>
                pageSizeType = PAGE_SIZE_RESOLVED;
                width = height = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize());
            } else {
                switch (primitiveValue->getIdent()) {
                case 0:



            if (!currValue->isShadowValue())
                continue;
            ShadowValue* item = static_cast<ShadowValue*>(currValue);
            const IntSize& viewportSize = state.document()->viewportSize();
            int x = item->x->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize, zoomFactor);
            int y = item->y->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize, zoomFactor);
            int blur = item->blur ? item->blur->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize, zoomFactor) : 0;
            int spread = item->spread ? item->spread->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize, zoomFactor) : 0;
            ShadowStyle shadowStyle = item->style && item->style->getIdent() == CSSValueInset ? Inset : Normal;
            Color color;
            if (item->color)

                result *= 3;
            else if (primitiveValue->getIdent() == CSSValueThick)
                result *= 5;
            width = CSSPrimitiveValue::create(result, CSSPrimitiveValue::CSS_EMS)->computeLength<float>(state.style(), state.rootElementStyle(), IntSize(), zoomFactor);
            break;
        }
        default:
            width = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), state.document()->viewportSize(), zoomFactor);
            break;
        }
        state.style()->setTextStrokeWidth(width);


        float perspectiveValue;
        if (primitiveValue->isLength())
            perspectiveValue = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), IntSize(), zoomFactor);
        else if (primitiveValue->isNumber()) {
            // For backward compatibility, treat valueless numbers as px.
            perspectiveValue = CSSPrimitiveValue::create(primitiveValue->getDoubleValue(), CSSPrimitiveValue::CSS_PX)->computeLength<float>(state.style(), state.rootElementStyle(), IntSize(), zoomFactor);
        } else
            return;


    case CSSPropertyWebkitFilter: {
        HANDLE_INHERIT_AND_INITIAL(filter, Filter);
        FilterOperations operations;
        if (createFilterOperations(value, state.style(), state.rootElementStyle(), state.document()->viewportSize(), operations))
            state.style()->setFilter(operations);
        return;
    }


#endif

bool StyleResolver::createFilterOperations(CSSValue* inValue, RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, FilterOperations& outOperations)
{
    ASSERT(outOperations.isEmpty());
    

                continue;

            ShadowValue* item = static_cast<ShadowValue*>(cssValue);
            IntPoint location(item->x->computeLength<int>(style, rootStyle, viewportSize, zoomFactor),
                              item->y->computeLength<int>(style, rootStyle, viewportSize, zoomFactor));
            int blur = item->blur ? item->blur->computeLength<int>(style, rootStyle, viewportSize, zoomFactor) : 0;
            Color color;
            if (item->color)
                color = colorFromPrimitiveValue(item->color.get());

Lines 304-310 public: a/Source/WebCore/css/StyleResolver.h_sec1
- a/Source/WebCore/css/StyleResolver.h -1 / +1 lines
304	void invalidateMatchedPropertiesCache();	304	void invalidateMatchedPropertiesCache();
305		305
306	#if ENABLE(CSS_FILTERS)	306	#if ENABLE(CSS_FILTERS)
307	bool createFilterOperations(CSSValue* inValue, RenderStyle* inStyle, RenderStyle* rootStyle, FilterOperations& outOperations);	307	bool createFilterOperations(CSSValue* inValue, RenderStyle* inStyle, RenderStyle* rootStyle, const IntSize& viewportSize, FilterOperations& outOperations);
308	#if ENABLE(CSS_SHADERS)	308	#if ENABLE(CSS_SHADERS)
309	StyleShader* styleShader(CSSValue*);	309	StyleShader* styleShader(CSSValue*);
310	StyleShader* cachedOrPendingStyleShaderFromValue(WebKitCSSShaderValue*);	310	StyleShader* cachedOrPendingStyleShaderFromValue(WebKitCSSShaderValue*);

Lines 75-81 void WebKitCSSMatrix::setMatrixValue(const String& string, ExceptionCode& ec) a/Source/WebCore/css/WebKitCSSMatrix.cpp_sec1
- a/Source/WebCore/css/WebKitCSSMatrix.cpp -1 / +1 lines
75	// if a param has a percentage ('%')	75	// if a param has a percentage ('%')
76	TransformationMatrix t;	76	TransformationMatrix t;
77	for (unsigned i = 0; i < operations.operations().size(); ++i) {	77	for (unsigned i = 0; i < operations.operations().size(); ++i) {
78	if (operations.operations()[i].get()->apply(t, IntSize(0, 0))) {	78	if (operations.operations()[i].get()->apply(t, IntSize(), IntSize())) {
79	ec = SYNTAX_ERR;	79	ec = SYNTAX_ERR;
80	return;	80	return;
81	}	81	}



void Document::pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
{
    RefPtr<RenderStyle> style = styleForPage(pageIndex);
    RenderView* view = renderView();

    int width = pageSize.width();
    int height = pageSize.height();

        LengthSize size = style->pageSize();
        ASSERT(size.width().isFixed());
        ASSERT(size.height().isFixed());
        width = renderer()->valueForLength(size.width(), 0);
        height = renderer()->valueForLength(size.height(), 0);
        break;
    }
    default:


    // The percentage is calculated with respect to the width even for margin top and bottom.
    // http://www.w3.org/TR/CSS2/box.html#margin-properties
    marginTop = style->marginTop().isAuto() ? marginTop : renderer()->intValueForLength(style->marginTop(), width);
    marginRight = style->marginRight().isAuto() ? marginRight : renderer()->intValueForLength(style->marginRight(), width);
    marginBottom = style->marginBottom().isAuto() ? marginBottom : renderer()->intValueForLength(style->marginBottom(), width);
    marginLeft = style->marginLeft().isAuto() ? marginLeft : renderer()->intValueForLength(style->marginLeft(), width);
}

void Document::setIsViewSource(bool isViewSource)



    }

    Path path;
    const RenderObject* renderer = document()->renderer();
    switch (shape) {
        case Poly:
            if (m_coordsLen >= 6) {
                int numPoints = m_coordsLen / 2;
                path.moveTo(FloatPoint(renderer->minimumValueForLength(m_coords[0], width), renderer->minimumValueForLength(m_coords[1], height)));
                for (int i = 1; i < numPoints; ++i)
                    path.addLineTo(FloatPoint(renderer->minimumValueForLength(m_coords[i * 2], width), renderer->minimumValueForLength(m_coords[i * 2 + 1], height)));
                path.closeSubpath();
            }
            break;
        case Circle:
            if (m_coordsLen >= 3) {
                Length radius = m_coords[2];
                int r = min(renderer->minimumValueForLength(radius, width), renderer->minimumValueForLength(radius, height));
                path.addEllipse(FloatRect(renderer->minimumValueForLength(m_coords[0], width) - r, renderer->minimumValueForLength(m_coords[1], height) - r, 2 * r, 2 * r));
            }
            break;
        case Rect:
            if (m_coordsLen >= 4) {
                int x0 = renderer->minimumValueForLength(m_coords[0], width);
                int y0 = renderer->minimumValueForLength(m_coords[1], height);
                int x1 = renderer->minimumValueForLength(m_coords[2], width);
                int y1 = renderer->minimumValueForLength(m_coords[3], height);
                path.addRect(FloatRect(x0, y0, x1 - x0, y1 - y0));
            }
            break;



#include "MatrixTransformOperation.h"
#include "RenderBox.h"
#include "RenderStyle.h"
#include "RenderView.h"
#include "StyleCachedImage.h"
#include "StyleGeneratedImage.h"
#include "StylePropertyShorthand.h"

static inline TransformOperations blendFunc(const AnimationBase* anim, const TransformOperations& from, const TransformOperations& to, double progress)
{
    if (anim->isTransformFunctionListValid())
        return to.blendByMatchingOperations(from, progress, anim->renderer()->view()->viewportSize());
    return to.blendByUsingMatrixInterpolation(from, progress, anim->renderer()->isBox() ? toRenderBox(anim->renderer())->borderBoxRect().size() : LayoutSize(), anim->renderer()->view()->viewportSize());
}

static inline PassRefPtr<ClipPathOperation> blendFunc(const AnimationBase*, ClipPathOperation* from, ClipPathOperation* to, double progress)

    ASSERT(toOp);
    if (toOp->blendingNeedsRendererSize()) {
        LayoutSize size = anim->renderer()->isBox() ? toRenderBox(anim->renderer())->borderBoxRect().size() : LayoutSize();
        return toOp->blend(fromOp, progress, size, anim->renderer()->view()->viewportSize(), blendToPassthrough);
    }
    return toOp->blend(fromOp, progress, blendToPassthrough);
}




namespace WebCore {

float CalcExpressionBinaryOperation::evaluate(float maxValue, const IntSize& viewportSize) const
{
    float left = m_leftSide->evaluate(maxValue, viewportSize);
    float right = m_rightSide->evaluate(maxValue, viewportSize);
    switch (m_operator) {
    case CalcAdd:
        return left + right;

    return adoptRef(new CalculationValue(value, range));
}

float CalculationValue::evaluate(float maxValue, const IntSize& viewportSize) const
{
    float result = m_value->evaluate(maxValue, viewportSize);
    // FIXME calc https://webkit.org/b/80411 : result is NaN when there is a division 
    // by zero which isn't found at parse time. 
    if (std::isnan(result))



    {
    }
    
    virtual float evaluate(float maxValue, const IntSize& viewportSize) const = 0;
    virtual bool operator==(const CalcExpressionNode&) const = 0;

    CalcExpressionNodeType type() const { return m_type; }

class CalculationValue : public RefCounted<CalculationValue> {
public:
    static PassRefPtr<CalculationValue> create(PassOwnPtr<CalcExpressionNode> value, CalculationPermittedValueRange);
    float evaluate(float maxValue, const IntSize& viewportSize) const;

    bool operator==(const CalculationValue& o) const 
    { 

        return type() == o.type() && *this == static_cast<const CalcExpressionNumber&>(o);
    }
    
    virtual float evaluate(float, const IntSize&) const 
    {
        return m_value;
    }

        return type() == o.type() && *this == static_cast<const CalcExpressionLength&>(o);
    }
    
    virtual float evaluate(float maxValue, const IntSize& viewportSize) const
    {
        return floatValueForLength(m_length, maxValue, viewportSize);
    }
    
private:

    }
    
    
    virtual float evaluate(float, const IntSize&) const;

private:
    OwnPtr<CalcExpressionNode> m_leftSide;

        return type() == o.type() && *this == static_cast<const CalcExpressionBlendLength&>(o);
    }
    
    virtual float evaluate(float maxValue, const IntSize& viewportSize) const
    {
        return (1.0f - m_progress) * floatValueForLength(m_from, maxValue, viewportSize) + m_progress * floatValueForLength(m_to, maxValue, viewportSize);
    }
    
private:  



    calcLength->deref();
}    

float Length::nonNanCalculatedValue(int maxValue, const IntSize& viewportSize) const
{
    ASSERT(isCalculated());
    float result = calculationValue()->evaluate(maxValue, viewportSize);
    if (std::isnan(result))
        return 0;
    return result;

Lines 260-266 public: a/Source/WebCore/platform/Length.h_sec1
- a/Source/WebCore/platform/Length.h -1 / +1 lines
260	ASSERT(!isUndefined());	260	ASSERT(!isUndefined());
261	return m_isFloat ? m_floatValue : m_intValue;	261	return m_isFloat ? m_floatValue : m_intValue;
262	}	262	}
263	float nonNanCalculatedValue(int maxValue) const;	263	float nonNanCalculatedValue(int maxValue, const IntSize& viewportSize) const;
264		264
265	bool isViewportPercentage() const	265	bool isViewportPercentage() const
266	{	266	{

Lines 336-342 public: a/Source/WebCore/platform/graphics/GraphicsLayer.h_sec1
- a/Source/WebCore/platform/graphics/GraphicsLayer.h -1 / +1 lines
336	// Return true if the animation is handled by the compositing system. If this returns	336	// Return true if the animation is handled by the compositing system. If this returns
337	// false, the animation will be run by AnimationController.	337	// false, the animation will be run by AnimationController.
338	// These methods handle both transitions and keyframe animations.	338	// These methods handle both transitions and keyframe animations.
339	virtual bool addAnimation(const KeyframeValueList&, const IntSize& /boxSize/, const Animation, const String& /animationName/, double /timeOffset*/) { return false; }	339	virtual bool addAnimation(const KeyframeValueList&, const IntSize& /boxSize/, const IntSize& /viewportSize/, const Animation, const String& /animationName/, double /timeOffset*/) { return false; }
340	virtual void pauseAnimation(const String& /animationName/, double /timeOffset/) { }	340	virtual void pauseAnimation(const String& /animationName/, double /timeOffset/) { }
341	virtual void removeAnimation(const String& /animationName/) { }	341	virtual void removeAnimation(const String& /animationName/) { }
342		342



namespace WebCore {

#if ENABLE(CSS_FILTERS)
static inline PassRefPtr<FilterOperation> blendFunc(FilterOperation* fromOp, FilterOperation* toOp, double progress, const IntSize& size, const IntSize& viewportSize, bool blendToPassthrough = false)
{
    ASSERT(toOp);
    if (toOp->blendingNeedsRendererSize())
        return toOp->blend(fromOp, progress, LayoutSize(size.width(), size.height()), viewportSize, blendToPassthrough);

    return toOp->blend(fromOp, progress, blendToPassthrough);
}


static FilterOperations applyFilterAnimation(const FilterOperations* from, const FilterOperations* to, double progress, const IntSize& boxSize, const IntSize& viewportSize)
{
    // First frame of an animation.
    if (!progress)

    for (size_t i = 0; i < size; i++) {
        RefPtr<FilterOperation> fromOp = (i < fromSize) ? from->operations()[i].get() : 0;
        RefPtr<FilterOperation> toOp = (i < toSize) ? to->operations()[i].get() : 0;
        RefPtr<FilterOperation> blendedOp = toOp ? blendFunc(fromOp.get(), toOp.get(), progress, boxSize, viewportSize) : (fromOp ? blendFunc(0, fromOp.get(), progress, boxSize, viewportSize, true) : 0);
        if (blendedOp)
            result.operations().append(blendedOp);
        else {

    return progress;
}

static TransformationMatrix applyTransformAnimation(const TransformOperations* from, const TransformOperations* to, double progress, const IntSize& boxSize, const IntSize& viewportSize, bool listsMatch)
{
    TransformationMatrix matrix;

    // First frame of an animation.
    if (!progress) {
        from->apply(boxSize, viewportSize, matrix);
        return matrix;
    }

    // Last frame of an animation.
    if (progress == 1) {
        to->apply(boxSize, viewportSize, matrix);
        return matrix;
    }

    // If we have incompatible operation lists, we blend the resulting matrices.
    if (!listsMatch) {
        TransformationMatrix fromMatrix;
        to->apply(boxSize, viewportSize, matrix);
        from->apply(boxSize, viewportSize, fromMatrix);
        matrix.blend(fromMatrix, progress);
        return matrix;
    }

    if (!to->size()) {
        TransformOperations blended(*from);
        for (size_t i = 0; i < blended.operations().size(); ++i)
            blended.operations()[i]->blend(0, progress, viewportSize, true)->apply(matrix, viewportSize, boxSize);
        return matrix;
    }


    if (!from->size()) {
        TransformOperations blended(*to);
        for (size_t i = 0; i < blended.operations().size(); ++i)
            blended.operations()[i]->blend(0, 1. - progress, viewportSize, true)->apply(matrix, viewportSize, boxSize);
        return matrix;
    }

    // Normal animation with a matching operation list.
    TransformOperations blended(*to);
    for (size_t i = 0; i < blended.operations().size(); ++i)
        blended.operations()[i]->blend(from->at(i), progress, viewportSize, !from->at(i))->apply(matrix, viewportSize, boxSize);
    return matrix;
}


{
}

void GraphicsLayerAnimation::applyInternal(Client* client, const AnimationValue* from, const AnimationValue* to, float progress, const IntSize& viewportSize)
{
    switch (m_keyframes.property()) {
    case AnimatedPropertyOpacity:
        client->setAnimatedOpacity(applyOpacityAnimation((static_cast<const FloatAnimationValue*>(from)->value()), (static_cast<const FloatAnimationValue*>(to)->value()), progress));
        return;
    case AnimatedPropertyWebkitTransform:
        client->setAnimatedTransform(applyTransformAnimation(static_cast<const TransformAnimationValue*>(from)->value(), static_cast<const TransformAnimationValue*>(to)->value(), progress, m_boxSize, viewportSize, m_listsMatch));
        return;
#if ENABLE(CSS_FILTERS)
    case AnimatedPropertyWebkitFilter:
        client->setAnimatedFilters(applyFilterAnimation(static_cast<const FilterAnimationValue*>(from)->value(), static_cast<const FilterAnimationValue*>(to)->value(), progress, m_boxSize, viewportSize));
        return;
#endif
    default:

    return false;
}

void GraphicsLayerAnimation::apply(Client* client, const IntSize& viewportSize)
{
    if (!isActive())
        return;

    }

    if (!normalizedValue) {
        applyInternal(client, m_keyframes.at(0), m_keyframes.at(1), 0, viewportSize);
        return;
    }

    if (normalizedValue == 1.0) {
        applyInternal(client, m_keyframes.at(m_keyframes.size() - 2), m_keyframes.at(m_keyframes.size() - 1), 1, viewportSize);
        return;
    }
    if (m_keyframes.size() == 2) {
        const TimingFunction* timingFunction = timingFunctionForAnimationValue(m_keyframes.at(0), m_animation.get());
        normalizedValue = applyTimingFunction(timingFunction, normalizedValue, m_animation->duration());
        applyInternal(client, m_keyframes.at(0), m_keyframes.at(1), normalizedValue, viewportSize);
        return;
    }


        normalizedValue = (normalizedValue - from->keyTime()) / (to->keyTime() - from->keyTime());
        const TimingFunction* timingFunction = timingFunctionForAnimationValue(from, m_animation.get());
        normalizedValue = applyTimingFunction(timingFunction, normalizedValue, m_animation->duration());
        applyInternal(client, from, to, normalizedValue, viewportSize);
        break;
    }
}

    }
}

void GraphicsLayerAnimations::apply(GraphicsLayerAnimation::Client* client, const IntSize& viewportSize)
{
    for (size_t i = 0; i < m_animations.size(); ++i)
        m_animations[i].apply(client, viewportSize);
}

GraphicsLayerAnimations GraphicsLayerAnimations::getActiveAnimations() const



        : m_keyframes(AnimatedPropertyInvalid)
    { }
    GraphicsLayerAnimation(const String&, const KeyframeValueList&, const IntSize&, const Animation*, double, bool);
    void apply(Client*, const IntSize& viewportSize);
    void pause(double);
    void resume();
    double computeTotalRunningTime();

    bool listsMatch() const { return m_listsMatch; }

private:
    void applyInternal(Client*, const AnimationValue* from, const AnimationValue* to, float progress, const IntSize& viewportSize);
    KeyframeValueList m_keyframes;
    IntSize m_boxSize;
    RefPtr<Animation> m_animation;

    void pause(const String&, double);
    void suspend(double);
    void resume();
    void apply(GraphicsLayerAnimation::Client*, const IntSize& viewportSize);
    bool isEmpty() const { return m_animations.isEmpty(); }
    size_t size() const { return m_animations.size(); }
    const Vector<GraphicsLayerAnimation>& animations() const { return m_animations; }




namespace WebCore {

PassOwnPtr<WebTransformOperations> toWebTransformOperations(const TransformOperations& transformOperations, const FloatSize& boxSize, const IntSize& viewportSize)
{
    // We need to do a deep copy the transformOperations may contain ref pointers to TransformOperation objects.
    OwnPtr<WebTransformOperations> webTransformOperations = adoptPtr(Platform::current()->compositorSupport()->createTransformOperations());

        case TransformOperation::TRANSLATE_3D:
        case TransformOperation::TRANSLATE: {
            TranslateTransformOperation* transform = static_cast<TranslateTransformOperation*>(transformOperations.operations()[j].get());
            webTransformOperations->appendTranslate(floatValueForLength(transform->x(), boxSize.width(), viewportSize), floatValueForLength(transform->y(), boxSize.height(), viewportSize), floatValueForLength(transform->z(), 1, viewportSize));
            break;
        }
        case TransformOperation::ROTATE_X:

        }
        case TransformOperation::PERSPECTIVE: {
            PerspectiveTransformOperation* transform = static_cast<PerspectiveTransformOperation*>(transformOperations.operations()[j].get());
            webTransformOperations->appendPerspective(floatValueForLength(transform->perspective(), 0, viewportSize));
            break;
        }
        case TransformOperation::IDENTITY:

}

template <class Value, class Keyframe, class Curve>
bool appendKeyframeWithStandardTimingFunction(Curve* curve, double keyTime, const Value* value, const Value* lastValue, WebKit::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize&, const IntSize& viewportSize)
{
    curve->add(Keyframe(keyTime, value->value()), timingFunctionType);
    return true;
}

template <class Value, class Keyframe, class Curve>
bool appendKeyframeWithCustomBezierTimingFunction(Curve* curve, double keyTime, const Value* value, const Value* lastValue, double x1, double y1, double x2, double y2, const FloatSize&, const IntSize& viewportSize)
{
    curve->add(Keyframe(keyTime, value->value()), x1, y1, x2, y2);
    return true;

}

template <>
bool appendKeyframeWithStandardTimingFunction<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(WebTransformAnimationCurve* curve, double keyTime, const TransformAnimationValue* value, const TransformAnimationValue* lastValue, WebKit::WebAnimationCurve::TimingFunctionType timingFunctionType, const FloatSize& boxSize, const IntSize& viewportSize)
{
    bool canBlend = !lastValue;
    OwnPtr<WebTransformOperations> operations(toWebTransformOperations(*value->value(), boxSize, viewportSize));
    if (!operations)
        return false;
    if (!canBlend) {
        OwnPtr<WebTransformOperations> lastOperations(toWebTransformOperations(*lastValue->value(), boxSize, viewportSize));
        if (!lastOperations)
            return false;
        canBlend = lastOperations->canBlendWith(*operations);

}

template <>
bool appendKeyframeWithCustomBezierTimingFunction<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(WebTransformAnimationCurve* curve, double keyTime, const TransformAnimationValue* value, const TransformAnimationValue* lastValue, double x1, double y1, double x2, double y2, const FloatSize& boxSize, const IntSize& viewportSize)
{
    bool canBlend = !lastValue;
    OwnPtr<WebTransformOperations> operations(toWebTransformOperations(*value->value(), boxSize, viewportSize));
    if (!operations)
        return false;
    if (!canBlend) {
        OwnPtr<WebTransformOperations> lastOperations(toWebTransformOperations(*lastValue->value(), boxSize, viewportSize));
        if (!lastOperations)
            return false;
        canBlend = lastOperations->canBlendWith(*operations);

}

template <class Value, class Keyframe, class Curve>
PassOwnPtr<WebKit::WebAnimation> createWebAnimation(const KeyframeValueList& valueList, const Animation* animation, int animationId, double timeOffset, Curve* curve, WebKit::WebAnimation::TargetProperty targetProperty, const FloatSize& boxSize, const IntSize& viewportSize)
{
    bool alternate = false;
    bool reverse = false;


        bool addedKeyframe = false;
        if (isUsingCustomBezierTimingFunction)
            addedKeyframe = appendKeyframeWithCustomBezierTimingFunction<Value, Keyframe, Curve>(curve, keyTime, originalValue, lastOriginalValue, x1, y1, x2, y2, boxSize, viewportSize);
        else
            addedKeyframe = appendKeyframeWithStandardTimingFunction<Value, Keyframe, Curve>(curve, keyTime, originalValue, lastOriginalValue, timingFunctionType, boxSize, viewportSize);
        if (!addedKeyframe)
            return nullptr;
    }

    return webAnimation.release();
}

PassOwnPtr<WebKit::WebAnimation> createWebAnimation(const KeyframeValueList& values, const Animation* animation, int animationId, double timeOffset, const FloatSize& boxSize, const IntSize& viewportSize)
{


    if (values.property() == AnimatedPropertyWebkitTransform) {
        OwnPtr<WebTransformAnimationCurve> curve = adoptPtr(Platform::current()->compositorSupport()->createTransformAnimationCurve());
        return createWebAnimation<TransformAnimationValue, WebTransformKeyframe, WebTransformAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), WebKit::WebAnimation::TargetPropertyTransform, FloatSize(boxSize), viewportSize);
    }

    if (values.property() == AnimatedPropertyOpacity) {
        OwnPtr<WebFloatAnimationCurve> curve = adoptPtr(Platform::current()->compositorSupport()->createFloatAnimationCurve());
        return createWebAnimation<FloatAnimationValue, WebFloatKeyframe, WebFloatAnimationCurve>(values, animation, animationId, timeOffset, curve.get(), WebKit::WebAnimation::TargetPropertyOpacity, FloatSize(), viewportSize);
    }

    return nullptr;



class KeyframeValueList;
class Animation;
class FloatSize;
class IntSize;


// Translates WebCore animation data into a WebAnimation. If we are unable

//   - a steps timing function is used,
//   - a property other than AnimatedPropertyWebkitTransform, or AnimatedPropertyOpacity is animated, or
//   - a transform animation involves a non-invertable transform.
PassOwnPtr<WebKit::WebAnimation> createWebAnimation(const KeyframeValueList&, const Animation*, int animationId, double timeOffset, const FloatSize& boxSize, const IntSize& viewportSize);

} // namespace WebCore




        updateChildList();
}

bool GraphicsLayerChromium::addAnimation(const KeyframeValueList& values, const IntSize& boxSize, const IntSize& viewportSize, const Animation* animation, const String& animationName, double timeOffset)
{
    platformLayer()->setAnimationDelegate(this);


    if (m_animationIdMap.contains(animationName))
        animationId = m_animationIdMap.get(animationName);

    OwnPtr<WebAnimation> toAdd(createWebAnimation(values, animation, animationId, timeOffset, boxSize, viewportSize));

    if (toAdd) {
        animationId = toAdd->id();

Lines 118-124 public: a/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h_sec1
- a/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.h -1 / +1 lines
118	virtual void setContentsToCanvas(PlatformLayer*);	118	virtual void setContentsToCanvas(PlatformLayer*);
119	virtual bool hasContentsLayer() const { return m_contentsLayer; }	119	virtual bool hasContentsLayer() const { return m_contentsLayer; }
120		120
121	virtual bool addAnimation(const KeyframeValueList&, const IntSize& boxSize, const Animation*, const String&, double timeOffset);	121	virtual bool addAnimation(const KeyframeValueList&, const IntSize& boxSize, const IntSize& viewportSize, const Animation*, const String&, double timeOffset);
122	virtual void pauseAnimation(const String& animationName, double timeOffset);	122	virtual void pauseAnimation(const String& animationName, double timeOffset);
123	virtual void removeAnimation(const String& animationName);	123	virtual void removeAnimation(const String& animationName);
124	virtual void suspendAnimations(double wallClockTime);	124	virtual void suspendAnimations(double wallClockTime);

Lines 49-55 public: a/Source/WebCore/platform/graphics/filters/CustomFilterArrayParameter.h_sec1
- a/Source/WebCore/platform/graphics/filters/CustomFilterArrayParameter.h -1 / +1 lines
49		49
50	void addValue(double value) { m_data.append(value); }	50	void addValue(double value) { m_data.append(value); }
51		51
52	virtual PassRefPtr<CustomFilterParameter> blend(const CustomFilterParameter* from, double progress, const LayoutSize&)	52	virtual PassRefPtr<CustomFilterParameter> blend(const CustomFilterParameter* from, double progress, const LayoutSize&, const IntSize& viewportSize)
53	{	53	{
54	if (!from \|\| !isSameType(*from))	54	if (!from \|\| !isSameType(*from))
55	return this;	55	return this;

Lines 49-55 public: a/Source/WebCore/platform/graphics/filters/CustomFilterNumberParameter.h_sec1
- a/Source/WebCore/platform/graphics/filters/CustomFilterNumberParameter.h -1 / +1 lines
49		49
50	void addValue(double value) { m_data.append(value); }	50	void addValue(double value) { m_data.append(value); }
51		51
52	virtual PassRefPtr<CustomFilterParameter> blend(const CustomFilterParameter* from, double progress, const LayoutSize&)	52	virtual PassRefPtr<CustomFilterParameter> blend(const CustomFilterParameter* from, double progress, const LayoutSize&, const IntSize& viewportSize)
53	{	53	{
54	if (!from \|\| !isSameType(*from))	54	if (!from \|\| !isSameType(*from))
55	return this;	55	return this;



{
}

PassRefPtr<FilterOperation> CustomFilterOperation::blend(const FilterOperation* from, double progress, const LayoutSize& size, const IntSize& viewportSize, bool blendToPassthrough)
{
    // FIXME: There's no way to decide what is the "passthrough filter" for shaders using the current CSS Syntax.
    // https://bugs.webkit.org/show_bug.cgi?id=84903

        return this;
    
    CustomFilterParameterList animatedParameters;
    m_parameters.blend(fromOp->m_parameters, progress, size, viewportSize, animatedParameters);
    return CustomFilterOperation::create(m_program, animatedParameters, m_meshRows, m_meshColumns, m_meshType);
}


Lines 64-70 public: a/Source/WebCore/platform/graphics/filters/CustomFilterOperation.h_sec1
- a/Source/WebCore/platform/graphics/filters/CustomFilterOperation.h -1 / +1 lines
64	virtual bool movesPixels() const { return true; }	64	virtual bool movesPixels() const { return true; }
65	virtual bool blendingNeedsRendererSize() const { return true; }	65	virtual bool blendingNeedsRendererSize() const { return true; }
66		66
67	virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, const LayoutSize&, bool blendToPassthrough = false);	67	virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, const LayoutSize&, const IntSize& viewportSize, bool blendToPassthrough = false);
68		68
69	protected:	69	protected:
70	CustomFilterOperation(PassRefPtr<CustomFilterProgram>, const CustomFilterParameterList&, unsigned meshRows, unsigned meshColumns, CustomFilterMeshType);	70	CustomFilterOperation(PassRefPtr<CustomFilterProgram>, const CustomFilterParameterList&, unsigned meshRows, unsigned meshColumns, CustomFilterMeshType);

Lines 57-63 public: a/Source/WebCore/platform/graphics/filters/CustomFilterParameter.h_sec1
- a/Source/WebCore/platform/graphics/filters/CustomFilterParameter.h -1 / +1 lines
57		57
58	bool isSameType(const CustomFilterParameter& other) const { return parameterType() == other.parameterType(); }	58	bool isSameType(const CustomFilterParameter& other) const { return parameterType() == other.parameterType(); }
59		59
60	virtual PassRefPtr<CustomFilterParameter> blend(const CustomFilterParameter*, double progress, const LayoutSize&) = 0;	60	virtual PassRefPtr<CustomFilterParameter> blend(const CustomFilterParameter*, double progress, const LayoutSize&, const IntSize& viewportSize) = 0;
61	virtual bool operator==(const CustomFilterParameter&) const = 0;	61	virtual bool operator==(const CustomFilterParameter&) const = 0;
62	bool operator!=(const CustomFilterParameter& o) const { return !(*this == o); }	62	bool operator!=(const CustomFilterParameter& o) const { return !(*this == o); }
63	protected:	63	protected:



}

void CustomFilterParameterList::blend(const CustomFilterParameterList& fromList, 
    double progress, const LayoutSize& frameSize, const IntSize& viewportSize, CustomFilterParameterList& resultList) const
{
    // This method expects both lists to be sorted by parameter name and the result list is also sorted.
    ASSERT(checkAlphabeticalOrder());

        CustomFilterParameter* paramFrom = fromList.at(fromListIndex).get();
        CustomFilterParameter* paramTo = at(toListIndex).get();
        if (paramFrom->name() == paramTo->name()) {
            resultList.append(paramTo->blend(paramFrom, progress, frameSize, viewportSize));
            ++fromListIndex;
            ++toListIndex;
            continue;

Lines 45-51 public: a/Source/WebCore/platform/graphics/filters/CustomFilterParameterList.h_sec1
- a/Source/WebCore/platform/graphics/filters/CustomFilterParameterList.h -1 / +1 lines
45	explicit CustomFilterParameterList(size_t);	45	explicit CustomFilterParameterList(size_t);
46		46
47	bool checkAlphabeticalOrder() const;	47	bool checkAlphabeticalOrder() const;
48	void blend(const CustomFilterParameterList& from, double progress, const LayoutSize&, CustomFilterParameterList& resultList) const;	48	void blend(const CustomFilterParameterList& from, double progress, const LayoutSize&, const IntSize& viewportSize, CustomFilterParameterList& resultList) const;
49	bool operator==(const CustomFilterParameterList&) const;	49	bool operator==(const CustomFilterParameterList&) const;
50	};	50	};
51		51

Lines 191-197 void CustomFilterRenderer::bindProgramTransformParameter(int uniformLocation, Cu a/Source/WebCore/platform/graphics/filters/CustomFilterRenderer.cpp_sec1
- a/Source/WebCore/platform/graphics/filters/CustomFilterRenderer.cpp -1 / +1 lines
191	// Note that the origin (0, 0) of the viewport is in the middle of the context, so there's no need to change the origin of the transform	191	// Note that the origin (0, 0) of the viewport is in the middle of the context, so there's no need to change the origin of the transform
192	// in order to rotate around the middle of mesh.	192	// in order to rotate around the middle of mesh.
193	matrix.scale3d(1.0 / m_contextSize.width(), 1.0 / m_contextSize.height(), 1);	193	matrix.scale3d(1.0 / m_contextSize.width(), 1.0 / m_contextSize.height(), 1);
194	transformParameter->applyTransform(matrix, m_contextSize);	194	transformParameter->applyTransform(matrix, m_contextSize, IntSize());
195	matrix.scale3d(m_contextSize.width(), m_contextSize.height(), 1);	195	matrix.scale3d(m_contextSize.width(), m_contextSize.height(), 1);
196	}	196	}
197	float glMatrix[16];	197	float glMatrix[16];



        return adoptRef(new CustomFilterTransformParameter(name));
    }

    virtual PassRefPtr<CustomFilterParameter> blend(const CustomFilterParameter* fromParameter, double progress, const LayoutSize& size, const IntSize& viewportSize)
    {
        if (!fromParameter || !isSameType(*fromParameter))
            return this;

       
        RefPtr<CustomFilterTransformParameter> result = CustomFilterTransformParameter::create(name());
        if (from.size() && to.size())
            result->setOperations(to.blend(from, progress, size, viewportSize));
        else
            result->setOperations(progress > 0.5 ? to : from);
        return result;

        return m_operations == other->m_operations;
    }

    void applyTransform(TransformationMatrix& transform, const FloatSize& boxSize, const IntSize& viewportSize) const
    {
        for (unsigned i = 0, size = m_operations.size(); i < size; ++i)
            m_operations.at(i)->apply(transform, boxSize, viewportSize);
    }

    const TransformOperations& operations() const { return m_operations; }

Lines 91-97 public: a/Source/WebCore/platform/graphics/filters/FilterOperation.h_sec1
- a/Source/WebCore/platform/graphics/filters/FilterOperation.h -1 / +1 lines
91	return 0;	91	return 0;
92	}	92	}
93		93
94	virtual PassRefPtr<FilterOperation> blend(const FilterOperation* /from/, double /progress/, const LayoutSize&, bool /blendToPassthrough/ = false)	94	virtual PassRefPtr<FilterOperation> blend(const FilterOperation* /from/, double /progress/, const LayoutSize&, const IntSize& /viewportSize/, bool /blendToPassthrough/ = false)
95	{	95	{
96	ASSERT(blendingNeedsRendererSize());	96	ASSERT(blendingNeedsRendererSize());
97	return 0;	97	return 0;

Lines 126-132 FilterOutsets FilterOperations::outsets() const a/Source/WebCore/platform/graphics/filters/FilterOperations.cpp_sec1
- a/Source/WebCore/platform/graphics/filters/FilterOperations.cpp -1 / +1 lines
126	switch (filterOperation->getOperationType()) {	126	switch (filterOperation->getOperationType()) {
127	case FilterOperation::BLUR: {	127	case FilterOperation::BLUR: {
128	BlurFilterOperation* blurOperation = static_cast<BlurFilterOperation*>(filterOperation);	128	BlurFilterOperation* blurOperation = static_cast<BlurFilterOperation*>(filterOperation);
129	float stdDeviation = floatValueForLength(blurOperation->stdDeviation(), 0);	129	float stdDeviation = floatValueForLength(blurOperation->stdDeviation(), 0, IntSize());
130	IntSize outsetSize = outsetSizeForBlur(stdDeviation);	130	IntSize outsetSize = outsetSizeForBlur(stdDeviation);
131	FilterOutsets outsets(outsetSize.height(), outsetSize.width(), outsetSize.height(), outsetSize.width());	131	FilterOutsets outsets(outsetSize.height(), outsetSize.width(), outsetSize.height(), outsetSize.width());
132	totalOutsets += outsets;	132	totalOutsets += outsets;

Lines 54-60 ValidatedCustomFilterOperation::~ValidatedCustomFilterOperation() a/Source/WebCore/platform/graphics/filters/ValidatedCustomFilterOperation.cpp_sec1
- a/Source/WebCore/platform/graphics/filters/ValidatedCustomFilterOperation.cpp -1 / +1 lines
54	{	54	{
55	}	55	}
56		56
57	PassRefPtr<FilterOperation> ValidatedCustomFilterOperation::blend(const FilterOperation*, double progress, const LayoutSize& size, bool blendToPassthrough)	57	PassRefPtr<FilterOperation> ValidatedCustomFilterOperation::blend(const FilterOperation*, double progress, const LayoutSize& size, const IntSize& viewportSize, bool blendToPassthrough)
58	{	58	{
59	UNUSED_PARAM(progress);	59	UNUSED_PARAM(progress);
60	UNUSED_PARAM(size);	60	UNUSED_PARAM(size);

Lines 54-60 public: a/Source/WebCore/platform/graphics/filters/ValidatedCustomFilterOperation.h_sec1
- a/Source/WebCore/platform/graphics/filters/ValidatedCustomFilterOperation.h -1 / +1 lines
54	virtual bool movesPixels() const { return true; }	54	virtual bool movesPixels() const { return true; }
55	virtual bool blendingNeedsRendererSize() const { return true; }	55	virtual bool blendingNeedsRendererSize() const { return true; }
56		56
57	virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, const LayoutSize&, bool blendToPassthrough = false);	57	virtual PassRefPtr<FilterOperation> blend(const FilterOperation* from, double progress, const LayoutSize&, const IntSize& viewportSize, bool blendToPassthrough = false);
58		58
59	CustomFilterValidatedProgram* validatedProgram() const { return m_validatedProgram.get(); }	59	CustomFilterValidatedProgram* validatedProgram() const { return m_validatedProgram.get(); }
60	const CustomFilterParameterList& parameters() const { return m_parameters; }	60	const CustomFilterParameterList& parameters() const { return m_parameters; }



        return isSameType(o);
    }

    virtual bool apply(TransformationMatrix&, const FloatSize&, const IntSize&) const
    {
        return false;
    }

    virtual PassRefPtr<TransformOperation> blend(const TransformOperation*, double, const IntSize&, bool = false)
    {
        return this;
    }




namespace WebCore {

PassRefPtr<TransformOperation> Matrix3DTransformOperation::blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity)
{
    if (from && !from->isSameType(*this))
        return this;

    TransformationMatrix fromT;
    TransformationMatrix toT;
    if (from)
        from->apply(fromT, size, viewportSize);

    apply(toT, size, viewportSize);

    if (blendToIdentity)
        std::swap(fromT, toT);



        return m_matrix == m->m_matrix;
    }

    virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize&) const
    {
        transform.multiply(TransformationMatrix(m_matrix));
        return false;
    }

    virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);
    
    Matrix3DTransformOperation(const TransformationMatrix& mat)
    {

Lines 28-34 using namespace std; a/Source/WebCore/platform/graphics/transforms/MatrixTransformOperation.cpp_sec1
- a/Source/WebCore/platform/graphics/transforms/MatrixTransformOperation.cpp -1 / +1 lines
28		28
29	namespace WebCore {	29	namespace WebCore {
30		30
31	PassRefPtr<TransformOperation> MatrixTransformOperation::blend(const TransformOperation* from, double progress, bool blendToIdentity)	31	PassRefPtr<TransformOperation> MatrixTransformOperation::blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity)
32	{	32	{
33	if (from && !from->isSameType(*this))	33	if (from && !from->isSameType(*this))
34	return this;	34	return this;



        return m_a == m->m_a && m_b == m->m_b && m_c == m->m_c && m_d == m->m_d && m_e == m->m_e && m_f == m->m_f;
    }

    virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize&) const
    {
        TransformationMatrix matrix(m_a, m_b, m_c, m_d, m_e, m_f);
        transform.multiply(matrix);
        return false;
    }

    virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);
    
    MatrixTransformOperation(double a, double b, double c, double d, double e, double f)
        : m_a(a)




namespace WebCore {

PassRefPtr<TransformOperation> PerspectiveTransformOperation::blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity)
{
    if (from && !from->isSameType(*this))
        return this;
    
    if (blendToIdentity) {
        double p = floatValueForLength(m_p, 1, viewportSize);
        p = WebCore::blend(p, 1.0, progress); // FIXME: this seems wrong. https://bugs.webkit.org/show_bug.cgi?id=52700
        return PerspectiveTransformOperation::create(Length(clampToPositiveInteger(p), Fixed));
    }


    TransformationMatrix fromT;
    TransformationMatrix toT;
    fromT.applyPerspective(floatValueForLength(fromP, 1, viewportSize));
    toT.applyPerspective(floatValueForLength(toP, 1, viewportSize));
    toT.blend(fromT, progress);
    TransformationMatrix::DecomposedType decomp;
    toT.decompose(decomp);



    Length perspective() const { return m_p; }
    
private:
    virtual bool isIdentity() const { return !floatValueForLength(m_p, 1, IntSize(1, 1)); }
    virtual OperationType getOperationType() const { return PERSPECTIVE; }
    virtual bool isSameType(const TransformOperation& o) const { return o.getOperationType() == PERSPECTIVE; }


        return m_p == p->m_p;
    }

    virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize& viewportSize) const
    {
        transform.applyPerspective(floatValueForLength(m_p, 1, viewportSize));
        return false;
    }

    virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);

    PerspectiveTransformOperation(const Length& p)
        : m_p(p)

Lines 30-36 using namespace std; a/Source/WebCore/platform/graphics/transforms/RotateTransformOperation.cpp_sec1
- a/Source/WebCore/platform/graphics/transforms/RotateTransformOperation.cpp -1 / +1 lines
30		30
31	namespace WebCore {	31	namespace WebCore {
32		32
33	PassRefPtr<TransformOperation> RotateTransformOperation::blend(const TransformOperation* from, double progress, bool blendToIdentity)	33	PassRefPtr<TransformOperation> RotateTransformOperation::blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity)
34	{	34	{
35	if (from && !from->isSameType(*this))	35	if (from && !from->isSameType(*this))
36	return this;	36	return this;



        return m_x == r->m_x && m_y == r->m_y && m_z == r->m_z && m_angle == r->m_angle;
    }

    virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize&) const
    {
        transform.rotate3d(m_x, m_y, m_z, m_angle);
        return false;
    }

    virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);

    RotateTransformOperation(double x, double y, double z, double angle, OperationType type)
        : m_x(x)

Lines 26-32 a/Source/WebCore/platform/graphics/transforms/ScaleTransformOperation.cpp_sec1
- a/Source/WebCore/platform/graphics/transforms/ScaleTransformOperation.cpp -1 / +1 lines
26		26
27	namespace WebCore {	27	namespace WebCore {
28		28
29	PassRefPtr<TransformOperation> ScaleTransformOperation::blend(const TransformOperation* from, double progress, bool blendToIdentity)	29	PassRefPtr<TransformOperation> ScaleTransformOperation::blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity)
30	{	30	{
31	if (from && !from->isSameType(*this))	31	if (from && !from->isSameType(*this))
32	return this;	32	return this;



        return m_x == s->m_x && m_y == s->m_y && m_z == s->m_z;
    }

    virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize&) const
    {
        transform.scale3d(m_x, m_y, m_z);
        return false;
    }

    virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);

    ScaleTransformOperation(double sx, double sy, double sz, OperationType type)
        : m_x(sx)

Lines 26-32 a/Source/WebCore/platform/graphics/transforms/SkewTransformOperation.cpp_sec1
- a/Source/WebCore/platform/graphics/transforms/SkewTransformOperation.cpp -1 / +1 lines
26		26
27	namespace WebCore {	27	namespace WebCore {
28		28
29	PassRefPtr<TransformOperation> SkewTransformOperation::blend(const TransformOperation* from, double progress, bool blendToIdentity)	29	PassRefPtr<TransformOperation> SkewTransformOperation::blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity)
30	{	30	{
31	if (from && !from->isSameType(*this))	31	if (from && !from->isSameType(*this))
32	return this;	32	return this;



        return m_angleX == s->m_angleX && m_angleY == s->m_angleY;
    }

    virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize&) const
    {
        transform.skew(m_angleX, m_angleY);
        return false;
    }

    virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);
    
    SkewTransformOperation(double angleX, double angleY, OperationType type)
        : m_angleX(angleX)



    virtual bool isIdentity() const = 0;

    // Return true if the borderBoxSize was used in the computation, false otherwise.
    virtual bool apply(TransformationMatrix&, const FloatSize& borderBoxSize, const IntSize& viewportSize) const = 0;

    virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false) = 0;

    virtual OperationType getOperationType() const = 0;
    virtual bool isSameType(const TransformOperation&) const { return false; }



    return true;
}

TransformOperations TransformOperations::blendByMatchingOperations(const TransformOperations& from, const double& progress, const IntSize& viewportSize) const
{
    TransformOperations result;


    for (unsigned i = 0; i < size; i++) {
        RefPtr<TransformOperation> fromOperation = (i < fromSize) ? from.operations()[i].get() : 0;
        RefPtr<TransformOperation> toOperation = (i < toSize) ? operations()[i].get() : 0;
        RefPtr<TransformOperation> blendedOperation = toOperation ? toOperation->blend(fromOperation.get(), progress, viewportSize) : (fromOperation ? fromOperation->blend(0, progress, viewportSize, true) : 0);
        if (blendedOperation)
            result.operations().append(blendedOperation);
        else {

    return result;
}

TransformOperations TransformOperations::blendByUsingMatrixInterpolation(const TransformOperations& from, double progress, const LayoutSize& size, const IntSize& viewportSize) const
{
    TransformOperations result;

    // Convert the TransformOperations into matrices
    TransformationMatrix fromTransform;
    TransformationMatrix toTransform;
    from.apply(size, viewportSize, fromTransform);
    apply(size, viewportSize, toTransform);

    toTransform.blend(fromTransform, progress);


    return result;
}

TransformOperations TransformOperations::blend(const TransformOperations& from, double progress, const LayoutSize& size, const IntSize& viewportSize) const
{
    if (from == *this)
        return *this;

    if (from.size() && from.operationsMatch(*this))
        return blendByMatchingOperations(from, progress, viewportSize);

    return blendByUsingMatrixInterpolation(from, progress, size, viewportSize);
}

} // namespace WebCore



        return !(*this == o);
    }
    
    void apply(const FloatSize& sz, const IntSize& viewportSize, TransformationMatrix& t) const
    {
        for (unsigned i = 0; i < m_operations.size(); ++i)
            m_operations[i]->apply(t, sz, viewportSize);
    }
    
    // Return true if any of the operation types are 3D operation types (even if the

    size_t size() const { return m_operations.size(); }
    const TransformOperation* at(size_t index) const { return index < m_operations.size() ? m_operations.at(index).get() : 0; }

    TransformOperations blendByMatchingOperations(const TransformOperations& from, const double& progress, const IntSize& viewportSize) const;
    TransformOperations blendByUsingMatrixInterpolation(const TransformOperations& from, double progress, const LayoutSize&, const IntSize& viewportSize) const;
    TransformOperations blend(const TransformOperations& from, double progress, const LayoutSize&, const IntSize& viewportSize) const;

private:
    Vector<RefPtr<TransformOperation> > m_operations;

Lines 25-31 a/Source/WebCore/platform/graphics/transforms/TranslateTransformOperation.cpp_sec1
- a/Source/WebCore/platform/graphics/transforms/TranslateTransformOperation.cpp -1 / +1 lines
25		25
26	namespace WebCore {	26	namespace WebCore {
27		27
28	PassRefPtr<TransformOperation> TranslateTransformOperation::blend(const TransformOperation* from, double progress, bool blendToIdentity)	28	PassRefPtr<TransformOperation> TranslateTransformOperation::blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity)
29	{	29	{
30	if (from && !from->isSameType(*this))	30	if (from && !from->isSameType(*this))
31	return this;	31	return this;



        return adoptRef(new TranslateTransformOperation(tx, ty, tz, type));
    }

    double x(const FloatSize& borderBoxSize, const IntSize& viewportSize) const { return floatValueForLength(m_x, borderBoxSize.width(), viewportSize); }
    double y(const FloatSize& borderBoxSize, const IntSize& viewportSize) const { return floatValueForLength(m_y, borderBoxSize.height(), viewportSize); }
    double z(const FloatSize&, const IntSize& viewportSize) const { return floatValueForLength(m_z, 1, viewportSize); }

    Length x() const { return m_x; }
    Length y() const { return m_y; }
    Length z() const { return m_z; }

private:
    virtual bool isIdentity() const
    {
        IntSize viewportSize(1, 1);
        return !floatValueForLength(m_x, 1, viewportSize) && !floatValueForLength(m_y, 1, viewportSize) && !floatValueForLength(m_z, 1, viewportSize);
    }

    virtual OperationType getOperationType() const { return m_type; }
    virtual bool isSameType(const TransformOperation& o) const { return o.getOperationType() == m_type; }

        return m_x == t->m_x && m_y == t->m_y && m_z == t->m_z;
    }

    virtual bool apply(TransformationMatrix& transform, const FloatSize& borderBoxSize, const IntSize& viewportSize) const
    {
        transform.translate3d(x(borderBoxSize, viewportSize), y(borderBoxSize, viewportSize), z(borderBoxSize, viewportSize));
        return m_x.type() == Percent || m_y.type() == Percent;
    }

    virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);

    TranslateTransformOperation(const Length& tx, const Length& ty, const Length& tz, OperationType type)
        : m_x(tx)

Lines 543-549 void AutoTableLayout::layout() a/Source/WebCore/rendering/AutoTableLayout.cpp_sec1
- a/Source/WebCore/rendering/AutoTableLayout.cpp -1 / +1 lines
543	for (size_t i = 0; i < nEffCols; ++i) {	543	for (size_t i = 0; i < nEffCols; ++i) {
544	Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;	544	Length& logicalWidth = m_layoutStruct[i].effectiveLogicalWidth;
545	if (logicalWidth.isPercent()) {	545	if (logicalWidth.isPercent()) {
546	int cellLogicalWidth = max<int>(m_layoutStruct[i].effectiveMinLogicalWidth, minimumValueForLength(logicalWidth, tableLogicalWidth));	546	int cellLogicalWidth = max<int>(m_layoutStruct[i].effectiveMinLogicalWidth, minimumValueForLength(logicalWidth, tableLogicalWidth, IntSize()));
547	available += m_layoutStruct[i].computedLogicalWidth - cellLogicalWidth;	547	available += m_layoutStruct[i].computedLogicalWidth - cellLogicalWidth;
548	m_layoutStruct[i].computedLogicalWidth = cellLogicalWidth;	548	m_layoutStruct[i].computedLogicalWidth = cellLogicalWidth;
549	}	549	}




    const BasicShape* basicShape() const { return m_shape.get(); }
    WindRule windRule() const { return m_shape->windRule(); }
    const Path& path(const FloatRect& boundingRect, const IntSize& viewportSize)
    {
        ASSERT(m_shape);
        m_path.clear();
        m_path = adoptPtr(new Path);
        m_shape->path(*m_path, boundingRect, viewportSize);
        return *m_path;
    }




    return size.transposedSize();
}

PassOwnPtr<ExclusionShape> ExclusionShape::createExclusionShape(const BasicShape* basicShape, float logicalBoxWidth, float logicalBoxHeight, const IntSize& viewportSize, WritingMode writingMode, Length margin, Length padding)
{
    ASSERT(basicShape);


    case BasicShape::BASIC_SHAPE_RECTANGLE: {
        const BasicShapeRectangle* rectangle = static_cast<const BasicShapeRectangle*>(basicShape);
        FloatRect bounds(
            floatValueForLength(rectangle->x(), boxWidth, viewportSize),
            floatValueForLength(rectangle->y(), boxHeight, viewportSize),
            floatValueForLength(rectangle->width(), boxWidth, viewportSize),
            floatValueForLength(rectangle->height(), boxHeight, viewportSize));
        Length radiusXLength = rectangle->cornerRadiusX();
        Length radiusYLength = rectangle->cornerRadiusY();
        FloatSize cornerRadii(
            radiusXLength.isUndefined() ? 0 : floatValueForLength(radiusXLength, boxWidth, viewportSize),
            radiusYLength.isUndefined() ? 0 : floatValueForLength(radiusYLength, boxHeight, viewportSize));
        FloatRect logicalBounds = physicalRectToLogical(bounds, logicalBoxHeight, writingMode);

        exclusionShape = createExclusionRectangle(logicalBounds, physicalSizeToLogical(cornerRadii, writingMode));


    case BasicShape::BASIC_SHAPE_CIRCLE: {
        const BasicShapeCircle* circle = static_cast<const BasicShapeCircle*>(basicShape);
        float centerX = floatValueForLength(circle->centerX(), boxWidth, viewportSize);
        float centerY = floatValueForLength(circle->centerY(), boxHeight, viewportSize);
        float radius =  floatValueForLength(circle->radius(), std::max(boxHeight, boxWidth), viewportSize);
        FloatPoint logicalCenter = physicalPointToLogical(FloatPoint(centerX, centerY), logicalBoxHeight, writingMode);

        exclusionShape = createExclusionCircle(logicalCenter, radius);


    case BasicShape::BASIC_SHAPE_ELLIPSE: {
        const BasicShapeEllipse* ellipse = static_cast<const BasicShapeEllipse*>(basicShape);
        float centerX = floatValueForLength(ellipse->centerX(), boxWidth, viewportSize);
        float centerY = floatValueForLength(ellipse->centerY(), boxHeight, viewportSize);
        float radiusX = floatValueForLength(ellipse->radiusX(), boxWidth, viewportSize);
        float radiusY = floatValueForLength(ellipse->radiusY(), boxHeight, viewportSize);
        FloatPoint logicalCenter = physicalPointToLogical(FloatPoint(centerX, centerY), logicalBoxHeight, writingMode);
        FloatSize logicalRadii = physicalSizeToLogical(FloatSize(radiusX, radiusY), writingMode);


        Vector<FloatPoint>* vertices = new Vector<FloatPoint>(valuesSize / 2);
        for (unsigned i = 0; i < valuesSize; i += 2) {
            FloatPoint vertex(
                floatValueForLength(values.at(i), boxWidth, viewportSize),
                floatValueForLength(values.at(i + 1), boxHeight, viewportSize));
            (*vertices)[i / 2] = physicalPointToLogical(vertex, logicalBoxHeight, writingMode);
            if (!i)
                boundingBox.setLocation(vertex);

    exclusionShape->m_logicalBoxWidth = logicalBoxWidth;
    exclusionShape->m_logicalBoxHeight = logicalBoxHeight;
    exclusionShape->m_writingMode = writingMode;
    exclusionShape->m_margin = floatValueForLength(margin, 0, viewportSize);
    exclusionShape->m_padding = floatValueForLength(padding, 0, viewportSize);

    return exclusionShape.release();
}

Lines 59-65 typedef Vector<LineSegment> SegmentList; a/Source/WebCore/rendering/ExclusionShape.h_sec1
- a/Source/WebCore/rendering/ExclusionShape.h -1 / +1 lines
59		59
60	class ExclusionShape {	60	class ExclusionShape {
61	public:	61	public:
62	static PassOwnPtr<ExclusionShape> createExclusionShape(const BasicShape*, float logicalBoxWidth, float logicalBoxHeight, WritingMode, Length margin, Length padding);	62	static PassOwnPtr<ExclusionShape> createExclusionShape(const BasicShape*, float logicalBoxWidth, float logicalBoxHeight, const IntSize& viewportSize, WritingMode, Length margin, Length padding);
63		63
64	virtual ~ExclusionShape() { }	64	virtual ~ExclusionShape() { }
65		65



#include "RenderBox.h"
#include "RenderRegion.h"
#include "RenderStyle.h"
#include "RenderView.h"

namespace WebCore {
template<class RenderType, ExclusionShapeValue* (RenderStyle::*shapeGetter)() const, void (ExclusionShape::*intervalGetter)(float, float, SegmentList&) const>


    ASSERT(shape);

    m_shape = ExclusionShape::createExclusionShape(shape, m_shapeLogicalWidth, m_shapeLogicalHeight, m_renderer->view()->viewportSize(), m_renderer->style()->writingMode(), m_renderer->style()->shapeMargin(), m_renderer->style()->shapePadding());
    ASSERT(m_shape);
    return m_shape.get();
}

Lines 331-337 bool FilterEffectRenderer::build(RenderObject* renderer, const FilterOperations& a/Source/WebCore/rendering/FilterEffectRenderer.cpp_sec1
- a/Source/WebCore/rendering/FilterEffectRenderer.cpp -1 / +1 lines
331	}	331	}
332	case FilterOperation::BLUR: {	332	case FilterOperation::BLUR: {
333	BlurFilterOperation* blurOperation = static_cast<BlurFilterOperation*>(filterOperation);	333	BlurFilterOperation* blurOperation = static_cast<BlurFilterOperation*>(filterOperation);
334	float stdDeviation = floatValueForLength(blurOperation->stdDeviation(), 0);	334	float stdDeviation = renderer->floatValueForLength(blurOperation->stdDeviation(), 0);
335	effect = FEGaussianBlur::create(this, stdDeviation, stdDeviation);	335	effect = FEGaussianBlur::create(this, stdDeviation, stdDeviation);
336	break;	336	break;
337	}	337	}

Lines 233-239 void FixedTableLayout::layout() a/Source/WebCore/rendering/FixedTableLayout.cpp_sec1
- a/Source/WebCore/rendering/FixedTableLayout.cpp -1 / +1 lines
233	calcWidth[i] = m_width[i].value();	233	calcWidth[i] = m_width[i].value();
234	totalFixedWidth += calcWidth[i];	234	totalFixedWidth += calcWidth[i];
235	} else if (m_width[i].isPercent()) {	235	} else if (m_width[i].isPercent()) {
236	calcWidth[i] = valueForLength(m_width[i], tableLogicalWidth);	236	calcWidth[i] = valueForLength(m_width[i], tableLogicalWidth, IntSize());
237	totalPercentWidth += calcWidth[i];	237	totalPercentWidth += calcWidth[i];
238	totalPercent += m_width[i].percent();	238	totalPercent += m_width[i].percent();
239	} else if (m_width[i].isAuto()) {	239	} else if (m_width[i].isAuto()) {



LayoutUnit RenderBlock::textIndentOffset() const
{
    LayoutUnit cw = 0;
    RenderView* renderView = 0;
    if (style()->textIndent().isPercent())
        cw = containingBlock()->availableLogicalWidth();
    return minimumValueForLength(style()->textIndent(), cw);
        renderView = view();
    return minimumValueForLength(style()->textIndent(), cw, renderView);
}

LayoutUnit RenderBlock::logicalLeftOffsetForContent(RenderRegion* region, LayoutUnit offsetFromLogicalTopOfFirstPage) const

    // Signals the text indent was more negative than the min preferred width
    bool hasRemainingNegativeTextIndent = false;

    LayoutUnit textIndent = minimumValueForLength(styleToUse->textIndent(), cw);
    RenderObject* prevFloat = 0;
    bool isPrevChildInlineFlow = false;
    bool shouldBreakLineAfterText = false;



{
    if (!style()->boxReflect())
        return 0;
    RenderView* renderView = view();
    if (style()->boxReflect()->direction() == ReflectionLeft || style()->boxReflect()->direction() == ReflectionRight)
        return valueForLength(style()->boxReflect()->offset(), borderBoxRect().width());
    return valueForLength(style()->boxReflect()->offset(), borderBoxRect().height());
}

LayoutRect RenderBox::reflectedRect(const LayoutRect& r) const

        // To avoid the background color bleeding out behind the border, we'll render background and border
        // into a transparency layer, and then clip that in one go (which requires setting up the clip before
        // beginning the layer).
        RoundedRect border = style()->getRoundedBorderFor(paintRect, this);
        stateSaver.save();
        paintInfo.context->clipRoundedRect(border);
        paintInfo.context->beginTransparencyLayer(1);

    IntRect clipRect = pixelSnappedIntRect(isControlClip ? controlClipRect(accumulatedOffset) : overflowClipRect(accumulatedOffset, paintInfo.renderRegion));
    paintInfo.context->save();
    if (style()->hasBorderRadius())
        paintInfo.context->clipRoundedRect(style()->getRoundedInnerBorderFor(LayoutRect(accumulatedOffset, size()), this));
    paintInfo.context->clip(clipRect);
    return true;
}

{
    LayoutRect borderBoxRect = borderBoxRectInRegion(region);
    LayoutRect clipRect = LayoutRect(borderBoxRect.location() + location, borderBoxRect.size());
    RenderView* renderView = view();

    if (!style()->clipLeft().isAuto()) {
        LayoutUnit c = valueForLength(style()->clipLeft(), borderBoxRect.width());
        clipRect.move(c, 0);
        clipRect.contract(c, 0);
    }

    // from the left and top edges. Therefore it's better to avoid constraining to smaller widths and heights.

    if (!style()->clipRight().isAuto())
        clipRect.contract(width() - valueForLength(style()->clipRight(), width()), 0);

    if (!style()->clipTop().isAuto()) {
        LayoutUnit c = valueForLength(style()->clipTop(), borderBoxRect.height());
        clipRect.move(0, c);
        clipRect.contract(0, c);
    }

    if (!style()->clipBottom().isAuto())
        clipRect.contract(0, height() - valueForLength(style()->clipBottom(), height()));

    return clipRect;
}

    
    if (isInline() && !isInlineBlockOrInlineTable()) {
        // just calculate margins
        computedValues.m_margins.m_start = minimumValueForLength(styleToUse->marginStart(), containerLogicalWidth);
        computedValues.m_margins.m_end = minimumValueForLength(styleToUse->marginEnd(), containerLogicalWidth);
        computedValues.m_margins.m_end = minimumValueForLength(styleToUse->marginEnd(), containerLogicalWidth, renderView);
        if (treatAsReplaced)
            computedValues.m_extent = max<LayoutUnit>(floatValueForLength(logicalWidthLength, 0) + borderAndPaddingLogicalWidth(), minPreferredLogicalWidth());
        return;


    // Margin calculations.
    if (hasPerpendicularContainingBlock || isFloating() || isInline()) {
        computedValues.m_margins.m_start = minimumValueForLength(styleToUse->marginStart(), containerLogicalWidth);
        computedValues.m_margins.m_end = minimumValueForLength(styleToUse->marginEnd(), containerLogicalWidth);
        computedValues.m_margins.m_end = minimumValueForLength(styleToUse->marginEnd(), containerLogicalWidth, renderView);
    } else {
        LayoutUnit containerLogicalWidthForAutoMargins = containerLogicalWidth;
        if (avoidsFloats() && cb->containsFloats())


LayoutUnit RenderBox::fillAvailableMeasure(LayoutUnit availableLogicalWidth, LayoutUnit& marginStart, LayoutUnit& marginEnd) const
{
    marginStart = minimumValueForLength(style()->marginStart(), availableLogicalWidth);
    marginEnd = minimumValueForLength(style()->marginEnd(), availableLogicalWidth);
    marginEnd = minimumValueForLength(style()->marginEnd(), availableLogicalWidth, renderView);
    return availableLogicalWidth - marginStart - marginEnd;
}


    
    if (!logicalWidth.isIntrinsicOrAuto()) {
        // FIXME: If the containing block flow is perpendicular to our direction we need to use the available logical height instead.
        return adjustBorderBoxLogicalWidthForBoxSizing(valueForLength(logicalWidth, availableLogicalWidth));
    }

    if (logicalWidth.isIntrinsic())

    const RenderStyle* containingBlockStyle = containingBlock->style();
    Length marginStartLength = style()->marginStartUsing(containingBlockStyle);
    Length marginEndLength = style()->marginEndUsing(containingBlockStyle);
    RenderView* renderView = view();

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


    if ((marginStartLength.isAuto() && marginEndLength.isAuto() && childWidth < containerWidth)
        || (!marginStartLength.isAuto() && !marginEndLength.isAuto() && containingBlock->style()->textAlign() == WEBKIT_CENTER)) {
        // Other browsers center the margin box for align=center elements so we match them here.
        LayoutUnit marginStartWidth = minimumValueForLength(marginStartLength, containerWidth);
        LayoutUnit marginEndWidth = minimumValueForLength(marginEndLength, containerWidth);
        LayoutUnit centeredMarginBoxStart = max<LayoutUnit>(0, (containerWidth - childWidth - marginStartWidth - marginEndWidth) / 2);
        marginStart = centeredMarginBoxStart + marginStartWidth;
        marginEnd = containerWidth - childWidth - marginStart + marginEndWidth;

    
    // 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);
        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);
        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);
    marginEnd = minimumValueForLength(marginEndLength, containerWidth);
}

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

    if (height.isPercent())
        return computePercentageLogicalHeight(height);
    if (height.isViewportPercentage())
        return valueForLength(height, 0);
    return -1;
}


        case ViewportPercentageHeight:
        case ViewportPercentageMin:
        case ViewportPercentageMax:
            return adjustContentBoxLogicalWidthForBoxSizing(valueForLength(logicalWidth, 0));
        case FitContent:
        case FillAvailable:
        case Percent: 

        case ViewportPercentageHeight:
        case ViewportPercentageMin:
        case ViewportPercentageMax:
            return adjustContentBoxLogicalHeightForBoxSizing(valueForLength(logicalHeight, 0));
        default:
            return intrinsicLogicalHeight();
    }

    // Margins are calculated with respect to the logical width of
    // the containing block (8.3)
    LayoutUnit cw = containingBlockLogicalWidthForContent();
    RenderView* renderView = view();
    RenderStyle* containingBlockStyle = containingBlock->style();
    marginBefore = minimumValueForLength(style()->marginBeforeUsing(containingBlockStyle), cw);
    marginAfter = minimumValueForLength(style()->marginAfterUsing(containingBlockStyle), cw);
}

void RenderBox::computeAndSetBlockDirectionMargins(const RenderBlock* containingBlock)

    bool logicalWidthIsAuto = logicalWidth.isIntrinsicOrAuto();
    bool logicalLeftIsAuto = logicalLeft.isAuto();
    bool logicalRightIsAuto = logicalRight.isAuto();
    RenderView* renderView = view();
    LayoutUnit& marginLogicalLeftValue = style()->isLeftToRightDirection() ? computedValues.m_margins.m_start : computedValues.m_margins.m_end;
    LayoutUnit& marginLogicalRightValue = style()->isLeftToRightDirection() ? computedValues.m_margins.m_end : computedValues.m_margins.m_start;


        // NOTE:  It is not necessary to solve for 'right' in the over constrained
        // case because the value is not used for any further calculations.

        logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
        computedValues.m_extent = adjustContentBoxLogicalWidthForBoxSizing(valueForLength(logicalWidth, containerLogicalWidth));

        const LayoutUnit availableSpace = containerLogicalWidth - (logicalLeftValue + computedValues.m_extent + valueForLength(logicalRight, containerLogicalWidth) + bordersPlusPadding);

        // Margins are now the only unknown
        if (marginLogicalLeft.isAuto() && marginLogicalRight.isAuto()) {

            }
        } else if (marginLogicalLeft.isAuto()) {
            // Solve for left margin
            marginLogicalRightValue = valueForLength(marginLogicalRight, containerRelativeLogicalWidth);
            marginLogicalLeftValue = availableSpace - marginLogicalRightValue;
        } else if (marginLogicalRight.isAuto()) {
            // Solve for right margin
            marginLogicalLeftValue = valueForLength(marginLogicalLeft, containerRelativeLogicalWidth);
            marginLogicalRightValue = availableSpace - marginLogicalLeftValue;
        } else {
            // Over-constrained, solve for left if direction is RTL
            marginLogicalLeftValue = valueForLength(marginLogicalLeft, containerRelativeLogicalWidth);
            marginLogicalRightValue = valueForLength(marginLogicalRight, containerRelativeLogicalWidth);

            // Use the containing block's direction rather than the parent block's
            // per CSS 2.1 reference test abspos-non-replaced-width-margin-000.

        // because the value is not used for any further calculations.

        // Calculate margins, 'auto' margins are ignored.
        marginLogicalLeftValue = minimumValueForLength(marginLogicalLeft, containerRelativeLogicalWidth);
        marginLogicalRightValue = minimumValueForLength(marginLogicalRight, containerRelativeLogicalWidth);

        const LayoutUnit availableSpace = containerLogicalWidth - (marginLogicalLeftValue + marginLogicalRightValue + bordersPlusPadding);


        // Use rule/case that applies.
        if (logicalLeftIsAuto && logicalWidthIsAuto && !logicalRightIsAuto) {
            // RULE 1: (use shrink-to-fit for width, and solve of left)
            LayoutUnit logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);

            // FIXME: would it be better to have shrink-to-fit in one step?
            LayoutUnit preferredWidth = maxPreferredLogicalWidth() - bordersPlusPadding;

            logicalLeftValue = availableSpace - (computedValues.m_extent + logicalRightValue);
        } else if (!logicalLeftIsAuto && logicalWidthIsAuto && logicalRightIsAuto) {
            // RULE 3: (use shrink-to-fit for width, and no need solve of right)
            logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);

            // FIXME: would it be better to have shrink-to-fit in one step?
            LayoutUnit preferredWidth = maxPreferredLogicalWidth() - bordersPlusPadding;

            computedValues.m_extent = min(max(preferredMinWidth, availableWidth), preferredWidth);
        } else if (logicalLeftIsAuto && !logicalWidthIsAuto && !logicalRightIsAuto) {
            // RULE 4: (solve for left)
            computedValues.m_extent = adjustContentBoxLogicalWidthForBoxSizing(valueForLength(logicalWidth, containerLogicalWidth));
            logicalLeftValue = availableSpace - (computedValues.m_extent + valueForLength(logicalRight, containerLogicalWidth));
        } else if (!logicalLeftIsAuto && logicalWidthIsAuto && !logicalRightIsAuto) {
            // RULE 5: (solve for width)
            logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
            computedValues.m_extent = availableSpace - (logicalLeftValue + valueForLength(logicalRight, containerLogicalWidth));
        } else if (!logicalLeftIsAuto && !logicalWidthIsAuto && logicalRightIsAuto) {
            // RULE 6: (no need solve for right)
            logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
            computedValues.m_extent = adjustContentBoxLogicalWidthForBoxSizing(valueForLength(logicalWidth, containerLogicalWidth));
        }
    }


    bool logicalHeightIsAuto = logicalHeightLength.isAuto();
    bool logicalTopIsAuto = logicalTop.isAuto();
    bool logicalBottomIsAuto = logicalBottom.isAuto();
    RenderView* renderView = view();

    // Height is never unsolved for tables.
    if (isTable()) {

        // NOTE:  It is not necessary to solve for 'bottom' in the over constrained
        // case because the value is not used for any further calculations.

        logicalHeightValue = adjustContentBoxLogicalHeightForBoxSizing(valueForLength(logicalHeightLength, containerLogicalHeight));
        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);

        const LayoutUnit availableSpace = containerLogicalHeight - (logicalTopValue + logicalHeightValue + valueForLength(logicalBottom, containerLogicalHeight) + bordersPlusPadding);

        // Margins are now the only unknown
        if (marginBefore.isAuto() && marginAfter.isAuto()) {

            computedValues.m_margins.m_after = availableSpace - computedValues.m_margins.m_before; // account for odd valued differences
        } else if (marginBefore.isAuto()) {
            // Solve for top margin
            computedValues.m_margins.m_after = valueForLength(marginAfter, containerRelativeLogicalWidth);
            computedValues.m_margins.m_before = availableSpace - computedValues.m_margins.m_after;
        } else if (marginAfter.isAuto()) {
            // Solve for bottom margin
            computedValues.m_margins.m_before = valueForLength(marginBefore, containerRelativeLogicalWidth);
            computedValues.m_margins.m_after = availableSpace - computedValues.m_margins.m_before;
        } else {
            // Over-constrained, (no need solve for bottom)
            computedValues.m_margins.m_before = valueForLength(marginBefore, containerRelativeLogicalWidth);
            computedValues.m_margins.m_after = valueForLength(marginAfter, containerRelativeLogicalWidth);
        }
    } else {
        /*--------------------------------------------------------------------*\

        // because the value is not used for any further calculations.

        // Calculate margins, 'auto' margins are ignored.
        computedValues.m_margins.m_before = minimumValueForLength(marginBefore, containerRelativeLogicalWidth);
        computedValues.m_margins.m_after = minimumValueForLength(marginAfter, containerRelativeLogicalWidth);

        const LayoutUnit availableSpace = containerLogicalHeight - (computedValues.m_margins.m_before + computedValues.m_margins.m_after + bordersPlusPadding);


        if (logicalTopIsAuto && logicalHeightIsAuto && !logicalBottomIsAuto) {
            // RULE 1: (height is content based, solve of top)
            logicalHeightValue = contentLogicalHeight;
            logicalTopValue = availableSpace - (logicalHeightValue + valueForLength(logicalBottom, containerLogicalHeight));
        } else if (!logicalTopIsAuto && logicalHeightIsAuto && logicalBottomIsAuto) {
            // RULE 3: (height is content based, no need solve of bottom)
            logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
            logicalHeightValue = contentLogicalHeight;
        } else if (logicalTopIsAuto && !logicalHeightIsAuto && !logicalBottomIsAuto) {
            // RULE 4: (solve of top)
            logicalHeightValue = adjustContentBoxLogicalHeightForBoxSizing(valueForLength(logicalHeightLength, containerLogicalHeight));
            logicalTopValue = availableSpace - (logicalHeightValue + valueForLength(logicalBottom, containerLogicalHeight));
        } else if (!logicalTopIsAuto && logicalHeightIsAuto && !logicalBottomIsAuto) {
            // RULE 5: (solve of height)
            logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
            logicalHeightValue = max<LayoutUnit>(0, availableSpace - (logicalTopValue + valueForLength(logicalBottom, containerLogicalHeight)));
        } else if (!logicalTopIsAuto && !logicalHeightIsAuto && logicalBottomIsAuto) {
            // RULE 6: (no need solve of bottom)
            logicalHeightValue = adjustContentBoxLogicalHeightForBoxSizing(valueForLength(logicalHeightLength, containerLogicalHeight));
            logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
        }
    }
    computedValues.m_extent = logicalHeightValue;

    \*-----------------------------------------------------------------------*/
    LayoutUnit logicalLeftValue = 0;
    LayoutUnit logicalRightValue = 0;
    RenderView* renderView = view();

    if (marginLogicalLeft.isAuto() && marginLogicalRight.isAuto()) {
        // 'left' and 'right' cannot be 'auto' due to step 3
        ASSERT(!(logicalLeft.isAuto() && logicalRight.isAuto()));

        logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
        logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);

        LayoutUnit difference = availableSpace - (logicalLeftValue + logicalRightValue);
        if (difference > 0) {

     *    that value.
    \*-----------------------------------------------------------------------*/
    } else if (logicalLeft.isAuto()) {
        marginLogicalLeftAlias = valueForLength(marginLogicalLeft, containerRelativeLogicalWidth);
        marginLogicalRightAlias = valueForLength(marginLogicalRight, containerRelativeLogicalWidth);
        logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);

        // Solve for 'left'
        logicalLeftValue = availableSpace - (logicalRightValue + marginLogicalLeftAlias + marginLogicalRightAlias);
    } else if (logicalRight.isAuto()) {
        marginLogicalLeftAlias = valueForLength(marginLogicalLeft, containerRelativeLogicalWidth);
        marginLogicalRightAlias = valueForLength(marginLogicalRight, containerRelativeLogicalWidth);
        logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);

        // Solve for 'right'
        logicalRightValue = availableSpace - (logicalLeftValue + marginLogicalLeftAlias + marginLogicalRightAlias);
    } else if (marginLogicalLeft.isAuto()) {
        marginLogicalRightAlias = valueForLength(marginLogicalRight, containerRelativeLogicalWidth);
        logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
        logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);

        // Solve for 'margin-left'
        marginLogicalLeftAlias = availableSpace - (logicalLeftValue + logicalRightValue + marginLogicalRightAlias);
    } else if (marginLogicalRight.isAuto()) {
        marginLogicalLeftAlias = valueForLength(marginLogicalLeft, containerRelativeLogicalWidth);
        logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
        logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);

        // Solve for 'margin-right'
        marginLogicalRightAlias = availableSpace - (logicalLeftValue + logicalRightValue + marginLogicalLeftAlias);
    } else {
        // Nothing is 'auto', just calculate the values.
        marginLogicalLeftAlias = valueForLength(marginLogicalLeft, containerRelativeLogicalWidth);
        marginLogicalRightAlias = valueForLength(marginLogicalRight, containerRelativeLogicalWidth);
        logicalRightValue = valueForLength(logicalRight, containerLogicalWidth);
        logicalLeftValue = valueForLength(logicalLeft, containerLogicalWidth);
        // If the containing block is right-to-left, then push the left position as far to the right as possible
        if (containerDirection == RTL) {
            int totalLogicalWidth = computedValues.m_extent + logicalLeftValue + logicalRightValue +  marginLogicalLeftAlias + marginLogicalRightAlias;


    Length logicalTop = style()->logicalTop();
    Length logicalBottom = style()->logicalBottom();
    RenderView* renderView = view();

    /*-----------------------------------------------------------------------*\
     * 1. The used value of 'height' is determined as for inline replaced

        // 'top' and 'bottom' cannot be 'auto' due to step 2 and 3 combined.
        ASSERT(!(logicalTop.isAuto() || logicalBottom.isAuto()));

        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
        logicalBottomValue = valueForLength(logicalBottom, containerLogicalHeight);

        LayoutUnit difference = availableSpace - (logicalTopValue + logicalBottomValue);
        // NOTE: This may result in negative values.

     *    for that value.
    \*-----------------------------------------------------------------------*/
    } else if (logicalTop.isAuto()) {
        marginBeforeAlias = valueForLength(marginBefore, containerRelativeLogicalWidth);
        marginAfterAlias = valueForLength(marginAfter, containerRelativeLogicalWidth);
        logicalBottomValue = valueForLength(logicalBottom, containerLogicalHeight);

        // Solve for 'top'
        logicalTopValue = availableSpace - (logicalBottomValue + marginBeforeAlias + marginAfterAlias);
    } else if (logicalBottom.isAuto()) {
        marginBeforeAlias = valueForLength(marginBefore, containerRelativeLogicalWidth);
        marginAfterAlias = valueForLength(marginAfter, containerRelativeLogicalWidth);
        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);

        // Solve for 'bottom'
        // NOTE: It is not necessary to solve for 'bottom' because we don't ever
        // use the value.
    } else if (marginBefore.isAuto()) {
        marginAfterAlias = valueForLength(marginAfter, containerRelativeLogicalWidth);
        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
        logicalBottomValue = valueForLength(logicalBottom, containerLogicalHeight);

        // Solve for 'margin-top'
        marginBeforeAlias = availableSpace - (logicalTopValue + logicalBottomValue + marginAfterAlias);
    } else if (marginAfter.isAuto()) {
        marginBeforeAlias = valueForLength(marginBefore, containerRelativeLogicalWidth);
        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
        logicalBottomValue = valueForLength(logicalBottom, containerLogicalHeight);

        // Solve for 'margin-bottom'
        marginAfterAlias = availableSpace - (logicalTopValue + logicalBottomValue + marginBeforeAlias);
    } else {
        // Nothing is 'auto', just calculate the values.
        marginBeforeAlias = valueForLength(marginBefore, containerRelativeLogicalWidth);
        marginAfterAlias = valueForLength(marginAfter, containerRelativeLogicalWidth);
        logicalTopValue = valueForLength(logicalTop, containerLogicalHeight);
        // NOTE: It is not necessary to solve for 'bottom' because we don't ever
        // use the value.
     }



    // call availableWidth on our containing block.
    if (!style()->left().isAuto()) {
        if (!style()->right().isAuto() && !containingBlock->style()->isLeftToRightDirection())
            offset.setWidth(-valueForLength(style()->right(), containingBlock->availableWidth()));
        else
            offset.expand(valueForLength(style()->left(), containingBlock->availableWidth()), 0);
    } else if (!style()->right().isAuto()) {
        offset.expand(-valueForLength(style()->right(), containingBlock->availableWidth()), 0);
    }

    // If the containing block of a relatively positioned element does not

        && (!containingBlock->hasAutoHeightOrContainingBlockWithAutoHeight()
            || !style()->top().isPercent()
            || containingBlock->stretchesToViewport()))
        offset.expand(0, valueForLength(style()->top(), containingBlock->availableHeight()));

    else if (!style()->bottom().isAuto()
        && (!containingBlock->hasAutoHeightOrContainingBlockWithAutoHeight()
            || !style()->bottom().isPercent()
            || containingBlock->stretchesToViewport()))
        offset.expand(0, -valueForLength(style()->bottom(), containingBlock->availableHeight()));

    return offset;
}


    // Sticky positioned element ignore any override logical width on the containing block (as they don't call
    // containingBlockLogicalWidthForContent). It's unclear whether this is totally fine.
    LayoutBoxExtent minMargin(minimumValueForLength(style()->marginTop(), maxWidth),
        minimumValueForLength(style()->marginRight(), maxWidth),
        minimumValueForLength(style()->marginBottom(), maxWidth),
        minimumValueForLength(style()->marginLeft(), maxWidth));

    // Compute the container-relative area within which the sticky element is allowed to move.
    containerContentRect.contract(minMargin);

    constraints.setAbsoluteStickyBoxRect(absoluteStickyBoxRect);

    if (!style()->left().isAuto()) {
        constraints.setLeftOffset(valueForLength(style()->left(), viewportRect.width()));
        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeLeft);
    }

    if (!style()->right().isAuto()) {
        constraints.setRightOffset(valueForLength(style()->right(), viewportRect.width()));
        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeRight);
    }

    if (!style()->top().isAuto()) {
        constraints.setTopOffset(valueForLength(style()->top(), viewportRect.height()));
        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeTop);
    }

    if (!style()->bottom().isAuto()) {
        constraints.setBottomOffset(valueForLength(style()->bottom(), viewportRect.height()));
        constraints.addAnchorEdge(ViewportConstraints::AnchorEdgeBottom);
    }
}

LayoutUnit RenderBoxModelObject::computedCSSPadding(Length padding) const
{
    LayoutUnit w = 0;
    RenderView* renderView = 0;
    if (padding.isPercent())
        w = containingBlockLogicalWidthForContent();
    return minimumValueForLength(padding, w);
        renderView = view();
    return minimumValueForLength(padding, w, renderView);
}

RoundedRect RenderBoxModelObject::getBackgroundRoundedRect(const LayoutRect& borderRect, InlineFlowBox* box, LayoutUnit inlineBoxWidth, LayoutUnit inlineBoxHeight,
    bool includeLogicalLeftEdge, bool includeLogicalRightEdge) const
{
    RoundedRect border = style()->getRoundedBorderFor(borderRect, this, includeLogicalLeftEdge, includeLogicalRightEdge);
    RoundedRect border = style()->getRoundedBorderFor(borderRect, renderView, includeLogicalLeftEdge, includeLogicalRightEdge);
    if (box && (box->nextLineBox() || box->prevLineBox())) {
        RoundedRect segmentBorder = style()->getRoundedBorderFor(LayoutRect(0, 0, inlineBoxWidth, inlineBoxHeight), this, includeLogicalLeftEdge, includeLogicalRightEdge);
        border.setRadii(segmentBorder.radii());
    }


        return getBackgroundRoundedRect(shrinkRectByOnePixel(context, borderRect), box, boxSize.width(), boxSize.height(), includeLogicalLeftEdge, includeLogicalRightEdge);
    }
    if (bleedAvoidance == BackgroundBleedBackgroundOverBorder)
        return style()->getRoundedInnerBorderFor(borderRect, this, includeLogicalLeftEdge, includeLogicalRightEdge);

    return getBackgroundRoundedRect(borderRect, box, boxSize.width(), boxSize.height(), includeLogicalLeftEdge, includeLogicalRightEdge);
}


        // Clip to the padding or content boxes as necessary.
        if (bgLayer->clip() == ContentFillBox) {
            border = style()->getRoundedInnerBorderFor(border.rect(), this,
                paddingTop() + borderTop(), paddingBottom() + borderBottom(), paddingLeft() + borderLeft(), paddingRight() + borderRight(), includeLeftEdge, includeRightEdge);
        } else if (bgLayer->clip() == PaddingFillBox)
            border = style()->getRoundedInnerBorderFor(border.rect(), this, includeLeftEdge, includeRightEdge);

        clipRoundedInnerRect(context, rect, border);
    }


    IntSize imageIntrinsicSize = calculateImageIntrinsicDimensions(image, positioningAreaSize, ScaleByEffectiveZoom);
    imageIntrinsicSize.scale(1 / image->imageScaleFactor(), 1 / image->imageScaleFactor());
    RenderView* renderView = view();
    switch (type) {
        case SizeLength: {
            LayoutSize tileSize = positioningAreaSize;

            if (layerWidth.isFixed())
                tileSize.setWidth(layerWidth.value());
            else if (layerWidth.isPercent() || layerWidth.isViewportPercentage())
                tileSize.setWidth(valueForLength(layerWidth, positioningAreaSize.width()));
            
            if (layerHeight.isFixed())
                tileSize.setHeight(layerHeight.value());
            else if (layerHeight.isPercent() || layerHeight.isViewportPercentage())
                tileSize.setHeight(valueForLength(layerHeight, positioningAreaSize.height()));

            applySubPixelHeuristicForTileSize(tileSize, positioningAreaSize);



    EFillRepeat backgroundRepeatX = fillLayer->repeatX();
    EFillRepeat backgroundRepeatY = fillLayer->repeatY();
    RenderView* renderView = view();
    int availableWidth = positioningAreaSize.width() - geometry.tileSize().width();
    int availableHeight = positioningAreaSize.height() - geometry.tileSize().height();

    LayoutUnit computedXPosition = minimumValueForLength(fillLayer->xPosition(), availableWidth, true);
    if (backgroundRepeatX == RepeatFill)
        geometry.setPhaseX(geometry.tileSize().width() ? geometry.tileSize().width() - roundToInt(computedXPosition + left) % geometry.tileSize().width() : 0);
    else {
        int xOffset = fillLayer->backgroundXOrigin() == RightEdge ? availableWidth - computedXPosition : computedXPosition;
        geometry.setNoRepeatX(left + xOffset);
    }
    LayoutUnit computedYPosition = minimumValueForLength(fillLayer->yPosition(), availableHeight, true);
    if (backgroundRepeatY == RepeatFill)
        geometry.setPhaseY(geometry.tileSize().height() ? geometry.tileSize().height() - roundToInt(computedYPosition + top) % geometry.tileSize().height() : 0);
    else {

    geometry.setDestOrigin(geometry.destRect().location());
}

static LayoutUnit computeBorderImageSide(Length borderSlice, LayoutUnit borderSide, LayoutUnit imageSide, LayoutUnit boxExtent, const RenderObject* renderer)
{
    if (borderSlice.isRelative())
        return borderSlice.value() * borderSide;
    if (borderSlice.isAuto())
        return imageSide;
    return renderer->valueForLength(borderSlice, boxExtent);
}

bool RenderBoxModelObject::paintNinePieceImage(GraphicsContext* graphicsContext, const LayoutRect& rect, const RenderStyle* style,


    int imageWidth = imageSize.width();
    int imageHeight = imageSize.height();
    RenderView* renderView = view();

    float imageScaleFactor = styleImage->imageScaleFactor();
    int topSlice = min<int>(imageHeight, valueForLength(ninePieceImage.imageSlices().top(), imageHeight)) * imageScaleFactor;
    int rightSlice = min<int>(imageWidth, valueForLength(ninePieceImage.imageSlices().right(), imageWidth)) * imageScaleFactor;
    int bottomSlice = min<int>(imageHeight, valueForLength(ninePieceImage.imageSlices().bottom(), imageHeight)) * imageScaleFactor;
    int leftSlice = min<int>(imageWidth, valueForLength(ninePieceImage.imageSlices().left(), imageWidth)) * imageScaleFactor;

    ENinePieceImageRule hRule = ninePieceImage.horizontalRule();
    ENinePieceImageRule vRule = ninePieceImage.verticalRule();

    int topWidth = computeBorderImageSide(ninePieceImage.borderSlices().top(), style->borderTopWidth(), topSlice, borderImageRect.height(), this);
    int rightWidth = computeBorderImageSide(ninePieceImage.borderSlices().right(), style->borderRightWidth(), rightSlice, borderImageRect.width(), this);
    int bottomWidth = computeBorderImageSide(ninePieceImage.borderSlices().bottom(), style->borderBottomWidth(), bottomSlice, borderImageRect.height(), this);
    int leftWidth = computeBorderImageSide(ninePieceImage.borderSlices().left(), style->borderLeftWidth(), leftSlice, borderImageRect.width(), this);
    
    // Reduce the widths if they're too large.
    // The spec says: Given Lwidth as the width of the border image area, Lheight as its height, and Wside as the border image width


    BorderEdge edges[4];
    getBorderEdgeInfo(edges, style, includeLogicalLeftEdge, includeLogicalRightEdge);
    RoundedRect outerBorder = style->getRoundedBorderFor(rect, this, includeLogicalLeftEdge, includeLogicalRightEdge);
    RoundedRect innerBorder = style->getRoundedInnerBorderFor(borderInnerRectAdjustedForBleedAvoidance(graphicsContext, rect, bleedAvoidance), this, includeLogicalLeftEdge, includeLogicalRightEdge);

    bool haveAlphaColor = false;
    bool haveAllSolidEdges = true;


    // If only one edge visible antialiasing doesn't create seams
    bool antialias = shouldAntialiasLines(graphicsContext) || numEdgesVisible == 1;
    RoundedRect unadjustedInnerBorder = (bleedAvoidance == BackgroundBleedBackgroundOverBorder) ? style->getRoundedInnerBorderFor(rect, this, includeLogicalLeftEdge, includeLogicalRightEdge) : innerBorder;
    IntPoint innerBorderAdjustment(innerBorder.rect().x() - unadjustedInnerBorder.rect().x(), innerBorder.rect().y() - unadjustedInnerBorder.rect().y());
    if (haveAlphaColor)
        paintTranslucentBorderSides(graphicsContext, style, outerBorder, unadjustedInnerBorder, innerBorderAdjustment, edges, edgesToDraw, bleedAvoidance, includeLogicalLeftEdge, includeLogicalRightEdge, antialias);

        // Draw inner border line
        {
            GraphicsContextStateSaver stateSaver(*graphicsContext);
            RoundedRect innerClip = style->getRoundedInnerBorderFor(borderRect, this,
                innerBorderTopWidth, innerBorderBottomWidth, innerBorderLeftWidth, innerBorderRightWidth,
                includeLogicalLeftEdge, includeLogicalRightEdge);
            

                ++outerBorderRightWidth;
            }
                
            RoundedRect outerClip = style->getRoundedInnerBorderFor(outerRect, this,
                outerBorderTopWidth, outerBorderBottomWidth, outerBorderLeftWidth, outerBorderRightWidth,
                includeLogicalLeftEdge, includeLogicalRightEdge);
            graphicsContext->clipOutRoundedRect(outerClip);

        LayoutUnit leftWidth = edges[BSLeft].usedWidth() / 2;
        LayoutUnit rightWidth = edges[BSRight].usedWidth() / 2;

        RoundedRect clipRect = style->getRoundedInnerBorderFor(borderRect, this,
            topWidth, bottomWidth, leftWidth, rightWidth,
            includeLogicalLeftEdge, includeLogicalRightEdge);


    if (context->paintingDisabled() || !s->boxShadow())
        return;

    RoundedRect border = (shadowStyle == Inset) ? s->getRoundedInnerBorderFor(paintRect, this, includeLogicalLeftEdge, includeLogicalRightEdge)
                                                   : s->getRoundedBorderFor(paintRect, this, includeLogicalLeftEdge, includeLogicalRightEdge);

    bool hasBorderRadius = s->hasBorderRadius();
    bool isHorizontal = s->isHorizontalWritingMode();



    // to figure out the logical height/width.
    if (isColumnFlow())
        return child->computeContentLogicalHeight(sizeType, size);
    return child->adjustContentBoxLogicalWidthForBoxSizing(valueForLength(size, contentLogicalWidth()));
}

WritingMode RenderFlexibleBox::transformedWritingMode() const

    // When resolving the margins, we use the content size for resolving percent and calc (for percents in calc expressions) margins.
    // Fortunately, percent margins are always computed with respect to the block's width, even for margin-top and margin-bottom.
    LayoutUnit availableSize = contentLogicalWidth();
    return minimumValueForLength(margin, availableSize);
}

void RenderFlexibleBox::computeMainAxisPreferredSizes(OrderHashSet& orderValues)

Lines 313-319 LayoutUnit RenderGrid::computeUsedBreadthOfSpecifiedLength(TrackSizingDirection a/Source/WebCore/rendering/RenderGrid.cpp_sec1
- a/Source/WebCore/rendering/RenderGrid.cpp -1 / +1 lines
313	{	313	{
314	// FIXME: We still need to support calc() here (https://webkit.org/b/103761).	314	// FIXME: We still need to support calc() here (https://webkit.org/b/103761).
315	ASSERT(trackLength.isFixed() \|\| trackLength.isPercent() \|\| trackLength.isViewportPercentage());	315	ASSERT(trackLength.isFixed() \|\| trackLength.isPercent() \|\| trackLength.isViewportPercentage());
316	return valueForLength(trackLength, direction == ForColumns ? logicalWidth() : computeContentLogicalHeight(MainOrPreferredSize, style()->logicalHeight()), view());	316	return valueForLength(trackLength, direction == ForColumns ? logicalWidth() : computeContentLogicalHeight(MainOrPreferredSize, style()->logicalHeight()));
317	}	317	}
318		318
319	const GridTrackSize& RenderGrid::gridTrackSize(TrackSizingDirection direction, size_t i)	319	const GridTrackSize& RenderGrid::gridTrackSize(TrackSizingDirection direction, size_t i)



    if (margin.isFixed())
        return margin.value();
    if (margin.isPercent())
        return renderer->minimumValueForLength(margin, max<LayoutUnit>(0, renderer->containingBlock()->availableLogicalWidth()));
    if (margin.isViewportPercentage())
        return renderer->valueForLength(margin, 0);
    return 0;
}




        RenderBox* box = renderBox();
        ASSERT(box);
        m_transform->makeIdentity();
        box->style()->applyTransform(*m_transform, box->pixelSnappedBorderBoxRect().size(), renderer(), RenderStyle::IncludeTransformOrigin);
        makeMatrixRenderable(*m_transform, canRender3DTransforms());
    }


    if (renderer()->style()->isRunningAcceleratedAnimation()) {
        TransformationMatrix currTransform;
        RefPtr<RenderStyle> style = renderer()->animation()->getAnimatedStyleForRenderer(renderer());
        style->applyTransform(currTransform, renderBox()->pixelSnappedBorderBoxRect().size(), renderer(), applyOrigin);
        makeMatrixRenderable(currTransform, canRender3DTransforms());
        return currTransform;
    }

    if (applyOrigin == RenderStyle::ExcludeTransformOrigin) {
        RenderBox* box = renderBox();
        TransformationMatrix currTransform;
        box->style()->applyTransform(currTransform, box->pixelSnappedBorderBoxRect().size(), renderer(), RenderStyle::ExcludeTransformOrigin);
        makeMatrixRenderable(currTransform, canRender3DTransforms());
        return currTransform;
    }

    const float boxWidth = borderBox.width();
    const float boxHeight = borderBox.height();

    float perspectiveOriginX = renderer()->floatValueForLength(style->perspectiveOriginX(), boxWidth);
    float perspectiveOriginY = renderer()->floatValueForLength(style->perspectiveOriginY(), boxHeight);

    // A perspective origin of 0,0 makes the vanishing point in the center of the element.
    // We want it to be in the top-left, so subtract half the height and width.

    const LayoutRect borderBox = toRenderBox(renderer())->borderBoxRect();
    RenderStyle* style = renderer()->style();

    return FloatPoint(renderer()->floatValueForLength(style->perspectiveOriginX(), borderBox.width()),
                      renderer()->floatValueForLength(style->perspectiveOriginY(), borderBox.height()));
}

RenderLayer* RenderLayer::stackingContainer() const

        if (layer->renderer()->hasOverflowClip() && layer->renderer()->style()->hasBorderRadius() && inContainingBlockChain(this, layer)) {
                LayoutPoint delta;
                layer->convertToLayerCoords(rootLayer, delta);
                context->clipRoundedRect(layer->renderer()->style()->getRoundedInnerBorderFor(LayoutRect(delta, layer->size()), renderer()));
        }

        if (layer == rootLayer)

                rootRelativeBoundsComputed = true;
            }

            context->clipPath(clipPath->path(rootRelativeBounds, renderer()->view()->viewportSize()), clipPath->windRule());
        }
#if ENABLE(SVG)
        else if (style->clipPath()->getOperationType() == ClipPathOperation::REFERENCE) {

Lines 336-342 void RenderLayerBacking::updateTransform(const RenderStyle* style) a/Source/WebCore/rendering/RenderLayerBacking.cpp_sec1
- a/Source/WebCore/rendering/RenderLayerBacking.cpp -11 / +14 lines
336	// baked into it, and we don't want that.	336	// baked into it, and we don't want that.
337	TransformationMatrix t;	337	TransformationMatrix t;
338	if (m_owningLayer->hasTransform()) {	338	if (m_owningLayer->hasTransform()) {
339	style->applyTransform(t, toRenderBox(renderer())->pixelSnappedBorderBoxRect().size(), RenderStyle::ExcludeTransformOrigin);	339	style->applyTransform(t, toRenderBox(renderer())->pixelSnappedBorderBoxRect().size(), renderer(), RenderStyle::ExcludeTransformOrigin);
340	makeMatrixRenderable(t, compositor()->canRender3DTransforms());	340	makeMatrixRenderable(t, compositor()->canRender3DTransforms());
341	}	341	}
342		342
Lines 1617-1625 FloatPoint3D RenderLayerBacking::computeTransformOrigin(const IntRect& borderBox a/Source/WebCore/rendering/RenderLayerBacking.cpp_sec2
1617	{	1617	{
1618	RenderStyle* style = renderer()->style();	1618	RenderStyle* style = renderer()->style();
1619		1619
		1620	const IntSize& viewportSize = renderer()->view()->viewportSize();
		1621
1620	FloatPoint3D origin;	1622	FloatPoint3D origin;
1621	origin.setX(floatValueForLength(style->transformOriginX(), borderBox.width()));	1623	origin.setX(floatValueForLength(style->transformOriginX(), borderBox.width(), viewportSize));
1622	origin.setY(floatValueForLength(style->transformOriginY(), borderBox.height()));	1624	origin.setY(floatValueForLength(style->transformOriginY(), borderBox.height(), viewportSize));
1623	origin.setZ(style->transformOriginZ());	1625	origin.setZ(style->transformOriginZ());
1624		1626
1625	return origin;	1627	return origin;
Lines 1631-1640 FloatPoint RenderLayerBacking::computePerspectiveOrigin(const IntRect& borderBox a/Source/WebCore/rendering/RenderLayerBacking.cpp_sec3
1631		1633
1632	float boxWidth = borderBox.width();	1634	float boxWidth = borderBox.width();
1633	float boxHeight = borderBox.height();	1635	float boxHeight = borderBox.height();
		1636	const IntSize& viewportSize = renderer()->view()->viewportSize();
1634		1637
1635	FloatPoint origin;	1638	FloatPoint origin;
1636	origin.setX(floatValueForLength(style->perspectiveOriginX(), boxWidth));	1639	origin.setX(floatValueForLength(style->perspectiveOriginX(), boxWidth, viewportSize));
1637	origin.setY(floatValueForLength(style->perspectiveOriginY(), boxHeight));	1640	origin.setY(floatValueForLength(style->perspectiveOriginY(), boxHeight, viewportSize));
1638		1641
1639	return origin;	1642	return origin;
1640	}	1643	}
Lines 1995-2008 bool RenderLayerBacking::startAnimation(double timeOffset, const Animation* anim a/Source/WebCore/rendering/RenderLayerBacking.cpp_sec4
1995	bool didAnimateFilter = false;	1998	bool didAnimateFilter = false;
1996	#endif	1999	#endif
1997		2000
1998	if (hasTransform && m_graphicsLayer->addAnimation(transformVector, toRenderBox(renderer())->pixelSnappedBorderBoxRect().size(), anim, keyframes.animationName(), timeOffset))	2001	if (hasTransform && m_graphicsLayer->addAnimation(transformVector, toRenderBox(renderer())->pixelSnappedBorderBoxRect().size(), renderer()->view()->viewportSize(), anim, keyframes.animationName(), timeOffset))
1999	didAnimateTransform = true;	2002	didAnimateTransform = true;
2000		2003
2001	if (hasOpacity && m_graphicsLayer->addAnimation(opacityVector, IntSize(), anim, keyframes.animationName(), timeOffset))	2004	if (hasOpacity && m_graphicsLayer->addAnimation(opacityVector, IntSize(), IntSize(), anim, keyframes.animationName(), timeOffset))
2002	didAnimateOpacity = true;	2005	didAnimateOpacity = true;
2003		2006
2004	#if ENABLE(CSS_FILTERS)	2007	#if ENABLE(CSS_FILTERS)
2005	if (hasFilter && m_graphicsLayer->addAnimation(filterVector, IntSize(), anim, keyframes.animationName(), timeOffset))	2008	if (hasFilter && m_graphicsLayer->addAnimation(filterVector, IntSize(), IntSize(), anim, keyframes.animationName(), timeOffset))
2006	didAnimateFilter = true;	2009	didAnimateFilter = true;
2007	#endif	2010	#endif
2008		2011
Lines 2040-2046 bool RenderLayerBacking::startTransition(double timeOffset, CSSPropertyID proper a/Source/WebCore/rendering/RenderLayerBacking.cpp_sec5
2040	opacityVector.insert(new FloatAnimationValue(0, compositingOpacity(fromStyle->opacity())));	2043	opacityVector.insert(new FloatAnimationValue(0, compositingOpacity(fromStyle->opacity())));
2041	opacityVector.insert(new FloatAnimationValue(1, compositingOpacity(toStyle->opacity())));	2044	opacityVector.insert(new FloatAnimationValue(1, compositingOpacity(toStyle->opacity())));
2042	// The boxSize param is only used for transform animations (which can only run on RenderBoxes), so we pass an empty size here.	2045	// The boxSize param is only used for transform animations (which can only run on RenderBoxes), so we pass an empty size here.
2043	if (m_graphicsLayer->addAnimation(opacityVector, IntSize(), opacityAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyOpacity), timeOffset)) {	2046	if (m_graphicsLayer->addAnimation(opacityVector, IntSize(), IntSize(), opacityAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyOpacity), timeOffset)) {
2044	// To ensure that the correct opacity is visible when the animation ends, also set the final opacity.	2047	// To ensure that the correct opacity is visible when the animation ends, also set the final opacity.
2045	updateOpacity(toStyle);	2048	updateOpacity(toStyle);
2046	didAnimateOpacity = true;	2049	didAnimateOpacity = true;
Lines 2054-2060 bool RenderLayerBacking::startTransition(double timeOffset, CSSPropertyID proper a/Source/WebCore/rendering/RenderLayerBacking.cpp_sec6
2054	KeyframeValueList transformVector(AnimatedPropertyWebkitTransform);	2057	KeyframeValueList transformVector(AnimatedPropertyWebkitTransform);
2055	transformVector.insert(new TransformAnimationValue(0, &fromStyle->transform()));	2058	transformVector.insert(new TransformAnimationValue(0, &fromStyle->transform()));
2056	transformVector.insert(new TransformAnimationValue(1, &toStyle->transform()));	2059	transformVector.insert(new TransformAnimationValue(1, &toStyle->transform()));
2057	if (m_graphicsLayer->addAnimation(transformVector, toRenderBox(renderer())->pixelSnappedBorderBoxRect().size(), transformAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyWebkitTransform), timeOffset)) {	2060	if (m_graphicsLayer->addAnimation(transformVector, toRenderBox(renderer())->pixelSnappedBorderBoxRect().size(), renderer()->view()->viewportSize(), transformAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyWebkitTransform), timeOffset)) {
2058	// To ensure that the correct transform is visible when the animation ends, also set the final transform.	2061	// To ensure that the correct transform is visible when the animation ends, also set the final transform.
2059	updateTransform(toStyle);	2062	updateTransform(toStyle);
2060	didAnimateTransform = true;	2063	didAnimateTransform = true;
Lines 2069-2075 bool RenderLayerBacking::startTransition(double timeOffset, CSSPropertyID proper a/Source/WebCore/rendering/RenderLayerBacking.cpp_sec7
2069	KeyframeValueList filterVector(AnimatedPropertyWebkitFilter);	2072	KeyframeValueList filterVector(AnimatedPropertyWebkitFilter);
2070	filterVector.insert(new FilterAnimationValue(0, &fromStyle->filter()));	2073	filterVector.insert(new FilterAnimationValue(0, &fromStyle->filter()));
2071	filterVector.insert(new FilterAnimationValue(1, &toStyle->filter()));	2074	filterVector.insert(new FilterAnimationValue(1, &toStyle->filter()));
2072	if (m_graphicsLayer->addAnimation(filterVector, IntSize(), filterAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyWebkitFilter), timeOffset)) {	2075	if (m_graphicsLayer->addAnimation(filterVector, IntSize(), IntSize(), filterAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyWebkitFilter), timeOffset)) {
2073	// To ensure that the correct filter is visible when the animation ends, also set the final filter.	2076	// To ensure that the correct filter is visible when the animation ends, also set the final filter.
2074	updateFilters(toStyle);	2077	updateFilters(toStyle);
2075	didAnimateFilter = true;	2078	didAnimateFilter = true;

Lines 285-291 void RenderMarquee::timerFired(Timer<RenderMarquee>*) a/Source/WebCore/rendering/RenderMarquee.cpp_sec1
- a/Source/WebCore/rendering/RenderMarquee.cpp -1 / +1 lines
285	}	285	}
286	bool positive = range > 0;	286	bool positive = range > 0;
287	int clientSize = (isHorizontal() ? m_layer->renderBox()->clientWidth() : m_layer->renderBox()->clientHeight());	287	int clientSize = (isHorizontal() ? m_layer->renderBox()->clientWidth() : m_layer->renderBox()->clientHeight());
288	int increment = abs(intValueForLength(m_layer->renderer()->style()->marqueeIncrement(), clientSize));	288	int increment = abs(m_layer->renderer()->intValueForLength(m_layer->renderer()->style()->marqueeIncrement(), clientSize));
289	int currentPos = (isHorizontal() ? m_layer->scrollXOffset() : m_layer->scrollYOffset());	289	int currentPos = (isHorizontal() ? m_layer->scrollXOffset() : m_layer->scrollYOffset());
290	newPos = currentPos + (addIncrement ? increment : -increment);	290	newPos = currentPos + (addIncrement ? increment : -increment);
291	if (positive)	291	if (positive)

Lines 175-181 void RenderMenuList::updateOptionsWidth() a/Source/WebCore/rendering/RenderMenuList.cpp_sec1
- a/Source/WebCore/rendering/RenderMenuList.cpp -1 / +1 lines
175	// Add in the option's text indent. We can't calculate percentage values for now.	175	// Add in the option's text indent. We can't calculate percentage values for now.
176	float optionWidth = 0;	176	float optionWidth = 0;
177	if (RenderStyle* optionStyle = element->renderStyle())	177	if (RenderStyle* optionStyle = element->renderStyle())
178	optionWidth += minimumValueForLength(optionStyle->textIndent(), 0, view());	178	optionWidth += minimumValueForLength(optionStyle->textIndent(), 0);
179	if (!text.isEmpty())	179	if (!text.isEmpty())
180	optionWidth += style()->font().width(text);	180	optionWidth += style()->font().width(text);
181	maxOptionWidth = max(maxOptionWidth, optionWidth);	181	maxOptionWidth = max(maxOptionWidth, optionWidth);



#include "GraphicsContext.h"
#include "HTMLElement.h"
#include "HTMLNames.h"
#include "LengthFunctions.h"
#include "Page.h"
#include "RenderArena.h"
#include "RenderCounter.h"

        int borderRight = isBox() ? toRenderBox(this)->borderRight() : 0;
        LayoutUnit boxWidth = isBox() ? toRenderBox(this)->width() : LayoutUnit();
        LayoutUnit minInsetRightShadowExtent = min<LayoutUnit>(-insetShadowExtent.right(), min<LayoutUnit>(newBounds.width(), oldBounds.width()));
        LayoutUnit borderWidth = max<LayoutUnit>(borderRight, max<LayoutUnit>(valueForLength(style()->borderTopRightRadius().width(), boxWidth), valueForLength(style()->borderBottomRightRadius().width(), boxWidth)));
        LayoutUnit decorationsWidth = max<LayoutUnit>(-outlineStyle->outlineOffset(), borderWidth + minInsetRightShadowExtent) + max<LayoutUnit>(outlineWidth, shadowRight);
        LayoutRect rightRect(newOutlineBox.x() + min(newOutlineBox.width(), oldOutlineBox.width()) - decorationsWidth,
            newOutlineBox.y(),

        int borderBottom = isBox() ? toRenderBox(this)->borderBottom() : 0;
        LayoutUnit boxHeight = isBox() ? toRenderBox(this)->height() : LayoutUnit();
        LayoutUnit minInsetBottomShadowExtent = min<LayoutUnit>(-insetShadowExtent.bottom(), min<LayoutUnit>(newBounds.height(), oldBounds.height()));
        LayoutUnit borderHeight = max<LayoutUnit>(borderBottom, max<LayoutUnit>(valueForLength(style()->borderBottomLeftRadius().height(), boxHeight), valueForLength(style()->borderBottomRightRadius().height(), boxHeight)));
        LayoutUnit decorationsHeight = max<LayoutUnit>(-outlineStyle->outlineOffset(), borderHeight + minInsetBottomShadowExtent) + max<LayoutUnit>(outlineWidth, shadowBottom);
        LayoutRect bottomRect(newOutlineBox.x(),
            min(newOutlineBox.maxY(), oldOutlineBox.maxY()) - decorationsHeight,

    info.setCustomAllocation(true);
}

static IntSize optionalViewportSize(const RenderObject* renderer, const Length& length)
{
    return length.isViewportPercentage() ? renderer->view()->viewportSize() : IntSize();
}

int RenderObject::minimumIntValueForLength(const Length& length, LayoutUnit maximumValue, bool roundPercentages) const
{
    return WebCore::minimumIntValueForLength(length, maximumValue, optionalViewportSize(this, length), roundPercentages);
}

int RenderObject::intValueForLength(const Length& length, LayoutUnit maximumValue, bool roundPercentages) const
{
    return WebCore::intValueForLength(length, maximumValue, optionalViewportSize(this, length), roundPercentages);
}

LayoutUnit RenderObject::minimumValueForLength(const Length& length, LayoutUnit maximumValue, bool roundPercentages) const
{
    return WebCore::minimumValueForLength(length, maximumValue, optionalViewportSize(this, length), roundPercentages);
}

LayoutUnit RenderObject::valueForLength(const Length& length, LayoutUnit maximumValue, bool roundPercentages) const
{
    return WebCore::valueForLength(length, maximumValue, optionalViewportSize(this, length), roundPercentages);
}

float RenderObject::floatValueForLength(const Length& length, LayoutUnit maximumValue) const
{
    return WebCore::valueForLength(length, maximumValue, optionalViewportSize(this, length));
}

float RenderObject::floatValueForLength(const Length& length, float maximumValue) const
{
    return WebCore::valueForLength(length, maximumValue, optionalViewportSize(this, length));
}

#if ENABLE(SVG)

RenderSVGResourceContainer* RenderObject::toRenderSVGResourceContainer()

Lines 267-272 public: a/Source/WebCore/rendering/RenderObject.h_sec1
- a/Source/WebCore/rendering/RenderObject.h +7 lines
267		267
268	virtual void reportMemoryUsage(MemoryObjectInfo*) const;	268	virtual void reportMemoryUsage(MemoryObjectInfo*) const;
269		269
		270	int minimumIntValueForLength(const Length&, LayoutUnit maximumValue, bool roundPercentages = false) const;
		271	int intValueForLength(const Length&, LayoutUnit maximumValue, bool roundPercentages = false) const;
		272	LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue, bool roundPercentages = false) const;
		273	LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue, bool roundPercentages = false) const;
		274	float floatValueForLength(const Length&, LayoutUnit maximumValue) const;
		275	float floatValueForLength(const Length&, float maximumValue) const;
		276
270	protected:	277	protected:
271	//////////////////////////////////////////	278	//////////////////////////////////////////
272	// Helper functions. Dangerous to use!	279	// Helper functions. Dangerous to use!

Lines 147-153 void RenderReplaced::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset) a/Source/WebCore/rendering/RenderReplaced.cpp_sec1
- a/Source/WebCore/rendering/RenderReplaced.cpp -1 / +1 lines
147	else {	147	else {
148	// Push a clip if we have a border radius, since we want to round the foreground content that gets painted.	148	// Push a clip if we have a border radius, since we want to round the foreground content that gets painted.
149	paintInfo.context->save();	149	paintInfo.context->save();
150	RoundedRect roundedInnerRect = style()->getRoundedInnerBorderFor(paintRect,	150	RoundedRect roundedInnerRect = style()->getRoundedInnerBorderFor(paintRect, this,
151	paddingTop() + borderTop(), paddingBottom() + borderBottom(), paddingLeft() + borderLeft(), paddingRight() + borderRight(), true, true);	151	paddingTop() + borderTop(), paddingBottom() + borderBottom(), paddingLeft() + borderLeft(), paddingRight() + borderRight(), true, true);
152	clipRoundedInnerRect(paintInfo.context, paintRect, roundedInnerRect);	152	clipRoundedInnerRect(paintInfo.context, paintRect, roundedInnerRect);
153	}	153	}



    } 
}

static int calcScrollbarThicknessUsing(SizeType sizeType, const Length& length, int containingLength, const IntSize& viewportSize)
{
    if (!length.isIntrinsicOrAuto() || (sizeType == MinSize && length.isAuto()))
        return minimumValueForLength(length, containingLength, viewportSize);
    return ScrollbarTheme::theme()->scrollbarThickness();
}


{
    if (!m_scrollbar->owningRenderer())
        return;
    const IntSize& viewportSize = view()->viewportSize();
    // FIXME: We are querying layout information but nothing guarantees that it's up-to-date, especially since we are called at style change.
    // FIXME: Querying the style's border information doesn't work on table cells with collapsing borders.
    int visibleSize = m_scrollbar->owningRenderer()->width() - m_scrollbar->owningRenderer()->style()->borderLeftWidth() - m_scrollbar->owningRenderer()->style()->borderRightWidth();
    int w = calcScrollbarThicknessUsing(MainOrPreferredSize, style()->width(), visibleSize, viewportSize);
    int minWidth = calcScrollbarThicknessUsing(MinSize, style()->minWidth(), visibleSize, viewportSize);
    int maxWidth = style()->maxWidth().isUndefined() ? w : calcScrollbarThicknessUsing(MaxSize, style()->maxWidth(), visibleSize, viewportSize);
    setWidth(max(minWidth, min(maxWidth, w)));
    
    // Buttons and track pieces can all have margins along the axis of the scrollbar. 
    m_marginBox.setLeft(minimumValueForLength(style()->marginLeft(), visibleSize));
    m_marginBox.setRight(minimumValueForLength(style()->marginRight(), visibleSize));
}

void RenderScrollbarPart::computeScrollbarHeight()
{
    if (!m_scrollbar->owningRenderer())
        return;
    const IntSize& viewportSize = view()->viewportSize();
    // FIXME: We are querying layout information but nothing guarantees that it's up-to-date, especially since we are called at style change.
    // FIXME: Querying the style's border information doesn't work on table cells with collapsing borders.
    int visibleSize = m_scrollbar->owningRenderer()->height() -  m_scrollbar->owningRenderer()->style()->borderTopWidth() - m_scrollbar->owningRenderer()->style()->borderBottomWidth();
    int h = calcScrollbarThicknessUsing(MainOrPreferredSize, style()->height(), visibleSize, viewportSize);
    int minHeight = calcScrollbarThicknessUsing(MinSize, style()->minHeight(), visibleSize, viewportSize);
    int maxHeight = style()->maxHeight().isUndefined() ? h : calcScrollbarThicknessUsing(MaxSize, style()->maxHeight(), visibleSize, viewportSize);
    setHeight(max(minHeight, min(maxHeight, h)));

    // Buttons and track pieces can all have margins along the axis of the scrollbar. 
    m_marginBox.setTop(minimumValueForLength(style()->marginTop(), visibleSize));
    m_marginBox.setBottom(minimumValueForLength(style()->marginBottom(), visibleSize));
}

void RenderScrollbarPart::computePreferredLogicalWidths()



    }

    RenderBlock* cb = containingBlock();
    RenderView* renderView = view();

    LayoutUnit availableLogicalWidth = containingBlockLogicalWidthForContent();
    bool hasPerpendicularContainingBlock = cb->style()->isHorizontalWritingMode() != style()->isHorizontalWritingMode();

        setLogicalWidth(convertStyleLogicalWidthToComputedWidth(styleLogicalWidth, containerWidthInInlineDirection));
    else {
        // Subtract out any fixed margins from our available width for auto width tables.
        LayoutUnit marginStart = minimumValueForLength(style()->marginStart(), availableLogicalWidth);
        LayoutUnit marginEnd = minimumValueForLength(style()->marginEnd(), availableLogicalWidth);
        LayoutUnit marginTotal = marginStart + marginEnd;

        // Subtract out our margins to get the available content width.

        setMarginStart(marginValues.m_start);
        setMarginEnd(marginValues.m_end);
    } else {
        setMarginStart(minimumValueForLength(style()->marginStart(), availableLogicalWidth));
        setMarginEnd(minimumValueForLength(style()->marginEnd(), availableLogicalWidth));
    }
}


    if (isCSSTable && styleLogicalWidth.isSpecified() && styleLogicalWidth.isPositive() && style()->boxSizing() == CONTENT_BOX)
            borders = borderStart() + borderEnd() + (collapseBorders() ? LayoutUnit() : paddingStart() + paddingEnd());

    return minimumValueForLength(styleLogicalWidth, availableWidth) + borders;
}

LayoutUnit RenderTable::convertStyleLogicalHeightToComputedHeight(const Length& styleLogicalHeight)

    } else if (styleLogicalHeight.isPercent())
        computedLogicalHeight = computePercentageLogicalHeight(styleLogicalHeight);
    else if (styleLogicalHeight.isViewportPercentage())
        computedLogicalHeight = minimumValueForLength(styleLogicalHeight, 0);
    else
        ASSERT_NOT_REACHED();
    return max<LayoutUnit>(0, computedLogicalHeight);




#include "RenderTableRow.h"
#include "RenderTableSection.h"
#include "RenderView.h"

namespace WebCore {


    {
        // FIXME: This function does too much work, and is very hot during table layout!
        int adjustedLogicalHeight = pixelSnappedLogicalHeight() - (intrinsicPaddingBefore() + intrinsicPaddingAfter());
        int styleLogicalHeight = valueForLength(style()->logicalHeight(), 0);
        // In strict mode, box-sizing: content-box do the right thing and actually add in the border and padding.
        // Call computedCSSPadding* directly to avoid including implicitPadding.
        if (!document()->inQuirksMode() && style()->boxSizing() != BORDER_BOX)

Lines 283-289 int RenderTableSection::calcRowLogicalHeight() a/Source/WebCore/rendering/RenderTableSection.cpp_sec1
- a/Source/WebCore/rendering/RenderTableSection.cpp -1 / +1 lines
283	LayoutUnit baselineDescent = 0;	283	LayoutUnit baselineDescent = 0;
284		284
285	// Our base size is the biggest logical height from our cells' styles (excluding row spanning cells).	285	// Our base size is the biggest logical height from our cells' styles (excluding row spanning cells).
286	m_rowPos[r + 1] = max(m_rowPos[r] + minimumValueForLength(m_grid[r].logicalHeight, 0, viewRenderer).round(), 0);	286	m_rowPos[r + 1] = max(m_rowPos[r] + minimumValueForLength(m_grid[r].logicalHeight, 0).round(), 0);
287		287
288	Row& row = m_grid[r].row;	288	Row& row = m_grid[r].row;
289	unsigned totalCols = row.size();	289	unsigned totalCols = row.size();



    virtual LayoutRect selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool clipToVisibleContent = true) OVERRIDE;
    virtual LayoutRect localCaretRect(InlineBox*, int caretOffset, LayoutUnit* extraWidthToEndOfLine = 0);

    virtual LayoutUnit marginLeft() const { return minimumValueForLength(style()->marginLeft(), 0); }
    virtual LayoutUnit marginRight() const { return minimumValueForLength(style()->marginRight(), 0); }

    virtual LayoutRect clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const OVERRIDE;


Lines 1093-1099 void RenderThemeMacShared::paintMenuListButtonGradients(RenderObject* o, const P a/Source/WebCore/rendering/RenderThemeMacShared.mm_sec1
- a/Source/WebCore/rendering/RenderThemeMacShared.mm -1 / +1 lines
1093		1093
1094	GraphicsContextStateSaver stateSaver(*paintInfo.context);	1094	GraphicsContextStateSaver stateSaver(*paintInfo.context);
1095		1095
1096	RoundedRect border = o->style()->getRoundedBorderFor(r, o->view());	1096	RoundedRect border = o->style()->getRoundedBorderFor(r, o);
1097	int radius = border.radii().topLeft().width();	1097	int radius = border.radii().topLeft().width();
1098		1098
1099	CGColorSpaceRef cspace = deviceRGBColorSpaceRef();	1099	CGColorSpaceRef cspace = deviceRGBColorSpaceRef();

Lines 305-311 void RenderWidget::paint(PaintInfo& paintInfo, const LayoutPoint& paintOffset) a/Source/WebCore/rendering/RenderWidget.cpp_sec1
- a/Source/WebCore/rendering/RenderWidget.cpp -1 / +1 lines
305		305
306	// Push a clip if we have a border radius, since we want to round the foreground content that gets painted.	306	// Push a clip if we have a border radius, since we want to round the foreground content that gets painted.
307	paintInfo.context->save();	307	paintInfo.context->save();
308	RoundedRect roundedInnerRect = style()->getRoundedInnerBorderFor(borderRect,	308	RoundedRect roundedInnerRect = style()->getRoundedInnerBorderFor(borderRect, this,
309	paddingTop() + borderTop(), paddingBottom() + borderBottom(), paddingLeft() + borderLeft(), paddingRight() + borderRight(), true, true);	309	paddingTop() + borderTop(), paddingBottom() + borderBottom(), paddingLeft() + borderLeft(), paddingRight() + borderRight(), true, true);
310	clipRoundedInnerRect(paintInfo.context, borderRect, roundedInnerRect);	310	clipRoundedInnerRect(paintInfo.context, borderRect, roundedInnerRect);
311	}	311	}



            LayoutUnit lineHeight;
            //Per http://www.w3.org/TR/CSS21/visudet.html#propdef-vertical-align: 'Percentages: refer to the 'line-height' of the element itself'.
            if (renderer->style()->verticalAlignLength().isPercent())
                lineHeight = renderer->style()->computedLineHeight(renderer);
            else
                lineHeight = renderer->lineHeight(firstLine, lineDirection);
            verticalPosition -= renderer->valueForLength(renderer->style()->verticalAlignLength(), lineHeight);
        }
    }




    return true;
}

void BasicShapeRectangle::path(Path& path, const FloatRect& boundingBox, const IntSize& viewportSize)
{
    ASSERT(path.isEmpty());
    path.addRoundedRect(FloatRect(floatValueForLength(m_x, boundingBox.width(), viewportSize) + boundingBox.x(),
                                  floatValueForLength(m_y, boundingBox.height(), viewportSize) + boundingBox.y(),
                                  floatValueForLength(m_width, boundingBox.width(), viewportSize),
                                  floatValueForLength(m_height, boundingBox.height(), viewportSize)),
                        FloatSize(m_cornerRadiusX.isUndefined() ? 0 : floatValueForLength(m_cornerRadiusX, boundingBox.width(), viewportSize),
                                  m_cornerRadiusY.isUndefined() ? 0 : floatValueForLength(m_cornerRadiusY, boundingBox.height(), viewportSize)));
}

PassRefPtr<BasicShape> BasicShapeRectangle::blend(const BasicShape* other, double progress) const

    return result.release();
}

void BasicShapeCircle::path(Path& path, const FloatRect& boundingBox, const IntSize& viewportSize)
{
    ASSERT(path.isEmpty());
    float diagonal = sqrtf((boundingBox.width() * boundingBox.width() + boundingBox.height() * boundingBox.height()) / 2);
    float centerX = floatValueForLength(m_centerX, boundingBox.width(), viewportSize);
    float centerY = floatValueForLength(m_centerY, boundingBox.height(), viewportSize);
    float radius = floatValueForLength(m_radius, diagonal, viewportSize);
    path.addEllipse(FloatRect(centerX - radius + boundingBox.x(),
                              centerY - radius + boundingBox.y(),
                              radius * 2,

    return result.release();
}

void BasicShapeEllipse::path(Path& path, const FloatRect& boundingBox, const IntSize& viewportSize)
{
    ASSERT(path.isEmpty());
    float centerX = floatValueForLength(m_centerX, boundingBox.width(), viewportSize);
    float centerY = floatValueForLength(m_centerY, boundingBox.height(), viewportSize);
    float radiusX = floatValueForLength(m_radiusX, boundingBox.width(), viewportSize);
    float radiusY = floatValueForLength(m_radiusY, boundingBox.height(), viewportSize);
    path.addEllipse(FloatRect(centerX - radiusX + boundingBox.x(),
                              centerY - radiusY + boundingBox.y(),
                              radiusX * 2,

    return result.release();
}

void BasicShapePolygon::path(Path& path, const FloatRect& boundingBox, const IntSize& viewportSize)
{
    ASSERT(path.isEmpty());
    ASSERT(!(m_values.size() % 2));

    if (!length)
        return;

    path.moveTo(FloatPoint(floatValueForLength(m_values.at(0), boundingBox.width(), viewportSize) + boundingBox.x(),
        floatValueForLength(m_values.at(1), boundingBox.height(), viewportSize) + boundingBox.y()));
    for (size_t i = 2; i < length; i = i + 2) {
        path.addLineTo(FloatPoint(floatValueForLength(m_values.at(i), boundingBox.width(), viewportSize) + boundingBox.x(),
            floatValueForLength(m_values.at(i + 1), boundingBox.height(), viewportSize) + boundingBox.y()));
    }
    path.closeSubpath();
}




    bool canBlend(const BasicShape*) const;

    virtual void path(Path&, const FloatRect&, const IntSize& viewportSize) = 0;
    virtual WindRule windRule() const { return RULE_NONZERO; }
    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const = 0;


    void setCornerRadiusX(Length radiusX) { m_cornerRadiusX = radiusX; }
    void setCornerRadiusY(Length radiusY) { m_cornerRadiusY = radiusY; }

    virtual void path(Path&, const FloatRect&, const IntSize& viewportSize) OVERRIDE;
    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;

    virtual Type type() const { return BASIC_SHAPE_RECTANGLE; }

    void setCenterY(Length centerY) { m_centerY = centerY; }
    void setRadius(Length radius) { m_radius = radius; }

    virtual void path(Path&, const FloatRect&, const IntSize& viewportSize) OVERRIDE;
    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;

    virtual Type type() const { return BASIC_SHAPE_CIRCLE; }

    void setRadiusX(Length radiusX) { m_radiusX = radiusX; }
    void setRadiusY(Length radiusY) { m_radiusY = radiusY; }

    virtual void path(Path&, const FloatRect&, const IntSize& viewportSize) OVERRIDE;
    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;

    virtual Type type() const { return BASIC_SHAPE_ELLIPSE; } 

    void setWindRule(WindRule windRule) { m_windRule = windRule; }
    void appendPoint(Length x, Length y) { m_values.append(x); m_values.append(y); }

    virtual void path(Path&, const FloatRect&, const IntSize& viewportSize) OVERRIDE;
    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;

    virtual WindRule windRule() const { return m_windRule; }




    Length specifiedLineHeight() const;
    Length lineHeight() const;
    int computedLineHeight(const RenderObject* renderer) const;

    EWhiteSpace whiteSpace() const { return static_cast<EWhiteSpace>(inherited_flags._white_space); }
    static bool autoWrap(EWhiteSpace ws)

    bool hasTransformRelatedProperty() const { return hasTransform() || preserves3D() || hasPerspective(); }

    enum ApplyTransformOrigin { IncludeTransformOrigin, ExcludeTransformOrigin };
    void applyTransform(TransformationMatrix&, const LayoutSize& borderBoxSize, const RenderObject* renderer, ApplyTransformOrigin = IncludeTransformOrigin) const;
    void applyTransform(TransformationMatrix&, const FloatRect& boundingBox, const RenderObject* renderer, ApplyTransformOrigin = IncludeTransformOrigin) const;
    void setPageScaleTransform(float);

    bool hasMask() const { return rareNonInheritedData->m_mask.hasImage() || rareNonInheritedData->m_maskBoxImage.hasImage(); }

        setBorderRadius(LengthSize(Length(s.width(), Fixed), Length(s.height(), Fixed)));
    }
    
    RoundedRect getRoundedBorderFor(const LayoutRect& borderRect, const RenderObject* renderer, bool includeLogicalLeftEdge = true, bool includeLogicalRightEdge = true) const;
    RoundedRect getRoundedInnerBorderFor(const LayoutRect& borderRect, const RenderObject* renderer, bool includeLogicalLeftEdge = true, bool includeLogicalRightEdge = true) const;

    RoundedRect getRoundedInnerBorderFor(const LayoutRect& borderRect, const RenderObject* renderer,
        int topWidth, int bottomWidth, int leftWidth, int rightWidth, bool includeLogicalLeftEdge, bool includeLogicalRightEdge) const;

    void setBorderLeftWidth(unsigned v) { SET_VAR(surround, border.m_left.m_width, v); }



    return frame->document()->isSVGDocument();
}

static inline LayoutUnit resolveLengthAttributeForSVG(const Length& length, float scale, float maxSize, const IntSize& viewportSize)
{
    return static_cast<LayoutUnit>(valueForLength(length, maxSize, viewportSize) * (length.isFixed() ? scale : 1));
}

LayoutUnit RenderSVGRoot::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const

        return RenderReplaced::computeReplacedLogicalWidth(shouldComputePreferred);

    if (svg->widthAttributeEstablishesViewport())
        return resolveLengthAttributeForSVG(svg->intrinsicWidth(SVGSVGElement::IgnoreCSSProperties), style()->effectiveZoom(), containingBlock()->availableLogicalWidth(), view()->viewportSize());

    // SVG embedded through object/embed/iframe.
    if (isEmbeddedThroughFrameContainingSVGDocument())

        } else
            RenderBlock::removePercentHeightDescendant(const_cast<RenderSVGRoot*>(this));

        return resolveLengthAttributeForSVG(height, style()->effectiveZoom(), containingBlock()->availableLogicalHeight(IncludeMarginBorderPadding), view()->viewportSize());
    }

    // SVG embedded through object/embed/iframe.



#include "RenderSVGResourceClipper.h"
#include "RenderSVGResourceFilter.h"
#include "RenderSVGResourceMasker.h"
#include "RenderView.h"
#include "SVGResources.h"
#include "SVGResourcesCache.h"


    ClipPathOperation* clipPathOperation = style->clipPath();
    if (clipPathOperation && clipPathOperation->getOperationType() == ClipPathOperation::SHAPE) {
        ShapeClipPathOperation* clipPath = static_cast<ShapeClipPathOperation*>(clipPathOperation);
        m_paintInfo->context->clipPath(clipPath->path(object->objectBoundingBox(), m_object->view()->viewportSize()), clipPath->windRule());
    }

    SVGResources* resources = SVGResourcesCache::cachedResourcesForRenderObject(m_object);




    // If no viewBox is specified but non-relative width/height values, then we
    // should always synthesize a viewBox if we're embedded through a SVGImage.    
    return FloatRect(FloatPoint(), FloatSize(floatValueForLength(intrinsicWidth, 0, IntSize()), floatValueForLength(intrinsicHeight, 0, IntSize())));
}

FloatSize SVGSVGElement::currentViewportSize() const

    Length intrinsicWidth = this->intrinsicWidth();
    Length intrinsicHeight = this->intrinsicHeight();
    if (intrinsicWidth.isFixed() && intrinsicHeight.isFixed())
        return FloatSize(floatValueForLength(intrinsicWidth, 0, IntSize()), floatValueForLength(intrinsicHeight, 0, IntSize()));

    if (!renderer())
        return FloatSize();

Lines 71-77 AffineTransform SVGStyledTransformableElement::animatedLocalTransform() const a/Source/WebCore/svg/SVGStyledTransformableElement.cpp_sec1
- a/Source/WebCore/svg/SVGStyledTransformableElement.cpp -1 / +1 lines
71	// Note: objectBoundingBox is an emptyRect for elements like pattern or clipPath.	71	// Note: objectBoundingBox is an emptyRect for elements like pattern or clipPath.
72	// See the "Object bounding box units" section of http://dev.w3.org/csswg/css3-transforms/	72	// See the "Object bounding box units" section of http://dev.w3.org/csswg/css3-transforms/
73	TransformationMatrix transform;	73	TransformationMatrix transform;
74	style->applyTransform(transform, renderer()->objectBoundingBox());	74	style->applyTransform(transform, renderer()->objectBoundingBox(), renderer());
75		75
76	// Flatten any 3D transform.	76	// Flatten any 3D transform.
77	matrix = transform.toAffineTransform();	77	matrix = transform.toAffineTransform();

Lines 117-123 AffineTransform SVGTextElement::animatedLocalTransform() const a/Source/WebCore/svg/SVGTextElement.cpp_sec1
- a/Source/WebCore/svg/SVGTextElement.cpp -1 / +1 lines
117	TransformationMatrix t;	117	TransformationMatrix t;
118	// For now, the transform-origin is not taken into account	118	// For now, the transform-origin is not taken into account
119	// Also, any percentage values will not be taken into account	119	// Also, any percentage values will not be taken into account
120	style->applyTransform(t, IntSize(0, 0), RenderStyle::ExcludeTransformOrigin);	120	style->applyTransform(t, IntSize(), renderer(), RenderStyle::ExcludeTransformOrigin);
121	// Flatten any 3D transform	121	// Flatten any 3D transform
122	matrix = t.toAffineTransform();	122	matrix = t.toAffineTransform();
123	} else	123	} else

Lines 265-271 void SVGImage::computeIntrinsicDimensions(Length& intrinsicWidth, Length& intrin a/Source/WebCore/svg/graphics/SVGImage.cpp_sec1
- a/Source/WebCore/svg/graphics/SVGImage.cpp -1 / +1 lines
265		265
266	intrinsicRatio = rootElement->viewBox().size();	266	intrinsicRatio = rootElement->viewBox().size();
267	if (intrinsicRatio.isEmpty() && intrinsicWidth.isFixed() && intrinsicHeight.isFixed())	267	if (intrinsicRatio.isEmpty() && intrinsicWidth.isFixed() && intrinsicHeight.isFixed())
268	intrinsicRatio = FloatSize(floatValueForLength(intrinsicWidth, 0), floatValueForLength(intrinsicHeight, 0));	268	intrinsicRatio = FloatSize(floatValueForLength(intrinsicWidth, 0, IntSize()), floatValueForLength(intrinsicHeight, 0, IntSize()));
269	}	269	}
270		270
271	// FIXME: support catchUpIfNecessary.	271	// FIXME: support catchUpIfNecessary.




bool animationCanBeTranslated(const KeyframeValueList& values, Animation* animation)
{
    IntSize boxSize, viewportSize;
    return createWebAnimation(values, animation, 0, 0, boxSize, viewportSize);
}

TEST(AnimationTranslationUtilTest, createOpacityAnimation)



2013-03-11  Timothy Loh  <timloh@chromium.org>

        viewport units (vw, vh) don't work in CSS transforms
        https://bugs.webkit.org/show_bug.cgi?id=91554

        Reviewed by NOBODY (OOPS!).

        WIP

        * css3/calc/simple-calcs-expected.txt:
        * css3/calc/simple-calcs-prefixed-expected.txt:
        * css3/calc/simple-calcs-prefixed.html:
        * css3/calc/simple-calcs.html:
        * transforms/2d/transform-2d-expected.txt:
        * transforms/2d/transform-2d.html:

2013-03-09  Sheriff Bot  <webkit.review.bot@gmail.com>

        Unreviewed, rolling out r145299.

Lines 44-46 control => PASS a/LayoutTests/css3/calc/simple-calcs-expected.txt_sec1
- a/LayoutTests/css3/calc/simple-calcs-expected.txt +5 lines
44	(((((((100px))))))) => PASS	44	(((((((100px))))))) => PASS
45	100px => PASS	45	100px => PASS
46	100% * 2 => PASS	46	100% * 2 => PASS
		47	12.5vw => PASS
		48	20vh - 20px => PASS
		49	10vmax + 20px => PASS
		50	50vmin / 3 => PASS
		51	(4vw + 3vh)*2 => PASS

Lines 46-48 control => PASS a/LayoutTests/css3/calc/simple-calcs-prefixed-expected.txt_sec1
- a/LayoutTests/css3/calc/simple-calcs-prefixed-expected.txt +5 lines
46	(((((((100px))))))) => PASS	46	(((((((100px))))))) => PASS
47	100px => PASS	47	100px => PASS
48	100% * 2 => PASS	48	100% * 2 => PASS
		49	12.5vw => PASS
		50	20vh - 20px => PASS
		51	10vmax + 20px => PASS
		52	50vmin / 3 => PASS
		53	(4vw + 3vh)*2 => PASS

Lines 85-90 a/LayoutTests/css3/calc/simple-calcs-prefixed.html_sec1
- a/LayoutTests/css3/calc/simple-calcs-prefixed.html +5 lines
85	<div style="height: 50px; background-color: white;" class="wrapper">	85	<div style="height: 50px; background-color: white;" class="wrapper">
86	<div class="height-test" style="height: -webkit-calc(100% * 2);">100% * 2</div>	86	<div class="height-test" style="height: -webkit-calc(100% * 2);">100% * 2</div>
87	</div>	87	</div>
		88	<div class="width-test" style="width: -webkit-calc(12.5vw);">12.5vw</div>
		89	<div class="width-test" style="width: -webkit-calc(20vh - 20px);">20vh - 20px</div>
		90	<div class="width-test" style="width: -webkit-calc(10vmax + 20px);">10vmax + 20px</div>
		91	<div class="width-test" style="width: -webkit-calc(50vmin / 3);">50vmin / 3</div>
		92	<div class="width-test" style="width: -webkit-calc((4vw + 3vh)2);">(4vw + 3vh)2</div>
88	</div>	93	</div>
89		94
90	<script>	95	<script>

Lines 82-87 a/LayoutTests/css3/calc/simple-calcs.html_sec1
- a/LayoutTests/css3/calc/simple-calcs.html +5 lines
82	<div style="height: 50px; background-color: white;" class="wrapper">	82	<div style="height: 50px; background-color: white;" class="wrapper">
83	<div class="height-test" style="height: calc(100% * 2);">100% * 2</div>	83	<div class="height-test" style="height: calc(100% * 2);">100% * 2</div>
84	</div>	84	</div>
		85	<div class="width-test" style="width: -webkit-calc(12.5vw);">12.5vw</div>
		86	<div class="width-test" style="width: -webkit-calc(20vh - 20px);">20vh - 20px</div>
		87	<div class="width-test" style="width: -webkit-calc(10vmax + 20px);">10vmax + 20px</div>
		88	<div class="width-test" style="width: -webkit-calc(50vmin / 3);">50vmin / 3</div>
		89	<div class="width-test" style="width: -webkit-calc((4vw + 3vh)2);">(4vw + 3vh)2</div>
85	</div>	90	</div>
86		91
87	<script>	92	<script>



transform "inherit" expected "none" : PASS
transform "translate(80px, 90px)" expected "matrix(1, 0, 0, 1, 80, 90)" : PASS
transform "translate(100%, 3em)" expected "matrix(1, 0, 0, 1, 200, 48)" : PASS
transform "translate(30vw, -60vh)" expected "matrix(1, 0, 0, 1, 240, -360)" : PASS
transform "translate(50px)" expected "matrix(1, 0, 0, 1, 50, 0)" : PASS
transform "translatex(-20px)" expected "matrix(1, 0, 0, 1, -20, 0)" : PASS
transform "translateX(-20px)" expected "matrix(1, 0, 0, 1, -20, 0)" : PASS
transform "translateX(20vmax)" expected "matrix(1, 0, 0, 1, 160, 0)" : PASS
transform "translatey(23px)" expected "matrix(1, 0, 0, 1, 0, 23)" : PASS
transform "translateY(-3em)" expected "matrix(1, 0, 0, 1, 0, -48)" : PASS
transform "translateY(20vmin)" expected "matrix(1, 0, 0, 1, 0, 120)" : PASS
transform "scale(1.2)" expected "matrix(1.2, 0, 0, 1.2, 0, 0)" : PASS
transform "scalex(1.5)" expected "matrix(1.5, 0, 0, 1, 0, 0)" : PASS
transform "scaleX(1.5)" expected "matrix(1.5, 0, 0, 1, 0, 0)" : PASS

Lines 38-48 a/LayoutTests/transforms/2d/transform-2d.html_sec1
- a/LayoutTests/transforms/2d/transform-2d.html +3 lines
38	// translate	38	// translate
39	{ 'transform' : 'translate(80px, 90px)', 'result' : 'matrix(1, 0, 0, 1, 80, 90)' },	39	{ 'transform' : 'translate(80px, 90px)', 'result' : 'matrix(1, 0, 0, 1, 80, 90)' },
40	{ 'transform' : 'translate(100%, 3em)', 'result' : 'matrix(1, 0, 0, 1, 200, 48)' }, // depends on font size	40	{ 'transform' : 'translate(100%, 3em)', 'result' : 'matrix(1, 0, 0, 1, 200, 48)' }, // depends on font size
		41	{ 'transform' : 'translate(30vw, -60vh)', 'result' : 'matrix(1, 0, 0, 1, 240, -360)' },
41	{ 'transform' : 'translate(50px)', 'result' : 'matrix(1, 0, 0, 1, 50, 0)' },	42	{ 'transform' : 'translate(50px)', 'result' : 'matrix(1, 0, 0, 1, 50, 0)' },
42	{ 'transform' : 'translatex(-20px)', 'result' : 'matrix(1, 0, 0, 1, -20, 0)' },	43	{ 'transform' : 'translatex(-20px)', 'result' : 'matrix(1, 0, 0, 1, -20, 0)' },
43	{ 'transform' : 'translateX(-20px)', 'result' : 'matrix(1, 0, 0, 1, -20, 0)' },	44	{ 'transform' : 'translateX(-20px)', 'result' : 'matrix(1, 0, 0, 1, -20, 0)' },
		45	{ 'transform' : 'translateX(20vmax)', 'result' : 'matrix(1, 0, 0, 1, 160, 0)' },
44	{ 'transform' : 'translatey(23px)', 'result' : 'matrix(1, 0, 0, 1, 0, 23)' },	46	{ 'transform' : 'translatey(23px)', 'result' : 'matrix(1, 0, 0, 1, 0, 23)' },
45	{ 'transform' : 'translateY(-3em)', 'result' : 'matrix(1, 0, 0, 1, 0, -48)' }, // depends on font size	47	{ 'transform' : 'translateY(-3em)', 'result' : 'matrix(1, 0, 0, 1, 0, -48)' }, // depends on font size
		48	{ 'transform' : 'translateY(20vmin)', 'result' : 'matrix(1, 0, 0, 1, 0, 120)' },
46		49
47	// scale	50	// scale
48	{ 'transform' : 'scale(1.2)', 'result' : 'matrix(1.2, 0, 0, 1.2, 0, 0)' },	51	{ 'transform' : 'scale(1.2)', 'result' : 'matrix(1.2, 0, 0, 1.2, 0, 0)' },

Return to Bug 91554

Lines 481-530 double CSSPrimitiveValue::computeDegrees() a/Source/WebCore/css/CSSPrimitiveValue.cpp_sec1
- a/Source/WebCore/css/CSSPrimitiveValue.cpp -17 / +30 lines
481	}	481	}
482	}	482	}
483		483
484	template<> int CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, float multiplier, bool computingFontSize)	484	template<> int CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
485	{	485	{
486	return roundForImpreciseConversion<int>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));	486	return roundForImpreciseConversion<int>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize));
487	}	487	}
488		488
489	template<> unsigned CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, float multiplier, bool computingFontSize)	489	template<> unsigned CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
490	{	490	{
491	return roundForImpreciseConversion<unsigned>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));	491	return roundForImpreciseConversion<unsigned>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize));
492	}	492	}
493		493
494	template<> Length CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, float multiplier, bool computingFontSize)	494	template<> Length CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
495	{	495	{
496	#if ENABLE(SUBPIXEL_LAYOUT)	496	#if ENABLE(SUBPIXEL_LAYOUT)
497	return Length(clampTo<float>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize), minValueForCssLength, maxValueForCssLength), Fixed);	497	return Length(clampTo<float>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize), minValueForCssLength, maxValueForCssLength), Fixed);
498	#else	498	#else
499	return Length(clampTo<float>(roundForImpreciseConversion<float>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize)), minValueForCssLength, maxValueForCssLength), Fixed);	499	return Length(clampTo<float>(roundForImpreciseConversion<float>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize)), minValueForCssLength, maxValueForCssLength), Fixed);
500	#endif	500	#endif
501	}	501	}
502		502
503	template<> short CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, float multiplier, bool computingFontSize)	503	template<> short CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
504	{	504	{
505	return roundForImpreciseConversion<short>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));	505	return roundForImpreciseConversion<short>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize));
506	}	506	}
507		507
508	template<> unsigned short CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, float multiplier, bool computingFontSize)	508	template<> unsigned short CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
509	{	509	{
510	return roundForImpreciseConversion<unsigned short>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));	510	return roundForImpreciseConversion<unsigned short>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize));
511	}	511	}
512		512
513	template<> float CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, float multiplier, bool computingFontSize)	513	template<> float CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
514	{	514	{
515	return static_cast<float>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));	515	return static_cast<float>(computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize));
516	}	516	}
517		517
518	template<> double CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, float multiplier, bool computingFontSize)	518	template<> double CSSPrimitiveValue::computeLength(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
519	{	519	{
520	return computeLengthDouble(style, rootStyle, multiplier, computingFontSize);	520	return computeLengthDouble(style, rootStyle, viewportSize, multiplier, computingFontSize);
521	}	521	}
522		522
523	double CSSPrimitiveValue::computeLengthDouble(RenderStyle* style, RenderStyle* rootStyle, float multiplier, bool computingFontSize)	523	double CSSPrimitiveValue::computeLengthDouble(RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize)
524	{	524	{
525	if (m_primitiveUnitType == CSS_CALC)	525	if (m_primitiveUnitType == CSS_CALC)
526	// The multiplier and factor is applied to each value in the calc expression individually	526	// The multiplier and factor is applied to each value in the calc expression individually
527	return m_value.calc->computeLengthPx(style, rootStyle, multiplier, computingFontSize);	527	return m_value.calc->computeLengthPx(style, rootStyle, viewportSize, multiplier, computingFontSize);
528		528
529	double factor;	529	double factor;
530		530
Lines 569-574 double CSSPrimitiveValue::computeLengthDouble(RenderStyle* style, RenderStyle* r a/Source/WebCore/css/CSSPrimitiveValue.cpp_sec2
569	// 1 pc == 12 pt	569	// 1 pc == 12 pt
570	factor = cssPixelsPerInch * 12.0 / 72.0;	570	factor = cssPixelsPerInch * 12.0 / 72.0;
571	break;	571	break;
		572	case CSS_VW:
		573	factor = viewportSize.width() / 100.0;
		574	break;
		575	case CSS_VH:
		576	factor = viewportSize.height() / 100.0;
		577	break;
		578	case CSS_VMIN:
		579	factor = std::min(viewportSize.width(), viewportSize.height()) / 100.0;
		580	break;
		581	case CSS_VMAX:
		582	factor = std::max(viewportSize.width(), viewportSize.height()) / 100.0;
		583	break;
572	case CSS_CALC_PERCENTAGE_WITH_LENGTH:	584	case CSS_CALC_PERCENTAGE_WITH_LENGTH:
573	case CSS_CALC_PERCENTAGE_WITH_NUMBER:	585	case CSS_CALC_PERCENTAGE_WITH_NUMBER:
574	ASSERT_NOT_REACHED();	586	ASSERT_NOT_REACHED();
Lines 1318-1323 bool CSSPrimitiveValue::equals(const CSSPrimitiveValue& other) const a/Source/WebCore/css/CSSPrimitiveValue.cpp_sec3
1318	case CSS_VW:	1330	case CSS_VW:
1319	case CSS_VH:	1331	case CSS_VH:
1320	case CSS_VMIN:	1332	case CSS_VMIN:
		1333	case CSS_VMAX:
1321	case CSS_DIMENSION:	1334	case CSS_DIMENSION:
1322	return m_value.num == other.m_value.num;	1335	return m_value.num == other.m_value.num;
1323	case CSS_IDENT:	1336	case CSS_IDENT:

Lines 4183-4200 template<int supported> Length CSSPrimitiveValue::convertToLength(RenderStyle* s a/Source/WebCore/css/CSSPrimitiveValueMappings.h_sec1
- a/Source/WebCore/css/CSSPrimitiveValueMappings.h -4 / +4 lines
4183	#endif	4183	#endif
4184	if ((supported & (FixedIntegerConversion \| FixedFloatConversion)) && isFontRelativeLength() && (!style \|\| !rootStyle))	4184	if ((supported & (FixedIntegerConversion \| FixedFloatConversion)) && isFontRelativeLength() && (!style \|\| !rootStyle))
4185	return Length(Undefined);	4185	return Length(Undefined);
		4186	if ((supported & CalculatedConversion) && isCalculated())
		4187	return Length(cssCalcValue()->toCalcValue(style, rootStyle, multiplier));
4186	if ((supported & FixedIntegerConversion) && isLength())	4188	if ((supported & FixedIntegerConversion) && isLength())
4187	return computeLength<Length>(style, rootStyle, multiplier, computingFontSize);	4189	return computeLength<Length>(style, rootStyle, IntSize(), multiplier, computingFontSize);
4188	if ((supported & FixedFloatConversion) && isLength())	4190	if ((supported & FixedFloatConversion) && isLength())
4189	return Length(computeLength<double>(style, rootStyle, multiplier), Fixed);	4191	return Length(computeLength<double>(style, rootStyle, IntSize(), multiplier), Fixed);
4190	if ((supported & PercentConversion) && isPercentage())	4192	if ((supported & PercentConversion) && isPercentage())
4191	return Length(getDoubleValue(), Percent);	4193	return Length(getDoubleValue(), Percent);
4192	if ((supported & FractionConversion) && isNumber())	4194	if ((supported & FractionConversion) && isNumber())
4193	return Length(getDoubleValue() * 100.0, Percent);	4195	return Length(getDoubleValue() * 100.0, Percent);
4194	if ((supported & AutoConversion) && getIdent() == CSSValueAuto)	4196	if ((supported & AutoConversion) && getIdent() == CSSValueAuto)
4195	return Length(Auto);	4197	return Length(Auto);
4196	if ((supported & CalculatedConversion) && isCalculated())
4197	return Length(cssCalcValue()->toCalcValue(style, rootStyle, multiplier));
4198	if ((supported & ViewportPercentageConversion) && isViewportPercentageLength())	4198	if ((supported & ViewportPercentageConversion) && isViewportPercentageLength())
4199	return viewportPercentageLength();	4199	return viewportPercentageLength();
4200	return Length(Undefined);	4200	return Length(Undefined);

Lines 424-430 static bool gridMediaFeatureEval(CSSValue* value, RenderStyle, Frame, MediaFea a/Source/WebCore/css/MediaQueryEvaluator.cpp_sec1
- a/Source/WebCore/css/MediaQueryEvaluator.cpp -6 / +6 lines
424	return false;	424	return false;
425	}	425	}
426		426
427	static bool computeLength(CSSValue* value, bool strict, RenderStyle* style, RenderStyle* rootStyle, int& result)	427	static bool computeLength(CSSValue* value, bool strict, RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, int& result)
428	{	428	{
429	if (!value->isPrimitiveValue())	429	if (!value->isPrimitiveValue())
430	return false;	430	return false;
Lines 437-443 static bool computeLength(CSSValue* value, bool strict, RenderStyle* style, Rend a/Source/WebCore/css/MediaQueryEvaluator.cpp_sec2
437	}	437	}
438		438
439	if (primitiveValue->isLength()) {	439	if (primitiveValue->isLength()) {
440	result = primitiveValue->computeLength<int>(style, rootStyle);	440	result = primitiveValue->computeLength<int>(style, rootStyle, viewportSize);
441	return true;	441	return true;
442	}	442	}
443		443
Lines 452-458 static bool device_heightMediaFeatureEval(CSSValue* value, RenderStyle* style, F a/Source/WebCore/css/MediaQueryEvaluator.cpp_sec3
452	int length;	452	int length;
453	long height = sg.height();	453	long height = sg.height();
454	InspectorInstrumentation::applyScreenHeightOverride(frame, &height);	454	InspectorInstrumentation::applyScreenHeightOverride(frame, &height);
455	return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(static_cast<int>(height), length, op);	455	return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, frame->document()->viewportSize(), length) && compareValue(static_cast<int>(height), length, op);
456	}	456	}
457	// ({,min-,max-}device-height)	457	// ({,min-,max-}device-height)
458	// assume if we have a device, assume non-zero	458	// assume if we have a device, assume non-zero
Lines 467-473 static bool device_widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Fr a/Source/WebCore/css/MediaQueryEvaluator.cpp_sec4
467	int length;	467	int length;
468	long width = sg.width();	468	long width = sg.width();
469	InspectorInstrumentation::applyScreenWidthOverride(frame, &width);	469	InspectorInstrumentation::applyScreenWidthOverride(frame, &width);
470	return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(static_cast<int>(width), length, op);	470	return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, frame->document()->viewportSize(), length) && compareValue(static_cast<int>(width), length, op);
471	}	471	}
472	// ({,min-,max-}device-width)	472	// ({,min-,max-}device-width)
473	// assume if we have a device, assume non-zero	473	// assume if we have a device, assume non-zero
Lines 484-490 static bool heightMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* f a/Source/WebCore/css/MediaQueryEvaluator.cpp_sec5
484	height = adjustForAbsoluteZoom(height, renderView);	484	height = adjustForAbsoluteZoom(height, renderView);
485	RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();	485	RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
486	int length;	486	int length;
487	return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(height, length, op);	487	return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, frame->document()->viewportSize(), length) && compareValue(height, length, op);
488	}	488	}
489		489
490	return view->layoutHeight() != 0;	490	return view->layoutHeight() != 0;
Lines 500-506 static bool widthMediaFeatureEval(CSSValue* value, RenderStyle* style, Frame* fr a/Source/WebCore/css/MediaQueryEvaluator.cpp_sec6
500	width = adjustForAbsoluteZoom(width, renderView);	500	width = adjustForAbsoluteZoom(width, renderView);
501	RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();	501	RenderStyle* rootStyle = frame->document()->documentElement()->renderStyle();
502	int length;	502	int length;
503	return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, length) && compareValue(width, length, op);	503	return computeLength(value, !frame->document()->inQuirksMode(), style, rootStyle, frame->document()->viewportSize(), length) && compareValue(width, length, op);
504	}	504	}
505		505
506	return view->layoutWidth() != 0;	506	return view->layoutWidth() != 0;

Lines 564-573 void StyleResolver::applySVGProperty(CSSPropertyID id, CSSValue* value) a/Source/WebCore/css/SVGCSSStyleSelector.cpp_sec1
- a/Source/WebCore/css/SVGCSSStyleSelector.cpp -3 / +5 lines
564	CSSValue* firstValue = list->itemWithoutBoundsCheck(0);	564	CSSValue* firstValue = list->itemWithoutBoundsCheck(0);
565	if (!firstValue->isShadowValue())	565	if (!firstValue->isShadowValue())
566	return;	566	return;
		567
567	ShadowValue* item = static_cast<ShadowValue*>(firstValue);	568	ShadowValue* item = static_cast<ShadowValue*>(firstValue);
568	IntPoint location(item->x->computeLength<int>(state.style(), state.rootElementStyle()),	569	const IntSize& viewportSize = state.document()->viewportSize();
569	item->y->computeLength<int>(state.style(), state.rootElementStyle()));	570	IntPoint location(item->x->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize),
570	int blur = item->blur ? item->blur->computeLength<int>(state.style(), state.rootElementStyle()) : 0;	571	item->y->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize));
		572	int blur = item->blur ? item->blur->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize) : 0;
571	Color color;	573	Color color;
572	if (item->color)	574	if (item->color)
573	color = colorFromPrimitiveValue(item->color.get());	575	color = colorFromPrimitiveValue(item->color.get());

Lines 3164-3173 void StyleResolver::applyProperty(CSSPropertyID id, CSSValue* value) a/Source/WebCore/css/StyleResolver.cpp_sec1
- a/Source/WebCore/css/StyleResolver.cpp -13 / +14 lines
3164	if (!currValue->isShadowValue())	3164	if (!currValue->isShadowValue())
3165	continue;	3165	continue;
3166	ShadowValue* item = static_cast<ShadowValue*>(currValue);	3166	ShadowValue* item = static_cast<ShadowValue*>(currValue);
3167	int x = item->x->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor);	3167	const IntSize& viewportSize = state.document()->viewportSize();
3168	int y = item->y->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor);	3168	int x = item->x->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize, zoomFactor);
3169	int blur = item->blur ? item->blur->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor) : 0;	3169	int y = item->y->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize, zoomFactor);
3170	int spread = item->spread ? item->spread->computeLength<int>(state.style(), state.rootElementStyle(), zoomFactor) : 0;	3170	int blur = item->blur ? item->blur->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize, zoomFactor) : 0;
		3171	int spread = item->spread ? item->spread->computeLength<int>(state.style(), state.rootElementStyle(), viewportSize, zoomFactor) : 0;
3171	ShadowStyle shadowStyle = item->style && item->style->getIdent() == CSSValueInset ? Inset : Normal;	3172	ShadowStyle shadowStyle = item->style && item->style->getIdent() == CSSValueInset ? Inset : Normal;
3172	Color color;	3173	Color color;
3173	if (item->color)	3174	if (item->color)
Lines 3343-3353 void StyleResolver::applyProperty(CSSPropertyID id, CSSValue* value) a/Source/WebCore/css/StyleResolver.cpp_sec2
3343	result *= 3;	3344	result *= 3;
3344	else if (primitiveValue->getIdent() == CSSValueThick)	3345	else if (primitiveValue->getIdent() == CSSValueThick)
3345	result *= 5;	3346	result *= 5;
3346	width = CSSPrimitiveValue::create(result, CSSPrimitiveValue::CSS_EMS)->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);	3347	width = CSSPrimitiveValue::create(result, CSSPrimitiveValue::CSS_EMS)->computeLength<float>(state.style(), state.rootElementStyle(), IntSize(), zoomFactor);
3347	break;	3348	break;
3348	}	3349	}
3349	default:	3350	default:
3350	width = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);	3351	width = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), state.document()->viewportSize(), zoomFactor);
3351	break;	3352	break;
3352	}	3353	}
3353	state.style()->setTextStrokeWidth(width);	3354	state.style()->setTextStrokeWidth(width);
Lines 3373-3382 void StyleResolver::applyProperty(CSSPropertyID id, CSSValue* value) a/Source/WebCore/css/StyleResolver.cpp_sec3
3373		3374
3374	float perspectiveValue;	3375	float perspectiveValue;
3375	if (primitiveValue->isLength())	3376	if (primitiveValue->isLength())
3376	perspectiveValue = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);	3377	perspectiveValue = primitiveValue->computeLength<float>(state.style(), state.rootElementStyle(), IntSize(), zoomFactor);
3377	else if (primitiveValue->isNumber()) {	3378	else if (primitiveValue->isNumber()) {
3378	// For backward compatibility, treat valueless numbers as px.	3379	// For backward compatibility, treat valueless numbers as px.
3379	perspectiveValue = CSSPrimitiveValue::create(primitiveValue->getDoubleValue(), CSSPrimitiveValue::CSS_PX)->computeLength<float>(state.style(), state.rootElementStyle(), zoomFactor);	3380	perspectiveValue = CSSPrimitiveValue::create(primitiveValue->getDoubleValue(), CSSPrimitiveValue::CSS_PX)->computeLength<float>(state.style(), state.rootElementStyle(), IntSize(), zoomFactor);
3380	} else	3381	} else
3381	return;	3382	return;
3382		3383
Lines 3530-3536 void StyleResolver::applyProperty(CSSPropertyID id, CSSValue* value) a/Source/WebCore/css/StyleResolver.cpp_sec4
3530	case CSSPropertyWebkitFilter: {	3531	case CSSPropertyWebkitFilter: {
3531	HANDLE_INHERIT_AND_INITIAL(filter, Filter);	3532	HANDLE_INHERIT_AND_INITIAL(filter, Filter);
3532	FilterOperations operations;	3533	FilterOperations operations;
3533	if (createFilterOperations(value, state.style(), state.rootElementStyle(), operations))	3534	if (createFilterOperations(value, state.style(), state.rootElementStyle(), state.document()->viewportSize(), operations))
3534	state.style()->setFilter(operations);	3535	state.style()->setFilter(operations);
3535	return;	3536	return;
3536	}	3537	}
Lines 4841-4847 PassRefPtr<CustomFilterOperation> StyleResolver::createCustomFilterOperation(Web a/Source/WebCore/css/StyleResolver.cpp_sec5
4841		4842
4842	#endif	4843	#endif
4843		4844
4844	bool StyleResolver::createFilterOperations(CSSValue* inValue, RenderStyle* style, RenderStyle* rootStyle, FilterOperations& outOperations)	4845	bool StyleResolver::createFilterOperations(CSSValue* inValue, RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, FilterOperations& outOperations)
4845	{	4846	{
4846	ASSERT(outOperations.isEmpty());	4847	ASSERT(outOperations.isEmpty());
4847		4848
Lines 4976-4984 bool StyleResolver::createFilterOperations(CSSValue* inValue, RenderStyle* style a/Source/WebCore/css/StyleResolver.cpp_sec6
4976	continue;	4977	continue;
4977		4978
4978	ShadowValue* item = static_cast<ShadowValue*>(cssValue);	4979	ShadowValue* item = static_cast<ShadowValue*>(cssValue);
4979	IntPoint location(item->x->computeLength<int>(style, rootStyle, zoomFactor),	4980	IntPoint location(item->x->computeLength<int>(style, rootStyle, viewportSize, zoomFactor),
4980	item->y->computeLength<int>(style, rootStyle, zoomFactor));	4981	item->y->computeLength<int>(style, rootStyle, viewportSize, zoomFactor));
4981	int blur = item->blur ? item->blur->computeLength<int>(style, rootStyle, zoomFactor) : 0;	4982	int blur = item->blur ? item->blur->computeLength<int>(style, rootStyle, viewportSize, zoomFactor) : 0;
4982	Color color;	4983	Color color;
4983	if (item->color)	4984	if (item->color)
4984	color = colorFromPrimitiveValue(item->color.get());	4985	color = colorFromPrimitiveValue(item->color.get());

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +354 lines
		1	2013-03-11 Timothy Loh <timloh@chromium.org>
		2
		3	viewport units (vw, vh) don't work in CSS transforms
		4	https://bugs.webkit.org/show_bug.cgi?id=91554
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	WIP.
		9	Change optional RenderView* parameter in valueForLength functions to a const IntSize&.
		10	Add equivalent valueForLength functions to RenderObject which call the regular ones,
		11	so we don't have to compute the viewportSize all the time.
		12
		13	No new tests (OOPS!).
		14
		15	* accessibility/atk/WebKitAccessibleInterfaceText.cpp:
		16	(getAttributeSetForAccessibilityObject):
		17	* css/CSSCalculationValue.cpp:
		18	(WebCore::unitCategory):
		19	(WebCore::CSSCalcValue::computeLengthPx):
		20	(WebCore::CSSCalcPrimitiveValue::toCalcValue):
		21	(WebCore::CSSCalcPrimitiveValue::computeLengthPx):
		22	(WebCore::CSSCalcBinaryOperation::computeLengthPx):
		23	* css/CSSCalculationValue.h:
		24	(CSSCalcValue):
		25	* css/CSSComputedStyleDeclaration.cpp:
		26	(WebCore::getPositionOffsetValue):
		27	(WebCore::getBorderRadiusCornerValues):
		28	(WebCore::getBorderRadiusCornerValue):
		29	(WebCore::getBorderRadiusShorthandValue):
		30	(WebCore::computedTransform):
		31	(WebCore::valueForCustomFilterTransformParameter):
		32	(WebCore::valueForGridTrackBreadth):
		33	(WebCore::valueForGridTrackMinMax):
		34	(WebCore::valueForGridTrackGroup):
		35	(WebCore::valueForGridTrackList):
		36	(WebCore::lineHeightFromStyle):
		37	(WebCore::CSSComputedStyleDeclaration::getPropertyCSSValue):
		38	* css/CSSGradientValue.cpp:
		39	(WebCore::CSSGradientValue::addStops):
		40	(WebCore::positionFromValue):
		41	(WebCore::CSSGradientValue::computeEndPoint):
		42	(WebCore::CSSLinearGradientValue::createGradient):
		43	(WebCore::CSSRadialGradientValue::resolveRadius):
		44	(WebCore::CSSRadialGradientValue::createGradient):
		45	* css/CSSGradientValue.h:
		46	(CSSGradientValue):
		47	(CSSRadialGradientValue):
		48	* css/CSSPrimitiveValue.cpp:
		49	(WebCore::CSSPrimitiveValue::computeLength):
		50	(WebCore::CSSPrimitiveValue::computeLengthDouble):
		51	(WebCore::CSSPrimitiveValue::equals):
		52	* css/CSSPrimitiveValue.h:
		53	(CSSPrimitiveValue):
		54	* css/CSSPrimitiveValueMappings.h:
		55	(WebCore::CSSPrimitiveValue::convertToLength):
		56	* css/CSSToStyleMap.cpp:
		57	(WebCore::CSSToStyleMap::mapFillXPosition):
		58	(WebCore::CSSToStyleMap::mapFillYPosition):
		59	(WebCore::CSSToStyleMap::mapNinePieceImageQuad):
		60	* css/LengthFunctions.cpp:
		61	(WebCore::minimumIntValueForLength):
		62	(WebCore::intValueForLength):
		63	(WebCore::minimumValueForLength):
		64	(WebCore::valueForLength):
65	(WebCore::floatValueForLength):
66	* css/LengthFunctions.h:
67	(WebCore):
68	* css/MediaQueryEvaluator.cpp:
69	(WebCore::computeLength):
70	(WebCore::device_heightMediaFeatureEval):
71	(WebCore::device_widthMediaFeatureEval):
72	(WebCore::heightMediaFeatureEval):
73	(WebCore::widthMediaFeatureEval):
74	* css/SVGCSSStyleSelector.cpp:
75	(WebCore::StyleResolver::applySVGProperty):
76	* css/StyleBuilder.cpp:
77	(WebCore::ApplyPropertyAuto::applyValue):
78	(WebCore::ApplyPropertyLength::applyValue):
79	(WebCore::ApplyPropertyBorderRadius::applyValue):
80	(WebCore::ApplyPropertyComputeLength::applyValue):
81	(WebCore::ApplyPropertyFontSize::applyValue):
82	(WebCore::ApplyPropertyLineHeight::applyValue):
83	(WebCore::ApplyPropertyPageSize::mmLength):
84	(WebCore::ApplyPropertyPageSize::inchLength):
85	(WebCore::ApplyPropertyPageSize::applyValue):
86	* css/StyleResolver.cpp:
87	(WebCore::StyleResolver::applyProperty):
88	(WebCore::StyleResolver::createFilterOperations):
89	* css/StyleResolver.h:
90	(StyleResolver):
91	* css/WebKitCSSMatrix.cpp:
92	(WebCore::WebKitCSSMatrix::setMatrixValue):
93	* dom/Document.cpp:
94	(WebCore::Document::pageSizeAndMarginsInPixels):
95	* html/HTMLAreaElement.cpp:
96	(WebCore::HTMLAreaElement::getRegion):
97	* page/animation/CSSPropertyAnimation.cpp:
98	(WebCore::blendFunc):
99	* platform/CalculationValue.cpp:
100	(WebCore::CalcExpressionBinaryOperation::evaluate):
101	(WebCore::CalculationValue::evaluate):
102	* platform/CalculationValue.h:
103	(CalcExpressionNode):
104	(CalculationValue):
105	(WebCore::CalcExpressionNumber::evaluate):
106	(WebCore::CalcExpressionLength::evaluate):
107	(CalcExpressionBinaryOperation):
108	(WebCore::CalcExpressionBlendLength::evaluate):
109	* platform/Length.cpp:
110	(WebCore::Length::nonNanCalculatedValue):
111	* platform/Length.h:
112	(Length):
113	* platform/graphics/GraphicsLayer.h:
114	(WebCore::GraphicsLayer::addAnimation):
115	* platform/graphics/GraphicsLayerAnimation.cpp:
116	(WebCore::blendFunc):
117	(WebCore::applyFilterAnimation):
118	(WebCore::applyTransformAnimation):
119	(WebCore::GraphicsLayerAnimation::applyInternal):
120	(WebCore::GraphicsLayerAnimation::apply):
121	(WebCore::GraphicsLayerAnimations::apply):
122	* platform/graphics/GraphicsLayerAnimation.h:
123	(GraphicsLayerAnimation):
124	(GraphicsLayerAnimations):
125	* platform/graphics/chromium/AnimationTranslationUtil.cpp:
126	(WebCore::toWebTransformOperations):
127	(WebCore::appendKeyframeWithStandardTimingFunction):
128	(WebCore::appendKeyframeWithCustomBezierTimingFunction):
129	(WebCore::WebTransformAnimationCurve):
130	(WebCore::createWebAnimation):
131	* platform/graphics/chromium/AnimationTranslationUtil.h:
132	(WebCore):
133	* platform/graphics/chromium/GraphicsLayerChromium.cpp:
134	(WebCore::GraphicsLayerChromium::addAnimation):
135	* platform/graphics/chromium/GraphicsLayerChromium.h:
136	(GraphicsLayerChromium):
137	* platform/graphics/filters/CustomFilterArrayParameter.h:
138	(WebCore::CustomFilterArrayParameter::blend):
139	* platform/graphics/filters/CustomFilterNumberParameter.h:
140	(WebCore::CustomFilterNumberParameter::blend):
141	* platform/graphics/filters/CustomFilterOperation.cpp:
142	(WebCore::CustomFilterOperation::blend):
143	* platform/graphics/filters/CustomFilterOperation.h:
144	(CustomFilterOperation):
145	* platform/graphics/filters/CustomFilterParameter.h:
146	(CustomFilterParameter):
147	* platform/graphics/filters/CustomFilterParameterList.cpp:
148	(WebCore::CustomFilterParameterList::blend):
149	* platform/graphics/filters/CustomFilterParameterList.h:
150	(CustomFilterParameterList):
151	* platform/graphics/filters/CustomFilterRenderer.cpp:
152	(WebCore::CustomFilterRenderer::bindProgramTransformParameter):
153	* platform/graphics/filters/CustomFilterTransformParameter.h:
154	(WebCore::CustomFilterTransformParameter::blend):
155	(WebCore::CustomFilterTransformParameter::applyTransform):
156	* platform/graphics/filters/FilterOperation.h:
157	(WebCore::FilterOperation::FilterOperation::blend):
158	* platform/graphics/filters/FilterOperations.cpp:
159	(WebCore::FilterOperations::outsets):
160	* platform/graphics/filters/ValidatedCustomFilterOperation.cpp:
161	(WebCore::ValidatedCustomFilterOperation::blend):
162	* platform/graphics/filters/ValidatedCustomFilterOperation.h:
163	(ValidatedCustomFilterOperation):
164	* platform/graphics/transforms/IdentityTransformOperation.h:
165	(WebCore::IdentityTransformOperation::apply):
166	(WebCore::IdentityTransformOperation::blend):
167	* platform/graphics/transforms/Matrix3DTransformOperation.cpp:
168	(WebCore::Matrix3DTransformOperation::blend):
169	* platform/graphics/transforms/Matrix3DTransformOperation.h:
170	(WebCore::Matrix3DTransformOperation::apply):
171	(Matrix3DTransformOperation):
172	* platform/graphics/transforms/MatrixTransformOperation.cpp:
173	(WebCore::MatrixTransformOperation::blend):
174	* platform/graphics/transforms/MatrixTransformOperation.h:
175	(WebCore::MatrixTransformOperation::apply):
176	(MatrixTransformOperation):
177	* platform/graphics/transforms/PerspectiveTransformOperation.cpp:
178	(WebCore::PerspectiveTransformOperation::blend):
179	* platform/graphics/transforms/PerspectiveTransformOperation.h:
180	(WebCore::PerspectiveTransformOperation::isIdentity):
181	(WebCore::PerspectiveTransformOperation::apply):
182	(PerspectiveTransformOperation):
183	* platform/graphics/transforms/RotateTransformOperation.cpp:
184	(WebCore::RotateTransformOperation::blend):
185	* platform/graphics/transforms/RotateTransformOperation.h:
186	(WebCore::RotateTransformOperation::apply):
187	(RotateTransformOperation):
188	* platform/graphics/transforms/ScaleTransformOperation.cpp:
189	(WebCore::ScaleTransformOperation::blend):
190	* platform/graphics/transforms/ScaleTransformOperation.h:
191	(WebCore::ScaleTransformOperation::apply):
192	(ScaleTransformOperation):
193	* platform/graphics/transforms/SkewTransformOperation.cpp:
194	(WebCore::SkewTransformOperation::blend):
195	* platform/graphics/transforms/SkewTransformOperation.h:
196	(WebCore::SkewTransformOperation::apply):
197	(SkewTransformOperation):
198	* platform/graphics/transforms/TransformOperation.h:
199	(TransformOperation):
200	* platform/graphics/transforms/TransformOperations.cpp:
201	(WebCore::TransformOperations::blendByMatchingOperations):
202	(WebCore::TransformOperations::blendByUsingMatrixInterpolation):
203	(WebCore::TransformOperations::blend):
204	* platform/graphics/transforms/TransformOperations.h:
205	(WebCore::TransformOperations::apply):
206	(TransformOperations):
207	* platform/graphics/transforms/TranslateTransformOperation.cpp:
208	(WebCore::TranslateTransformOperation::blend):
209	* platform/graphics/transforms/TranslateTransformOperation.h:
210	(WebCore::TranslateTransformOperation::x):
211	(WebCore::TranslateTransformOperation::y):
212	(WebCore::TranslateTransformOperation::z):
213	(WebCore::TranslateTransformOperation::isIdentity):
214	(WebCore::TranslateTransformOperation::apply):
215	(TranslateTransformOperation):
216	* rendering/AutoTableLayout.cpp:
217	(WebCore::AutoTableLayout::layout):
218	* rendering/ClipPathOperation.h:
219	(WebCore::ShapeClipPathOperation::path):
220	* rendering/ExclusionShape.cpp:
221	(WebCore::ExclusionShape::createExclusionShape):
222	* rendering/ExclusionShape.h:
223	(ExclusionShape):
224	* rendering/ExclusionShapeInfo.cpp:
225	(WebCore::::computedShape):
226	* rendering/FilterEffectRenderer.cpp:
227	(WebCore::FilterEffectRenderer::build):
228	* rendering/FixedTableLayout.cpp:
229	(WebCore::FixedTableLayout::layout):
230	* rendering/RenderBlock.cpp:
231	(WebCore::RenderBlock::textIndentOffset):
232	(WebCore::RenderBlock::computeInlinePreferredLogicalWidths):
233	* rendering/RenderBox.cpp:
234	(WebCore::RenderBox::reflectionOffset):
235	(WebCore::RenderBox::paintBoxDecorations):
236	(WebCore::RenderBox::pushContentsClip):
237	(WebCore::RenderBox::clipRect):
238	(WebCore::RenderBox::computeLogicalWidthInRegion):
239	(WebCore::RenderBox::fillAvailableMeasure):
240	(WebCore::RenderBox::computeLogicalWidthInRegionUsing):
241	(WebCore::RenderBox::computeInlineDirectionMargins):
242	(WebCore::RenderBox::computeContentAndScrollbarLogicalHeightUsing):
243	(WebCore::RenderBox::computeReplacedLogicalWidthUsing):
244	(WebCore::RenderBox::computeReplacedLogicalHeightUsing):
245	(WebCore::RenderBox::computeBlockDirectionMargins):
246	(WebCore::RenderBox::computePositionedLogicalWidthUsing):
247	(WebCore::RenderBox::computePositionedLogicalHeightUsing):
248	(WebCore::RenderBox::computePositionedLogicalWidthReplaced):
249	(WebCore::RenderBox::computePositionedLogicalHeightReplaced):
250	* rendering/RenderBoxModelObject.cpp:
251	(WebCore::RenderBoxModelObject::relativePositionOffset):
252	(WebCore::RenderBoxModelObject::computeStickyPositionConstraints):
253	(WebCore::RenderBoxModelObject::computedCSSPadding):
254	(WebCore::RenderBoxModelObject::getBackgroundRoundedRect):
255	(WebCore::RenderBoxModelObject::backgroundRoundedRectAdjustedForBleedAvoidance):
256	(WebCore::RenderBoxModelObject::paintFillLayerExtended):
257	(WebCore::RenderBoxModelObject::calculateFillTileSize):
258	(WebCore::RenderBoxModelObject::calculateBackgroundImageGeometry):
259	(WebCore::computeBorderImageSide):
260	(WebCore::RenderBoxModelObject::paintNinePieceImage):
261	(WebCore::RenderBoxModelObject::paintBorder):
262	(WebCore::RenderBoxModelObject::drawBoxSideFromPath):
263	(WebCore::RenderBoxModelObject::paintBoxShadow):
264	* rendering/RenderFlexibleBox.cpp:
265	(WebCore::RenderFlexibleBox::computeMainAxisExtentForChild):
266	(WebCore::RenderFlexibleBox::computeChildMarginValue):
267	* rendering/RenderGrid.cpp:
268	(WebCore::RenderGrid::computeUsedBreadthOfSpecifiedLength):
269	* rendering/RenderInline.cpp:
270	(WebCore::computeMargin):
271	* rendering/RenderLayer.cpp:
272	(WebCore::RenderLayer::updateTransform):
273	(WebCore::RenderLayer::currentTransform):
274	(WebCore::RenderLayer::perspectiveTransform):
275	(WebCore::RenderLayer::perspectiveOrigin):
276	(WebCore::RenderLayer::clipToRect):
277	(WebCore::RenderLayer::paintLayerContents):
278	* rendering/RenderLayerBacking.cpp:
279	(WebCore::RenderLayerBacking::updateTransform):
280	(WebCore::RenderLayerBacking::computeTransformOrigin):
281	(WebCore::RenderLayerBacking::computePerspectiveOrigin):
282	(WebCore::RenderLayerBacking::startAnimation):
283	(WebCore::RenderLayerBacking::startTransition):
284	* rendering/RenderMarquee.cpp:
285	(WebCore::RenderMarquee::timerFired):
286	* rendering/RenderMenuList.cpp:
287	(WebCore::RenderMenuList::updateOptionsWidth):
288	* rendering/RenderObject.cpp:
289	(WebCore::RenderObject::repaintAfterLayoutIfNeeded):
290	(WebCore::optionalViewportSize):
291	(WebCore):
292	(WebCore::RenderObject::minimumIntValueForLength):
293	(WebCore::RenderObject::intValueForLength):
294	(WebCore::RenderObject::minimumValueForLength):
295	(WebCore::RenderObject::valueForLength):
296	(WebCore::RenderObject::floatValueForLength):
297	* rendering/RenderObject.h:
298	(RenderObject):
299	* rendering/RenderReplaced.cpp:
300	(WebCore::RenderReplaced::paint):
301	* rendering/RenderScrollbarPart.cpp:
302	(WebCore::calcScrollbarThicknessUsing):
303	(WebCore::RenderScrollbarPart::computeScrollbarWidth):
304	(WebCore::RenderScrollbarPart::computeScrollbarHeight):
305	* rendering/RenderTable.cpp:
306	(WebCore::RenderTable::updateLogicalWidth):
307	(WebCore::RenderTable::convertStyleLogicalWidthToComputedWidth):
308	(WebCore::RenderTable::convertStyleLogicalHeightToComputedHeight):
309	* rendering/RenderTableCell.h:
310	(WebCore::RenderTableCell::logicalHeightForRowSizing):
311	* rendering/RenderTableSection.cpp:
312	(WebCore::RenderTableSection::calcRowLogicalHeight):
313	* rendering/RenderText.h:
314	(WebCore::RenderText::marginLeft):
315	(WebCore::RenderText::marginRight):
316	* rendering/RenderThemeMacShared.mm:
317	(WebCore::RenderThemeMacShared::paintMenuListButtonGradients):
318	* rendering/RenderWidget.cpp:
319	(WebCore::RenderWidget::paint):
320	* rendering/RootInlineBox.cpp:
321	(WebCore::RootInlineBox::verticalPositionForBox):
322	* rendering/style/BasicShapes.cpp:
323	(WebCore::BasicShapeRectangle::path):
324	(WebCore::BasicShapeCircle::path):
325	(WebCore::BasicShapeEllipse::path):
326	(WebCore::BasicShapePolygon::path):
327	* rendering/style/BasicShapes.h:
328	(BasicShapeRectangle):
329	(BasicShapeCircle):
330	(BasicShapeEllipse):
331	(BasicShapePolygon):
332	* rendering/style/RenderStyle.cpp:
333	(WebCore::RenderStyle::applyTransform):
334	(WebCore::calcRadiiFor):
335	(WebCore::RenderStyle::getRoundedBorderFor):
336	(WebCore::RenderStyle::getRoundedInnerBorderFor):
337	(WebCore::RenderStyle::computedLineHeight):
338	* rendering/style/RenderStyle.h:
339	* rendering/svg/RenderSVGRoot.cpp:
340	(WebCore::resolveLengthAttributeForSVG):
341	(WebCore::RenderSVGRoot::computeReplacedLogicalWidth):
342	(WebCore::RenderSVGRoot::computeReplacedLogicalHeight):
343	* rendering/svg/SVGRenderingContext.cpp:
344	(WebCore::SVGRenderingContext::prepareToRenderSVGContent):
345	* svg/SVGSVGElement.cpp:
346	(WebCore::SVGSVGElement::currentViewBoxRect):
347	(WebCore::SVGSVGElement::currentViewportSize):
348	* svg/SVGStyledTransformableElement.cpp:
349	(WebCore::SVGStyledTransformableElement::animatedLocalTransform):
350	* svg/SVGTextElement.cpp:
351	(WebCore::SVGTextElement::animatedLocalTransform):
352	* svg/graphics/SVGImage.cpp:
353	(WebCore::SVGImage::computeIntrinsicDimensions):
354
1	2013-03-10 Andreas Kling <akling@apple.com>	355	2013-03-10 Andreas Kling <akling@apple.com>
2		356
3	SVGDocumentExtensions should use OwnPtr for pending resource maps.	357	SVGDocumentExtensions should use OwnPtr for pending resource maps.

Lines 1-3 a/Source/WebKit/chromium/ChangeLog_sec1
- a/Source/WebKit/chromium/ChangeLog +10 lines
		1	2013-03-11 Timothy Loh <timloh@chromium.org>
		2
		3	viewport units (vw, vh) don't work in CSS transforms
		4	https://bugs.webkit.org/show_bug.cgi?id=91554
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* tests/AnimationTranslationUtilTest.cpp:
		9	(WebKit::animationCanBeTranslated):
		10
1	2013-03-09 Sadrul Habib Chowdhury <sadrul@chromium.org>	11	2013-03-09 Sadrul Habib Chowdhury <sadrul@chromium.org>
2		12
3	[chromium] Remove deprecated flingStart.sourceDevice from WebGestureEvent	13	[chromium] Remove deprecated flingStart.sourceDevice from WebGestureEvent

Lines 69-75 public: a/Source/WebCore/css/CSSCalculationValue.h_sec1
- a/Source/WebCore/css/CSSCalculationValue.h -2 / +2 lines
69	virtual bool isZero() const = 0;	69	virtual bool isZero() const = 0;
70	virtual PassOwnPtr<CalcExpressionNode> toCalcValue(RenderStyle, RenderStyle rootStyle, double zoom = 1.0) const = 0;	70	virtual PassOwnPtr<CalcExpressionNode> toCalcValue(RenderStyle, RenderStyle rootStyle, double zoom = 1.0) const = 0;
71	virtual double doubleValue() const = 0;	71	virtual double doubleValue() const = 0;
72	virtual double computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, double multiplier = 1.0, bool computingFontSize = false) const = 0;	72	virtual double computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, const IntSize& viewportSize, double multiplier = 1.0, bool computingFontSize = false) const = 0;
73	virtual String customCssText() const = 0;	73	virtual String customCssText() const = 0;
74	#if ENABLE(CSS_VARIABLES)	74	#if ENABLE(CSS_VARIABLES)
75	virtual String serializeResolvingVariables(const HashMap<AtomicString, String>&) const = 0;	75	virtual String serializeResolvingVariables(const HashMap<AtomicString, String>&) const = 0;
Lines 106-112 public: a/Source/WebCore/css/CSSCalculationValue.h_sec2
106	bool isInt() const { return m_expression->isInteger(); }	106	bool isInt() const { return m_expression->isInteger(); }
107	double doubleValue() const;	107	double doubleValue() const;
108	bool isNegative() const { return m_expression->doubleValue() < 0; }	108	bool isNegative() const { return m_expression->doubleValue() < 0; }
109	double computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, double multiplier = 1.0, bool computingFontSize = false) const;	109	double computeLengthPx(RenderStyle* currentStyle, RenderStyle* rootStyle, const IntSize& viewportSize, double multiplier = 1.0, bool computingFontSize = false) const;
110		110
111	String customCssText() const;	111	String customCssText() const;
112	bool equals(const CSSCalcValue&) const;	112	bool equals(const CSSCalcValue&) const;

Lines 35-40 a/Source/WebCore/css/CSSGradientValue.cpp_sec1
- a/Source/WebCore/css/CSSGradientValue.cpp -20 / +24 lines
35	#include "IntSizeHash.h"	35	#include "IntSizeHash.h"
36	#include "NodeRenderStyle.h"	36	#include "NodeRenderStyle.h"
37	#include "RenderObject.h"	37	#include "RenderObject.h"
		38	#include "RenderView.h"
38	#include "StyleResolver.h"	39	#include "StyleResolver.h"
39	#include "WebCoreMemoryInstrumentation.h"	40	#include "WebCoreMemoryInstrumentation.h"
40	#include <wtf/MemoryInstrumentationVector.h>	41	#include <wtf/MemoryInstrumentationVector.h>
Lines 168-173 void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend a/Source/WebCore/css/CSSGradientValue.cpp_sec2
168	}	169	}
169		170
170	size_t numStops = m_stops.size();	171	size_t numStops = m_stops.size();
		172	const IntSize& viewportSize = renderer->view()->viewportSize();
171		173
172	Vector<GradientStop> stops(numStops);	174	Vector<GradientStop> stops(numStops);
173		175
Lines 196-204 void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend a/Source/WebCore/css/CSSGradientValue.cpp_sec3
196	}	198	}
197	float length;	199	float length;
198	if (stop.m_position->isLength())	200	if (stop.m_position->isLength())
199	length = stop.m_position->computeLength<float>(style, rootStyle, style->effectiveZoom());	201	length = stop.m_position->computeLength<float>(style, rootStyle, viewportSize, style->effectiveZoom());
200	else	202	else
201	length = stop.m_position->cssCalcValue()->toCalcValue(style, rootStyle, style->effectiveZoom())->evaluate(gradientLength);	203	length = stop.m_position->cssCalcValue()->toCalcValue(style, rootStyle, style->effectiveZoom())->evaluate(gradientLength, viewportSize);
202	stops[i].offset = (gradientLength > 0) ? length / gradientLength : 0;	204	stops[i].offset = (gradientLength > 0) ? length / gradientLength : 0;
203	} else {	205	} else {
204	ASSERT_NOT_REACHED();	206	ASSERT_NOT_REACHED();
Lines 399-405 void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend a/Source/WebCore/css/CSSGradientValue.cpp_sec4
399	gradient->setStopsSorted(true);	401	gradient->setStopsSorted(true);
400	}	402	}
401		403
402	static float positionFromValue(CSSPrimitiveValue* value, RenderStyle* style, RenderStyle* rootStyle, const IntSize& size, bool isHorizontal)	404	static float positionFromValue(CSSPrimitiveValue* value, RenderStyle* style, RenderStyle* rootStyle, const IntSize& size, bool isHorizontal, const IntSize& viewportSize)
403	{	405	{
404	float zoomFactor = style->effectiveZoom();	406	float zoomFactor = style->effectiveZoom();
405		407
Lines 411-417 static float positionFromValue(CSSPrimitiveValue* value, RenderStyle* style, Ren a/Source/WebCore/css/CSSGradientValue.cpp_sec5
411	return value->getFloatValue() / 100.f * edgeDistance;	413	return value->getFloatValue() / 100.f * edgeDistance;
412		414
413	if (value->isCalculatedPercentageWithLength())	415	if (value->isCalculatedPercentageWithLength())
414	return value->cssCalcValue()->toCalcValue(style, rootStyle, style->effectiveZoom())->evaluate(edgeDistance);	416	return value->cssCalcValue()->toCalcValue(style, rootStyle, style->effectiveZoom())->evaluate(edgeDistance, viewportSize);
415		417
416	switch (value->getIdent()) {	418	switch (value->getIdent()) {
417	case CSSValueTop:	419	case CSSValueTop:
Lines 428-445 static float positionFromValue(CSSPrimitiveValue* value, RenderStyle* style, Ren a/Source/WebCore/css/CSSGradientValue.cpp_sec6
428	return size.width();	430	return size.width();
429	}	431	}
430		432
431	return value->computeLength<float>(style, rootStyle, zoomFactor);	433	return value->computeLength<float>(style, rootStyle, viewportSize, zoomFactor);
432	}	434	}
433		435
434	FloatPoint CSSGradientValue::computeEndPoint(CSSPrimitiveValue* horizontal, CSSPrimitiveValue* vertical, RenderStyle* style, RenderStyle* rootStyle, const IntSize& size)	436	FloatPoint CSSGradientValue::computeEndPoint(CSSPrimitiveValue* horizontal, CSSPrimitiveValue* vertical, RenderStyle* style, RenderStyle* rootStyle, const IntSize& size, const IntSize& viewportSize)
435	{	437	{
436	FloatPoint result;	438	FloatPoint result;
437		439
438	if (horizontal)	440	if (horizontal)
439	result.setX(positionFromValue(horizontal, style, rootStyle, size, true));	441	result.setX(positionFromValue(horizontal, style, rootStyle, size, true, viewportSize));
440		442
441	if (vertical)	443	if (vertical)
442	result.setY(positionFromValue(vertical, style, rootStyle, size, false));	444	result.setY(positionFromValue(vertical, style, rootStyle, size, false, viewportSize));
443		445
444	return result;	446	return result;
445	}	447	}
Lines 669-679 PassRefPtr<Gradient> CSSLinearGradientValue::createGradient(RenderObject* render a/Source/WebCore/css/CSSGradientValue.cpp_sec7
669	float angle = m_angle->getFloatValue(CSSPrimitiveValue::CSS_DEG);	671	float angle = m_angle->getFloatValue(CSSPrimitiveValue::CSS_DEG);
670	endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);	672	endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
671	} else {	673	} else {
		674	const IntSize& viewportSize = renderer->view()->viewportSize();
672	switch (m_gradientType) {	675	switch (m_gradientType) {
673	case CSSDeprecatedLinearGradient:	676	case CSSDeprecatedLinearGradient:
674	firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size);	677	firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size, viewportSize);
675	if (m_secondX \|\| m_secondY)	678	if (m_secondX \|\| m_secondY)
676	secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), renderer->style(), rootStyle, size);	679	secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), renderer->style(), rootStyle, size, viewportSize);
677	else {	680	else {
678	if (m_firstX)	681	if (m_firstX)
679	secondPoint.setX(size.width() - firstPoint.x());	682	secondPoint.setX(size.width() - firstPoint.x());
Lines 682-688 PassRefPtr<Gradient> CSSLinearGradientValue::createGradient(RenderObject* render a/Source/WebCore/css/CSSGradientValue.cpp_sec8
682	}	685	}
683	break;	686	break;
684	case CSSPrefixedLinearGradient:	687	case CSSPrefixedLinearGradient:
685	firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size);	688	firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size, viewportSize);
686	if (m_firstX)	689	if (m_firstX)
687	secondPoint.setX(size.width() - firstPoint.x());	690	secondPoint.setX(size.width() - firstPoint.x());
688	if (m_firstY)	691	if (m_firstY)
Lines 701-707 PassRefPtr<Gradient> CSSLinearGradientValue::createGradient(RenderObject* render a/Source/WebCore/css/CSSGradientValue.cpp_sec9
701	float angle = 90 - rad2deg(atan2(rise, run));	704	float angle = 90 - rad2deg(atan2(rise, run));
702	endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);	705	endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
703	} else if (m_firstX \|\| m_firstY) {	706	} else if (m_firstX \|\| m_firstY) {
704	secondPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size);	707	secondPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size, viewportSize);
705	if (m_firstX)	708	if (m_firstX)
706	firstPoint.setX(size.width() - secondPoint.x());	709	firstPoint.setX(size.width() - secondPoint.x());
707	if (m_firstY)	710	if (m_firstY)
Lines 912-918 String CSSRadialGradientValue::customCssText() const a/Source/WebCore/css/CSSGradientValue.cpp_sec10
912	return result.toString();	915	return result.toString();
913	}	916	}
914		917
915	float CSSRadialGradientValue::resolveRadius(CSSPrimitiveValue* radius, RenderStyle* style, RenderStyle* rootStyle, float* widthOrHeight)	918	float CSSRadialGradientValue::resolveRadius(CSSPrimitiveValue* radius, RenderStyle* style, RenderStyle* rootStyle, const IntSize& viewportSize, float* widthOrHeight)
916	{	919	{
917	float zoomFactor = style->effectiveZoom();	920	float zoomFactor = style->effectiveZoom();
918		921
Lines 922-928 float CSSRadialGradientValue::resolveRadius(CSSPrimitiveValue* radius, RenderSty a/Source/WebCore/css/CSSGradientValue.cpp_sec11
922	else if (widthOrHeight && radius->isPercentage())	925	else if (widthOrHeight && radius->isPercentage())
923	result = widthOrHeight radius->getFloatValue() / 100;	926	result = widthOrHeight radius->getFloatValue() / 100;
924	else	927	else
925	result = radius->computeLength<float>(style, rootStyle, zoomFactor);	928	result = radius->computeLength<float>(style, rootStyle, viewportSize, zoomFactor);
926		929
927	return result;	930	return result;
928	}	931	}
Lines 1009-1022 PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(RenderObject* render a/Source/WebCore/css/CSSGradientValue.cpp_sec12
1009	ASSERT(!size.isEmpty());	1012	ASSERT(!size.isEmpty());
1010		1013
1011	RenderStyle* rootStyle = renderer->document()->documentElement()->renderStyle();	1014	RenderStyle* rootStyle = renderer->document()->documentElement()->renderStyle();
		1015	const IntSize& viewportSize = renderer->view()->viewportSize();
1012		1016
1013	FloatPoint firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size);	1017	FloatPoint firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size, viewportSize);
1014	if (!m_firstX)	1018	if (!m_firstX)
1015	firstPoint.setX(size.width() / 2);	1019	firstPoint.setX(size.width() / 2);
1016	if (!m_firstY)	1020	if (!m_firstY)
1017	firstPoint.setY(size.height() / 2);	1021	firstPoint.setY(size.height() / 2);
1018		1022
1019	FloatPoint secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), renderer->style(), rootStyle, size);	1023	FloatPoint secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), renderer->style(), rootStyle, size, viewportSize);
1020	if (!m_secondX)	1024	if (!m_secondX)
1021	secondPoint.setX(size.width() / 2);	1025	secondPoint.setX(size.width() / 2);
1022	if (!m_secondY)	1026	if (!m_secondY)
Lines 1024-1041 PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(RenderObject* render a/Source/WebCore/css/CSSGradientValue.cpp_sec13
1024		1028
1025	float firstRadius = 0;	1029	float firstRadius = 0;
1026	if (m_firstRadius)	1030	if (m_firstRadius)
1027	firstRadius = resolveRadius(m_firstRadius.get(), renderer->style(), rootStyle);	1031	firstRadius = resolveRadius(m_firstRadius.get(), renderer->style(), rootStyle, viewportSize);
1028		1032
1029	float secondRadius = 0;	1033	float secondRadius = 0;
1030	float aspectRatio = 1; // width / height.	1034	float aspectRatio = 1; // width / height.
1031	if (m_secondRadius)	1035	if (m_secondRadius)
1032	secondRadius = resolveRadius(m_secondRadius.get(), renderer->style(), rootStyle);	1036	secondRadius = resolveRadius(m_secondRadius.get(), renderer->style(), rootStyle, viewportSize);
1033	else if (m_endHorizontalSize) {	1037	else if (m_endHorizontalSize) {
1034	float width = size.width();	1038	float width = size.width();
1035	float height = size.height();	1039	float height = size.height();
1036	secondRadius = resolveRadius(m_endHorizontalSize.get(), renderer->style(), rootStyle, &width);	1040	secondRadius = resolveRadius(m_endHorizontalSize.get(), renderer->style(), rootStyle, viewportSize, &width);
1037	if (m_endVerticalSize)	1041	if (m_endVerticalSize)
1038	aspectRatio = secondRadius / resolveRadius(m_endVerticalSize.get(), renderer->style(), rootStyle, &height);	1042	aspectRatio = secondRadius / resolveRadius(m_endVerticalSize.get(), renderer->style(), rootStyle, viewportSize, &height);
1039	else	1043	else
1040	aspectRatio = 1;	1044	aspectRatio = 1;
1041	} else {	1045	} else {

Lines 116-122 protected: a/Source/WebCore/css/CSSGradientValue.h_sec1
- a/Source/WebCore/css/CSSGradientValue.h -2 / +2 lines
116	void addStops(Gradient, RenderObject, RenderStyle* rootStyle, float maxLengthForRepeat = 0);	116	void addStops(Gradient, RenderObject, RenderStyle* rootStyle, float maxLengthForRepeat = 0);
117		117
118	// Resolve points/radii to front end values.	118	// Resolve points/radii to front end values.
119	FloatPoint computeEndPoint(CSSPrimitiveValue, CSSPrimitiveValue, RenderStyle, RenderStyle rootStyle, const IntSize&);	119	FloatPoint computeEndPoint(CSSPrimitiveValue, CSSPrimitiveValue, RenderStyle, RenderStyle rootStyle, const IntSize&, const IntSize& viewportSize);
120		120
121	bool isCacheable() const;	121	bool isCacheable() const;
122		122
Lines 225-231 private: a/Source/WebCore/css/CSSGradientValue.h_sec2
225		225
226		226
227	// Resolve points/radii to front end values.	227	// Resolve points/radii to front end values.
228	float resolveRadius(CSSPrimitiveValue, RenderStyle, RenderStyle* rootStyle, float* widthOrHeight = 0);	228	float resolveRadius(CSSPrimitiveValue, RenderStyle, RenderStyle* rootStyle, const IntSize& viewportSize, float* widthOrHeight = 0);
229		229
230	// These may be null for non-deprecated gradients.	230	// These may be null for non-deprecated gradients.
231	RefPtr<CSSPrimitiveValue> m_firstRadius;	231	RefPtr<CSSPrimitiveValue> m_firstRadius;

Lines 249-255 public: a/Source/WebCore/css/CSSPrimitiveValue.h_sec1
- a/Source/WebCore/css/CSSPrimitiveValue.h -2 / +2 lines
249	* this is screen/printer dependent, so we probably need a config option for this,	249	* this is screen/printer dependent, so we probably need a config option for this,
250	* and some tool to calibrate.	250	* and some tool to calibrate.
251	*/	251	*/
252	template<typename T> T computeLength(RenderStyle* currStyle, RenderStyle* rootStyle, float multiplier = 1.0f, bool computingFontSize = false);	252	template<typename T> T computeLength(RenderStyle* currStyle, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier = 1.0f, bool computingFontSize = false);
253		253
254	// Converts to a Length, mapping various unit types appropriately.	254	// Converts to a Length, mapping various unit types appropriately.
255	template<int> Length convertToLength(RenderStyle* currStyle, RenderStyle* rootStyle, double multiplier = 1.0, bool computingFontSize = false);	255	template<int> Length convertToLength(RenderStyle* currStyle, RenderStyle* rootStyle, double multiplier = 1.0, bool computingFontSize = false);
Lines 360-366 private: a/Source/WebCore/css/CSSPrimitiveValue.h_sec2
360	void init(PassRefPtr<CSSCalcValue>);	360	void init(PassRefPtr<CSSCalcValue>);
361	bool getDoubleValueInternal(UnitTypes targetUnitType, double* result) const;	361	bool getDoubleValueInternal(UnitTypes targetUnitType, double* result) const;
362		362
363	double computeLengthDouble(RenderStyle* currentStyle, RenderStyle* rootStyle, float multiplier, bool computingFontSize);	363	double computeLengthDouble(RenderStyle* currentStyle, RenderStyle* rootStyle, const IntSize& viewportSize, float multiplier, bool computingFontSize);
364		364
365	union {	365	union {
366	int ident;	366	int ident;

Lines 248-254 void CSSToStyleMap::mapFillXPosition(CSSPropertyID propertyID, FillLayer* layer, a/Source/WebCore/css/CSSToStyleMap.cpp_sec1
- a/Source/WebCore/css/CSSToStyleMap.cpp -6 / +6 lines
248		248
249	Length length;	249	Length length;
250	if (primitiveValue->isLength())	250	if (primitiveValue->isLength())
251	length = primitiveValue->computeLength<Length>(style(), rootElementStyle(), zoomFactor);	251	length = primitiveValue->computeLength<Length>(style(), rootElementStyle(), IntSize(), zoomFactor);
252	else if (primitiveValue->isPercentage())	252	else if (primitiveValue->isPercentage())
253	length = Length(primitiveValue->getDoubleValue(), Percent);	253	length = Length(primitiveValue->getDoubleValue(), Percent);
254	else if (primitiveValue->isCalculatedPercentageWithLength())	254	else if (primitiveValue->isCalculatedPercentageWithLength())
Lines 284-290 void CSSToStyleMap::mapFillYPosition(CSSPropertyID propertyID, FillLayer* layer, a/Source/WebCore/css/CSSToStyleMap.cpp_sec2
284		284
285	Length length;	285	Length length;
286	if (primitiveValue->isLength())	286	if (primitiveValue->isLength())
287	length = primitiveValue->computeLength<Length>(style(), rootElementStyle(), zoomFactor);	287	length = primitiveValue->computeLength<Length>(style(), rootElementStyle(), IntSize(), zoomFactor);
288	else if (primitiveValue->isPercentage())	288	else if (primitiveValue->isPercentage())
289	length = Length(primitiveValue->getDoubleValue(), Percent);	289	length = Length(primitiveValue->getDoubleValue(), Percent);
290	else if (primitiveValue->isCalculatedPercentageWithLength())	290	else if (primitiveValue->isCalculatedPercentageWithLength())
Lines 614-641 LengthBox CSSToStyleMap::mapNinePieceImageQuad(CSSValue* value) a/Source/WebCore/css/CSSToStyleMap.cpp_sec3
614	else if (slices->top()->isPercentage())	614	else if (slices->top()->isPercentage())
615	box.m_top = Length(slices->top()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);	615	box.m_top = Length(slices->top()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
616	else if (slices->top()->getIdent() != CSSValueAuto)	616	else if (slices->top()->getIdent() != CSSValueAuto)
617	box.m_top = slices->top()->computeLength<Length>(style(), rootElementStyle(), zoom);	617	box.m_top = slices->top()->convertToLength<FixedFloatConversion \| ViewportPercentageConversion>(style(), rootElementStyle(), zoom);
618		618
619	if (slices->right()->isNumber())	619	if (slices->right()->isNumber())
620	box.m_right = Length(slices->right()->getIntValue(), Relative);	620	box.m_right = Length(slices->right()->getIntValue(), Relative);
621	else if (slices->right()->isPercentage())	621	else if (slices->right()->isPercentage())
622	box.m_right = Length(slices->right()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);	622	box.m_right = Length(slices->right()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
623	else if (slices->right()->getIdent() != CSSValueAuto)	623	else if (slices->right()->getIdent() != CSSValueAuto)
624	box.m_right = slices->right()->computeLength<Length>(style(), rootElementStyle(), zoom);	624	box.m_right = slices->right()->convertToLength<FixedFloatConversion \| ViewportPercentageConversion>(style(), rootElementStyle(), zoom);
625		625
626	if (slices->bottom()->isNumber())	626	if (slices->bottom()->isNumber())
627	box.m_bottom = Length(slices->bottom()->getIntValue(), Relative);	627	box.m_bottom = Length(slices->bottom()->getIntValue(), Relative);
628	else if (slices->bottom()->isPercentage())	628	else if (slices->bottom()->isPercentage())
629	box.m_bottom = Length(slices->bottom()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);	629	box.m_bottom = Length(slices->bottom()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
630	else if (slices->bottom()->getIdent() != CSSValueAuto)	630	else if (slices->bottom()->getIdent() != CSSValueAuto)
631	box.m_bottom = slices->bottom()->computeLength<Length>(style(), rootElementStyle(), zoom);	631	box.m_bottom = slices->bottom()->convertToLength<FixedFloatConversion \| ViewportPercentageConversion>(style(), rootElementStyle(), zoom);
632		632
633	if (slices->left()->isNumber())	633	if (slices->left()->isNumber())
634	box.m_left = Length(slices->left()->getIntValue(), Relative);	634	box.m_left = Length(slices->left()->getIntValue(), Relative);
635	else if (slices->left()->isPercentage())	635	else if (slices->left()->isPercentage())
636	box.m_left = Length(slices->left()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);	636	box.m_left = Length(slices->left()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
637	else if (slices->left()->getIdent() != CSSValueAuto)	637	else if (slices->left()->getIdent() != CSSValueAuto)
638	box.m_left = slices->left()->computeLength<Length>(style(), rootElementStyle(), zoom);	638	box.m_left = slices->left()->convertToLength<FixedFloatConversion \| ViewportPercentageConversion>(style(), rootElementStyle(), zoom);
639		639
640	return box;	640	return box;
641	}	641	}

Lines 30-46 a/Source/WebCore/css/LengthFunctions.cpp_sec1
- a/Source/WebCore/css/LengthFunctions.cpp -60 / +24 lines
30		30
31	namespace WebCore {	31	namespace WebCore {
32		32
33	int minimumIntValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)	33	int minimumIntValueForLength(const Length& length, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages)
34	{	34	{
35	return static_cast<int>(minimumValueForLength(length, maximumValue, renderView, roundPercentages));	35	return static_cast<int>(minimumValueForLength(length, maximumValue, viewportSize, roundPercentages));
36	}	36	}
37		37
38	int intValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)	38	int intValueForLength(const Length& length, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages)
39	{	39	{
40	return static_cast<int>(valueForLength(length, maximumValue, renderView, roundPercentages));	40	return static_cast<int>(valueForLength(length, maximumValue, viewportSize, roundPercentages));
41	}	41	}
42		42
43	LayoutUnit minimumValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)	43	LayoutUnit minimumValueForLength(const Length& length, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages)
44	{	44	{
45	switch (length.type()) {	45	switch (length.type()) {
46	case Fixed:	46	case Fixed:
Lines 51-77 LayoutUnit minimumValueForLength(const Length& length, LayoutUnit maximumValue, a/Source/WebCore/css/LengthFunctions.cpp_sec2
51	// Don't remove the extra cast to float. It is needed for rounding on 32-bit Intel machines that use the FPU stack.	51	// Don't remove the extra cast to float. It is needed for rounding on 32-bit Intel machines that use the FPU stack.
52	return static_cast<LayoutUnit>(static_cast<float>(maximumValue * length.percent() / 100.0f));	52	return static_cast<LayoutUnit>(static_cast<float>(maximumValue * length.percent() / 100.0f));
53	case Calculated:	53	case Calculated:
54	return length.nonNanCalculatedValue(maximumValue);	54	return length.nonNanCalculatedValue(maximumValue, viewportSize);
55	case ViewportPercentageWidth:	55	case ViewportPercentageWidth:
56	if (renderView)	56	return static_cast<LayoutUnit>(viewportSize.width() * length.viewportPercentageLength() / 100.0f);
57	return static_cast<LayoutUnit>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
58	return 0;
59	case ViewportPercentageHeight:	57	case ViewportPercentageHeight:
60	if (renderView)	58	return static_cast<LayoutUnit>(viewportSize.height() * length.viewportPercentageLength() / 100.0f);
61	return static_cast<LayoutUnit>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
62	return 0;
63	case ViewportPercentageMin:	59	case ViewportPercentageMin:
64	if (renderView) {	60	return static_cast<LayoutUnit>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
65	IntSize viewportSize = renderView->viewportSize();
66	return static_cast<LayoutUnit>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
67	}
68	return 0;
69	case ViewportPercentageMax:	61	case ViewportPercentageMax:
70	if (renderView) {	62	return static_cast<LayoutUnit>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
71	IntSize viewportSize = renderView->viewportSize();
72	return static_cast<LayoutUnit>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
73	}
74	return 0;
75	case FillAvailable:	63	case FillAvailable:
76	case Auto:	64	case Auto:
77	return 0;	65	return 0;
Lines 89-95 LayoutUnit minimumValueForLength(const Length& length, LayoutUnit maximumValue, a/Source/WebCore/css/LengthFunctions.cpp_sec3
89	return 0;	77	return 0;
90	}	78	}
91		79
92	LayoutUnit valueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)	80	LayoutUnit valueForLength(const Length& length, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages)
93	{	81	{
94	switch (length.type()) {	82	switch (length.type()) {
95	case Fixed:	83	case Fixed:
Lines 99-105 LayoutUnit valueForLength(const Length& length, LayoutUnit maximumValue, RenderV a/Source/WebCore/css/LengthFunctions.cpp_sec4
99	case ViewportPercentageHeight:	87	case ViewportPercentageHeight:
100	case ViewportPercentageMin:	88	case ViewportPercentageMin:
101	case ViewportPercentageMax:	89	case ViewportPercentageMax:
102	return minimumValueForLength(length, maximumValue, renderView, roundPercentages);	90	return minimumValueForLength(length, maximumValue, viewportSize, roundPercentages);
103	case FillAvailable:	91	case FillAvailable:
104	case Auto:	92	case Auto:
105	return maximumValue;	93	return maximumValue;
Lines 118-124 LayoutUnit valueForLength(const Length& length, LayoutUnit maximumValue, RenderV a/Source/WebCore/css/LengthFunctions.cpp_sec5
118	}	106	}
119		107
120	// FIXME: when subpixel layout is supported this copy of floatValueForLength() can be removed. See bug 71143.	108	// FIXME: when subpixel layout is supported this copy of floatValueForLength() can be removed. See bug 71143.
121	float floatValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView)	109	float floatValueForLength(const Length& length, LayoutUnit maximumValue, const IntSize& viewportSize)
122	{	110	{
123	switch (length.type()) {	111	switch (length.type()) {
124	case Fixed:	112	case Fixed:
Lines 129-155 float floatValueForLength(const Length& length, LayoutUnit maximumValue, RenderV a/Source/WebCore/css/LengthFunctions.cpp_sec6
129	case Auto:	117	case Auto:
130	return static_cast<float>(maximumValue);	118	return static_cast<float>(maximumValue);
131	case Calculated:	119	case Calculated:
132	return length.nonNanCalculatedValue(maximumValue);	120	return length.nonNanCalculatedValue(maximumValue, viewportSize);
133	case ViewportPercentageWidth:	121	case ViewportPercentageWidth:
134	if (renderView)	122	return static_cast<int>(viewportSize.width() * length.viewportPercentageLength() / 100.0f);
135	return static_cast<int>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
136	return 0;
137	case ViewportPercentageHeight:	123	case ViewportPercentageHeight:
138	if (renderView)	124	return static_cast<float>(viewportSize.height() * length.viewportPercentageLength() / 100.0f);
139	return static_cast<int>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
140	return 0;
141	case ViewportPercentageMin:	125	case ViewportPercentageMin:
142	if (renderView) {	126	return static_cast<float>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
143	IntSize viewportSize = renderView->viewportSize();
144	return static_cast<int>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
145	}
146	return 0;
147	case ViewportPercentageMax:	127	case ViewportPercentageMax:
148	if (renderView) {	128	return static_cast<float>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
149	IntSize viewportSize = renderView->viewportSize();
150	return static_cast<int>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
151	}
152	return 0;
153	case Relative:	129	case Relative:
154	case Intrinsic:	130	case Intrinsic:
155	case MinIntrinsic:	131	case MinIntrinsic:
Lines 164-170 float floatValueForLength(const Length& length, LayoutUnit maximumValue, RenderV a/Source/WebCore/css/LengthFunctions.cpp_sec7
164	return 0;	140	return 0;
165	}	141	}
166		142
167	float floatValueForLength(const Length& length, float maximumValue, RenderView* renderView)	143	float floatValueForLength(const Length& length, float maximumValue, const IntSize& viewportSize)
168	{	144	{
169	switch (length.type()) {	145	switch (length.type()) {
170	case Fixed:	146	case Fixed:
Lines 175-201 float floatValueForLength(const Length& length, float maximumValue, RenderView* a/Source/WebCore/css/LengthFunctions.cpp_sec8
175	case Auto:	151	case Auto:
176	return static_cast<float>(maximumValue);	152	return static_cast<float>(maximumValue);
177	case Calculated:	153	case Calculated:
178	return length.nonNanCalculatedValue(maximumValue);	154	return length.nonNanCalculatedValue(maximumValue, viewportSize);
179	case ViewportPercentageWidth:	155	case ViewportPercentageWidth:
180	if (renderView)	156	return static_cast<float>(viewportSize.width() * length.viewportPercentageLength() / 100.0f);
181	return static_cast<int>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
182	return 0;
183	case ViewportPercentageHeight:	157	case ViewportPercentageHeight:
184	if (renderView)	158	return static_cast<float>(viewportSize.height() * length.viewportPercentageLength() / 100.0f);
185	return static_cast<int>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
186	return 0;
187	case ViewportPercentageMin:	159	case ViewportPercentageMin:
188	if (renderView) {	160	return static_cast<float>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
189	IntSize viewportSize = renderView->viewportSize();
190	return static_cast<int>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
191	}
192	return 0;
193	case ViewportPercentageMax:	161	case ViewportPercentageMax:
194	if (renderView) {	162	return static_cast<float>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
195	IntSize viewportSize = renderView->viewportSize();
196	return static_cast<int>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
197	}
198	return 0;
199	case Relative:	163	case Relative:
200	case Intrinsic:	164	case Intrinsic:
201	case MinIntrinsic:	165	case MinIntrinsic:

Lines 26-41 a/Source/WebCore/css/LengthFunctions.h_sec1
- a/Source/WebCore/css/LengthFunctions.h -7 / +7 lines
26		26
27	namespace WebCore {	27	namespace WebCore {
28		28
		29	class IntSize;
29	class LayoutUnit;	30	class LayoutUnit;
30	class RenderView;
31	struct Length;	31	struct Length;
32		32
33	int minimumIntValueForLength(const Length&, LayoutUnit maximumValue, RenderView* = 0, bool roundPercentages = false);	33	int minimumIntValueForLength(const Length&, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages = false);
34	int intValueForLength(const Length&, LayoutUnit maximumValue, RenderView* = 0, bool roundPercentages = false);	34	int intValueForLength(const Length&, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages = false);
35	LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue, RenderView* = 0, bool roundPercentages = false);	35	LayoutUnit minimumValueForLength(const Length&, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages = false);
36	LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue, RenderView* = 0, bool roundPercentages = false);	36	LayoutUnit valueForLength(const Length&, LayoutUnit maximumValue, const IntSize& viewportSize, bool roundPercentages = false);
37	float floatValueForLength(const Length&, LayoutUnit maximumValue, RenderView* = 0);	37	float floatValueForLength(const Length&, LayoutUnit maximumValue, const IntSize& viewportSize);
38	float floatValueForLength(const Length&, float maximumValue, RenderView* = 0);	38	float floatValueForLength(const Length&, float maximumValue, const IntSize& viewportSize);
39		39
40	} // namespace WebCore	40	} // namespace WebCore
41		41

Lines 219-225 public: a/Source/WebCore/css/StyleBuilder.cpp_sec1
- a/Source/WebCore/css/StyleBuilder.cpp -15 / +16 lines
219	else if (valueType == Number)	219	else if (valueType == Number)
220	setValue(styleResolver->style(), *primitiveValue);	220	setValue(styleResolver->style(), *primitiveValue);
221	else if (valueType == ComputeLength)	221	else if (valueType == ComputeLength)
222	setValue(styleResolver->style(), primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom()));	222	setValue(styleResolver->style(), primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), styleResolver->style()->effectiveZoom()));
223	}	223	}
224		224
225	static PropertyHandler createHandler() { return PropertyHandler(&applyInheritValue, &applyInitialValue, &applyValue); }	225	static PropertyHandler createHandler() { return PropertyHandler(&applyInheritValue, &applyInitialValue, &applyValue); }
Lines 386-392 public: a/Source/WebCore/css/StyleBuilder.cpp_sec2
386	if (autoEnabled && primitiveValue->getIdent() == CSSValueAuto)	386	if (autoEnabled && primitiveValue->getIdent() == CSSValueAuto)
387	setValue(styleResolver->style(), Length());	387	setValue(styleResolver->style(), Length());
388	else if (primitiveValue->isLength()) {	388	else if (primitiveValue->isLength()) {
389	Length length = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom());	389	Length length = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), styleResolver->style()->effectiveZoom());
390	length.setQuirk(primitiveValue->isQuirkValue());	390	length.setQuirk(primitiveValue->isQuirkValue());
391	setValue(styleResolver->style(), length);	391	setValue(styleResolver->style(), length);
392	} else if (primitiveValue->isPercentage())	392	} else if (primitiveValue->isPercentage())
Lines 450-456 public: a/Source/WebCore/css/StyleBuilder.cpp_sec3
450	else if (pair->first()->isCalculatedPercentageWithLength())	450	else if (pair->first()->isCalculatedPercentageWithLength())
451	radiusWidth = Length((pair->first()->cssCalcValue()->toCalcValue(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom())));	451	radiusWidth = Length((pair->first()->cssCalcValue()->toCalcValue(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom())));
452	else	452	else
453	radiusWidth = pair->first()->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom());	453	radiusWidth = pair->first()->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), styleResolver->style()->effectiveZoom());
454	if (pair->second()->isPercentage())	454	if (pair->second()->isPercentage())
455	radiusHeight = Length(pair->second()->getDoubleValue(), Percent);	455	radiusHeight = Length(pair->second()->getDoubleValue(), Percent);
456	else if (pair->second()->isViewportPercentageLength())	456	else if (pair->second()->isViewportPercentageLength())
Lines 458-464 public: a/Source/WebCore/css/StyleBuilder.cpp_sec4
458	else if (pair->second()->isCalculatedPercentageWithLength())	458	else if (pair->second()->isCalculatedPercentageWithLength())
459	radiusHeight = Length((pair->second()->cssCalcValue()->toCalcValue(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom())));	459	radiusHeight = Length((pair->second()->cssCalcValue()->toCalcValue(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom())));
460	else	460	else
461	radiusHeight = pair->second()->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->style()->effectiveZoom());	461	radiusHeight = pair->second()->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), styleResolver->style()->effectiveZoom());
462	int width = radiusWidth.value();	462	int width = radiusWidth.value();
463	int height = radiusHeight.value();	463	int height = radiusHeight.value();
464	if (width < 0 \|\| height < 0)	464	if (width < 0 \|\| height < 0)
Lines 603-614 public: a/Source/WebCore/css/StyleBuilder.cpp_sec5
603	length = 5;	603	length = 5;
604	} else if (ident == CSSValueInvalid) {	604	} else if (ident == CSSValueInvalid) {
605	float zoom = (svgZoomEnabled && styleResolver->useSVGZoomRules()) ? 1.0f : styleResolver->style()->effectiveZoom();	605	float zoom = (svgZoomEnabled && styleResolver->useSVGZoomRules()) ? 1.0f : styleResolver->style()->effectiveZoom();
		606	const IntSize& viewportSize = styleResolver->document()->viewportSize();
606		607
607	// Any original result that was >= 1 should not be allowed to fall below 1.	608	// Any original result that was >= 1 should not be allowed to fall below 1.
608	// This keeps border lines from vanishing.	609	// This keeps border lines from vanishing.
609	length = primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), zoom);	610	length = primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), viewportSize, zoom);
610	if (zoom < 1.0f && length < 1.0) {	611	if (zoom < 1.0f && length < 1.0) {
611	T originalLength = primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), 1.0);	612	T originalLength = primitiveValue->computeLength<T>(styleResolver->style(), styleResolver->rootElementStyle(), viewportSize, 1.0);
612	if (originalLength >= 1.0)	613	if (originalLength >= 1.0)
613	length = 1.0;	614	length = 1.0;
614	}	615	}
Lines 751-763 public: a/Source/WebCore/css/StyleBuilder.cpp_sec6
751	fontDescription.setIsAbsoluteSize(parentIsAbsoluteSize	752	fontDescription.setIsAbsoluteSize(parentIsAbsoluteSize
752	\|\| !(primitiveValue->isPercentage() \|\| primitiveValue->isFontRelativeLength()));	753	\|\| !(primitiveValue->isPercentage() \|\| primitiveValue->isFontRelativeLength()));
753	if (primitiveValue->isLength())	754	if (primitiveValue->isLength())
754	size = primitiveValue->computeLength<float>(styleResolver->parentStyle(), styleResolver->rootElementStyle(), 1.0, true);	755	size = primitiveValue->computeLength<float>(styleResolver->parentStyle(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), 1.0, true);
755	else if (primitiveValue->isPercentage())	756	else if (primitiveValue->isPercentage())
756	size = (primitiveValue->getFloatValue() * parentSize) / 100.0f;	757	size = (primitiveValue->getFloatValue() * parentSize) / 100.0f;
757	else if (primitiveValue->isCalculatedPercentageWithLength())	758	else if (primitiveValue->isCalculatedPercentageWithLength())
758	size = primitiveValue->cssCalcValue()->toCalcValue(styleResolver->parentStyle(), styleResolver->rootElementStyle())->evaluate(parentSize);	759	size = primitiveValue->cssCalcValue()->toCalcValue(styleResolver->parentStyle(), styleResolver->rootElementStyle())->evaluate(parentSize, styleResolver->document()->viewportSize());
759	else if (primitiveValue->isViewportPercentageLength())	760	else if (primitiveValue->isViewportPercentageLength())
760	size = valueForLength(primitiveValue->viewportPercentageLength(), 0, styleResolver->document()->renderView());	761	size = valueForLength(primitiveValue->viewportPercentageLength(), 0, styleResolver->document()->viewportSize());
761	else	762	else
762	return;	763	return;
763	}	764	}
Lines 1165-1171 public: a/Source/WebCore/css/StyleBuilder.cpp_sec7
1165	double multiplier = styleResolver->style()->effectiveZoom();	1166	double multiplier = styleResolver->style()->effectiveZoom();
1166	if (Frame* frame = styleResolver->document()->frame())	1167	if (Frame* frame = styleResolver->document()->frame())
1167	multiplier *= frame->textZoomFactor();	1168	multiplier *= frame->textZoomFactor();
1168	lineHeight = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), multiplier);	1169	lineHeight = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize(), multiplier);
1169	} else if (primitiveValue->isPercentage()) {	1170	} else if (primitiveValue->isPercentage()) {
1170	// FIXME: percentage should not be restricted to an integer here.	1171	// FIXME: percentage should not be restricted to an integer here.
1171	lineHeight = Length((styleResolver->style()->fontSize() * primitiveValue->getIntValue()) / 100, Fixed);	1172	lineHeight = Length((styleResolver->style()->fontSize() * primitiveValue->getIntValue()) / 100, Fixed);
Lines 1187-1194 public: a/Source/WebCore/css/StyleBuilder.cpp_sec8
1187		1188
1188	class ApplyPropertyPageSize {	1189	class ApplyPropertyPageSize {
1189	private:	1190	private:
1190	static Length mmLength(double mm) { return CSSPrimitiveValue::create(mm, CSSPrimitiveValue::CSS_MM)->computeLength<Length>(0, 0); }	1191	static Length mmLength(double mm) { return CSSPrimitiveValue::create(mm, CSSPrimitiveValue::CSS_MM)->computeLength<Length>(0, 0, IntSize()); }
1191	static Length inchLength(double inch) { return CSSPrimitiveValue::create(inch, CSSPrimitiveValue::CSS_IN)->computeLength<Length>(0, 0); }	1192	static Length inchLength(double inch) { return CSSPrimitiveValue::create(inch, CSSPrimitiveValue::CSS_IN)->computeLength<Length>(0, 0, IntSize()); }
1192	static bool getPageSizeFromName(CSSPrimitiveValue* pageSizeName, CSSPrimitiveValue* pageOrientation, Length& width, Length& height)	1193	static bool getPageSizeFromName(CSSPrimitiveValue* pageSizeName, CSSPrimitiveValue* pageOrientation, Length& width, Length& height)
1193	{	1194	{
1194	DEFINE_STATIC_LOCAL(Length, a5Width, (mmLength(148)));	1195	DEFINE_STATIC_LOCAL(Length, a5Width, (mmLength(148)));
Lines 1283-1290 public: a/Source/WebCore/css/StyleBuilder.cpp_sec9
1283	// <length>{2}	1284	// <length>{2}
1284	if (!second->isLength())	1285	if (!second->isLength())
1285	return;	1286	return;
1286	width = first->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle());	1287	width = first->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize());
1287	height = second->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle());	1288	height = second->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize());
1288	} else {	1289	} else {
1289	// <page-size> <orientation>	1290	// <page-size> <orientation>
1290	// The value order is guaranteed. See CSSParser::parseSizeParameter.	1291	// The value order is guaranteed. See CSSParser::parseSizeParameter.
Lines 1302-1308 public: a/Source/WebCore/css/StyleBuilder.cpp_sec10
1302	if (primitiveValue->isLength()) {	1303	if (primitiveValue->isLength()) {
1303	// <length>	1304	// <length>
1304	pageSizeType = PAGE_SIZE_RESOLVED;	1305	pageSizeType = PAGE_SIZE_RESOLVED;
1305	width = height = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle());	1306	width = height = primitiveValue->computeLength<Length>(styleResolver->style(), styleResolver->rootElementStyle(), styleResolver->document()->viewportSize());
1306	} else {	1307	} else {
1307	switch (primitiveValue->getIdent()) {	1308	switch (primitiveValue->getIdent()) {
1308	case 0:	1309	case 0:

Lines 1966-1972 bool Document::isPageBoxVisible(int pageIndex) a/Source/WebCore/dom/Document.cpp_sec1
- a/Source/WebCore/dom/Document.cpp -7 / +6 lines
1966	void Document::pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)	1966	void Document::pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
1967	{	1967	{
1968	RefPtr<RenderStyle> style = styleForPage(pageIndex);	1968	RefPtr<RenderStyle> style = styleForPage(pageIndex);
1969	RenderView* view = renderView();
1970		1969
1971	int width = pageSize.width();	1970	int width = pageSize.width();
1972	int height = pageSize.height();	1971	int height = pageSize.height();
Lines 1985-1992 void Document::pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& a/Source/WebCore/dom/Document.cpp_sec2
1985	LengthSize size = style->pageSize();	1984	LengthSize size = style->pageSize();
1986	ASSERT(size.width().isFixed());	1985	ASSERT(size.width().isFixed());
1987	ASSERT(size.height().isFixed());	1986	ASSERT(size.height().isFixed());
1988	width = valueForLength(size.width(), 0, view);	1987	width = renderer()->valueForLength(size.width(), 0);
1989	height = valueForLength(size.height(), 0, view);	1988	height = renderer()->valueForLength(size.height(), 0);
1990	break;	1989	break;
1991	}	1990	}
1992	default:	1991	default:
Lines 1996-2005 void Document::pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& a/Source/WebCore/dom/Document.cpp_sec3
1996		1995
1997	// The percentage is calculated with respect to the width even for margin top and bottom.	1996	// The percentage is calculated with respect to the width even for margin top and bottom.
1998	// http://www.w3.org/TR/CSS2/box.html#margin-properties	1997	// http://www.w3.org/TR/CSS2/box.html#margin-properties
1999	marginTop = style->marginTop().isAuto() ? marginTop : intValueForLength(style->marginTop(), width, view);	1998	marginTop = style->marginTop().isAuto() ? marginTop : renderer()->intValueForLength(style->marginTop(), width);
2000	marginRight = style->marginRight().isAuto() ? marginRight : intValueForLength(style->marginRight(), width, view);	1999	marginRight = style->marginRight().isAuto() ? marginRight : renderer()->intValueForLength(style->marginRight(), width);
2001	marginBottom = style->marginBottom().isAuto() ? marginBottom : intValueForLength(style->marginBottom(), width, view);	2000	marginBottom = style->marginBottom().isAuto() ? marginBottom : renderer()->intValueForLength(style->marginBottom(), width);
2002	marginLeft = style->marginLeft().isAuto() ? marginLeft : intValueForLength(style->marginLeft(), width, view);	2001	marginLeft = style->marginLeft().isAuto() ? marginLeft : renderer()->intValueForLength(style->marginLeft(), width);
2003	}	2002	}
2004		2003
2005	void Document::setIsViewSource(bool isViewSource)	2004	void Document::setIsViewSource(bool isViewSource)

Lines 144-173 Path HTMLAreaElement::getRegion(const LayoutSize& size) const a/Source/WebCore/html/HTMLAreaElement.cpp_sec1
- a/Source/WebCore/html/HTMLAreaElement.cpp -9 / +9 lines
144	}	144	}
145		145
146	Path path;	146	Path path;
147	RenderView* renderView = document()->renderView();	147	const RenderObject* renderer = document()->renderer();
148	switch (shape) {	148	switch (shape) {
149	case Poly:	149	case Poly:
150	if (m_coordsLen >= 6) {	150	if (m_coordsLen >= 6) {
151	int numPoints = m_coordsLen / 2;	151	int numPoints = m_coordsLen / 2;
152	path.moveTo(FloatPoint(minimumValueForLength(m_coords[0], width, renderView), minimumValueForLength(m_coords[1], height, renderView)));	152	path.moveTo(FloatPoint(renderer->minimumValueForLength(m_coords[0], width), renderer->minimumValueForLength(m_coords[1], height)));
153	for (int i = 1; i < numPoints; ++i)	153	for (int i = 1; i < numPoints; ++i)
154	path.addLineTo(FloatPoint(minimumValueForLength(m_coords[i * 2], width, renderView), minimumValueForLength(m_coords[i * 2 + 1], height, renderView)));	154	path.addLineTo(FloatPoint(renderer->minimumValueForLength(m_coords[i * 2], width), renderer->minimumValueForLength(m_coords[i * 2 + 1], height)));
155	path.closeSubpath();	155	path.closeSubpath();
156	}	156	}
157	break;	157	break;
158	case Circle:	158	case Circle:
159	if (m_coordsLen >= 3) {	159	if (m_coordsLen >= 3) {
160	Length radius = m_coords[2];	160	Length radius = m_coords[2];
161	int r = min(minimumValueForLength(radius, width, renderView), minimumValueForLength(radius, height, renderView));	161	int r = min(renderer->minimumValueForLength(radius, width), renderer->minimumValueForLength(radius, height));
162	path.addEllipse(FloatRect(minimumValueForLength(m_coords[0], width, renderView) - r, minimumValueForLength(m_coords[1], height, renderView) - r, 2 * r, 2 * r));	162	path.addEllipse(FloatRect(renderer->minimumValueForLength(m_coords[0], width) - r, renderer->minimumValueForLength(m_coords[1], height) - r, 2 * r, 2 * r));
163	}	163	}
164	break;	164	break;
165	case Rect:	165	case Rect:
166	if (m_coordsLen >= 4) {	166	if (m_coordsLen >= 4) {
167	int x0 = minimumValueForLength(m_coords[0], width, renderView);	167	int x0 = renderer->minimumValueForLength(m_coords[0], width);
168	int y0 = minimumValueForLength(m_coords[1], height, renderView);	168	int y0 = renderer->minimumValueForLength(m_coords[1], height);
169	int x1 = minimumValueForLength(m_coords[2], width, renderView);	169	int x1 = renderer->minimumValueForLength(m_coords[2], width);
170	int y1 = minimumValueForLength(m_coords[3], height, renderView);	170	int y1 = renderer->minimumValueForLength(m_coords[3], height);
171	path.addRect(FloatRect(x0, y0, x1 - x0, y1 - y0));	171	path.addRect(FloatRect(x0, y0, x1 - x0, y1 - y0));
172	}	172	}
173	break;	173	break;

Lines 44-49 a/Source/WebCore/page/animation/CSSPropertyAnimation.cpp_sec1
- a/Source/WebCore/page/animation/CSSPropertyAnimation.cpp -3 / +4 lines
44	#include "MatrixTransformOperation.h"	44	#include "MatrixTransformOperation.h"
45	#include "RenderBox.h"	45	#include "RenderBox.h"
46	#include "RenderStyle.h"	46	#include "RenderStyle.h"
		47	#include "RenderView.h"
47	#include "StyleCachedImage.h"	48	#include "StyleCachedImage.h"
48	#include "StyleGeneratedImage.h"	49	#include "StyleGeneratedImage.h"
49	#include "StylePropertyShorthand.h"	50	#include "StylePropertyShorthand.h"
Lines 124-131 static inline PassOwnPtr<ShadowData> blendFunc(const AnimationBase* anim, const a/Source/WebCore/page/animation/CSSPropertyAnimation.cpp_sec2
124	static inline TransformOperations blendFunc(const AnimationBase* anim, const TransformOperations& from, const TransformOperations& to, double progress)	125	static inline TransformOperations blendFunc(const AnimationBase* anim, const TransformOperations& from, const TransformOperations& to, double progress)
125	{	126	{
126	if (anim->isTransformFunctionListValid())	127	if (anim->isTransformFunctionListValid())
127	return to.blendByMatchingOperations(from, progress);	128	return to.blendByMatchingOperations(from, progress, anim->renderer()->view()->viewportSize());
128	return to.blendByUsingMatrixInterpolation(from, progress, anim->renderer()->isBox() ? toRenderBox(anim->renderer())->borderBoxRect().size() : LayoutSize());	129	return to.blendByUsingMatrixInterpolation(from, progress, anim->renderer()->isBox() ? toRenderBox(anim->renderer())->borderBoxRect().size() : LayoutSize(), anim->renderer()->view()->viewportSize());
129	}	130	}
130		131
131	static inline PassRefPtr<ClipPathOperation> blendFunc(const AnimationBase, ClipPathOperation from, ClipPathOperation* to, double progress)	132	static inline PassRefPtr<ClipPathOperation> blendFunc(const AnimationBase, ClipPathOperation from, ClipPathOperation* to, double progress)
Lines 166-172 static inline PassRefPtr<FilterOperation> blendFunc(const AnimationBase* anim, F a/Source/WebCore/page/animation/CSSPropertyAnimation.cpp_sec3
166	ASSERT(toOp);	167	ASSERT(toOp);
167	if (toOp->blendingNeedsRendererSize()) {	168	if (toOp->blendingNeedsRendererSize()) {
168	LayoutSize size = anim->renderer()->isBox() ? toRenderBox(anim->renderer())->borderBoxRect().size() : LayoutSize();	169	LayoutSize size = anim->renderer()->isBox() ? toRenderBox(anim->renderer())->borderBoxRect().size() : LayoutSize();
169	return toOp->blend(fromOp, progress, size, blendToPassthrough);	170	return toOp->blend(fromOp, progress, size, anim->renderer()->view()->viewportSize(), blendToPassthrough);
170	}	171	}
171	return toOp->blend(fromOp, progress, blendToPassthrough);	172	return toOp->blend(fromOp, progress, blendToPassthrough);
172	}	173	}

Lines 35-44 a/Source/WebCore/platform/CalculationValue.cpp_sec1
- a/Source/WebCore/platform/CalculationValue.cpp -5 / +5 lines
35		35
36	namespace WebCore {	36	namespace WebCore {
37		37
38	float CalcExpressionBinaryOperation::evaluate(float maxValue) const	38	float CalcExpressionBinaryOperation::evaluate(float maxValue, const IntSize& viewportSize) const
39	{	39	{
40	float left = m_leftSide->evaluate(maxValue);	40	float left = m_leftSide->evaluate(maxValue, viewportSize);
41	float right = m_rightSide->evaluate(maxValue);	41	float right = m_rightSide->evaluate(maxValue, viewportSize);
42	switch (m_operator) {	42	switch (m_operator) {
43	case CalcAdd:	43	case CalcAdd:
44	return left + right;	44	return left + right;
Lines 60-68 PassRefPtr<CalculationValue> CalculationValue::create(PassOwnPtr<CalcExpressionN a/Source/WebCore/platform/CalculationValue.cpp_sec2
60	return adoptRef(new CalculationValue(value, range));	60	return adoptRef(new CalculationValue(value, range));
61	}	61	}
62		62
63	float CalculationValue::evaluate(float maxValue) const	63	float CalculationValue::evaluate(float maxValue, const IntSize& viewportSize) const
64	{	64	{
65	float result = m_value->evaluate(maxValue);	65	float result = m_value->evaluate(maxValue, viewportSize);
66	// FIXME calc https://webkit.org/b/80411 : result is NaN when there is a division	66	// FIXME calc https://webkit.org/b/80411 : result is NaN when there is a division
67	// by zero which isn't found at parse time.	67	// by zero which isn't found at parse time.
68	if (std::isnan(result))	68	if (std::isnan(result))

Lines 72-78 public: a/Source/WebCore/platform/CalculationValue.h_sec1
- a/Source/WebCore/platform/CalculationValue.h -8 / +8 lines
72	{	72	{
73	}	73	}
74		74
75	virtual float evaluate(float maxValue) const = 0;	75	virtual float evaluate(float maxValue, const IntSize& viewportSize) const = 0;
76	virtual bool operator==(const CalcExpressionNode&) const = 0;	76	virtual bool operator==(const CalcExpressionNode&) const = 0;
77		77
78	CalcExpressionNodeType type() const { return m_type; }	78	CalcExpressionNodeType type() const { return m_type; }
Lines 84-90 protected: a/Source/WebCore/platform/CalculationValue.h_sec2
84	class CalculationValue : public RefCounted<CalculationValue> {	84	class CalculationValue : public RefCounted<CalculationValue> {
85	public:	85	public:
86	static PassRefPtr<CalculationValue> create(PassOwnPtr<CalcExpressionNode> value, CalculationPermittedValueRange);	86	static PassRefPtr<CalculationValue> create(PassOwnPtr<CalcExpressionNode> value, CalculationPermittedValueRange);
87	float evaluate(float maxValue) const;	87	float evaluate(float maxValue, const IntSize& viewportSize) const;
88		88
89	bool operator==(const CalculationValue& o) const	89	bool operator==(const CalculationValue& o) const
90	{	90	{
Lines 120-126 public: a/Source/WebCore/platform/CalculationValue.h_sec3
120	return type() == o.type() && *this == static_cast<const CalcExpressionNumber&>(o);	120	return type() == o.type() && *this == static_cast<const CalcExpressionNumber&>(o);
121	}	121	}
122		122
123	virtual float evaluate(float) const	123	virtual float evaluate(float, const IntSize&) const
124	{	124	{
125	return m_value;	125	return m_value;
126	}	126	}
Lines 147-155 public: a/Source/WebCore/platform/CalculationValue.h_sec4
147	return type() == o.type() && *this == static_cast<const CalcExpressionLength&>(o);	147	return type() == o.type() && *this == static_cast<const CalcExpressionLength&>(o);
148	}	148	}
149		149
150	virtual float evaluate(float maxValue) const	150	virtual float evaluate(float maxValue, const IntSize& viewportSize) const
151	{	151	{
152	return floatValueForLength(m_length, maxValue);	152	return floatValueForLength(m_length, maxValue, viewportSize);
153	}	153	}
154		154
155	private:	155	private:
Lines 177-183 public: a/Source/WebCore/platform/CalculationValue.h_sec5
177	}	177	}
178		178
179		179
180	virtual float evaluate(float) const;	180	virtual float evaluate(float, const IntSize&) const;
181		181
182	private:	182	private:
183	OwnPtr<CalcExpressionNode> m_leftSide;	183	OwnPtr<CalcExpressionNode> m_leftSide;
Lines 205-213 public: a/Source/WebCore/platform/CalculationValue.h_sec6
205	return type() == o.type() && *this == static_cast<const CalcExpressionBlendLength&>(o);	205	return type() == o.type() && *this == static_cast<const CalcExpressionBlendLength&>(o);
206	}	206	}
207		207
208	virtual float evaluate(float maxValue) const	208	virtual float evaluate(float maxValue, const IntSize& viewportSize) const
209	{	209	{
210	return (1.0f - m_progress) * floatValueForLength(m_from, maxValue) + m_progress * floatValueForLength(m_to, maxValue);	210	return (1.0f - m_progress) * floatValueForLength(m_from, maxValue, viewportSize) + m_progress * floatValueForLength(m_to, maxValue, viewportSize);
211	}	211	}
212		212
213	private:	213	private:

Lines 236-245 void Length::decrementCalculatedRef() const a/Source/WebCore/platform/Length.cpp_sec1
- a/Source/WebCore/platform/Length.cpp -2 / +2 lines
236	calcLength->deref();	236	calcLength->deref();
237	}	237	}
238		238
239	float Length::nonNanCalculatedValue(int maxValue) const	239	float Length::nonNanCalculatedValue(int maxValue, const IntSize& viewportSize) const
240	{	240	{
241	ASSERT(isCalculated());	241	ASSERT(isCalculated());
242	float result = calculationValue()->evaluate(maxValue);	242	float result = calculationValue()->evaluate(maxValue, viewportSize);
243	if (std::isnan(result))	243	if (std::isnan(result))
244	return 0;	244	return 0;
245	return result;	245	return result;

Lines 45-51 public: a/Source/WebCore/platform/graphics/GraphicsLayerAnimation.h_sec1
- a/Source/WebCore/platform/graphics/GraphicsLayerAnimation.h -3 / +3 lines
45	: m_keyframes(AnimatedPropertyInvalid)	45	: m_keyframes(AnimatedPropertyInvalid)
46	{ }	46	{ }
47	GraphicsLayerAnimation(const String&, const KeyframeValueList&, const IntSize&, const Animation*, double, bool);	47	GraphicsLayerAnimation(const String&, const KeyframeValueList&, const IntSize&, const Animation*, double, bool);
48	void apply(Client*);	48	void apply(Client*, const IntSize& viewportSize);
49	void pause(double);	49	void pause(double);
50	void resume();	50	void resume();
51	double computeTotalRunningTime();	51	double computeTotalRunningTime();
Lines 66-72 public: a/Source/WebCore/platform/graphics/GraphicsLayerAnimation.h_sec2
66	bool listsMatch() const { return m_listsMatch; }	66	bool listsMatch() const { return m_listsMatch; }
67		67
68	private:	68	private:
69	void applyInternal(Client, const AnimationValue from, const AnimationValue* to, float progress);	69	void applyInternal(Client, const AnimationValue from, const AnimationValue* to, float progress, const IntSize& viewportSize);
70	KeyframeValueList m_keyframes;	70	KeyframeValueList m_keyframes;
71	IntSize m_boxSize;	71	IntSize m_boxSize;
72	RefPtr<Animation> m_animation;	72	RefPtr<Animation> m_animation;
Lines 89-95 public: a/Source/WebCore/platform/graphics/GraphicsLayerAnimation.h_sec3
89	void pause(const String&, double);	89	void pause(const String&, double);
90	void suspend(double);	90	void suspend(double);
91	void resume();	91	void resume();
92	void apply(GraphicsLayerAnimation::Client*);	92	void apply(GraphicsLayerAnimation::Client*, const IntSize& viewportSize);
93	bool isEmpty() const { return m_animations.isEmpty(); }	93	bool isEmpty() const { return m_animations.isEmpty(); }
94	size_t size() const { return m_animations.size(); }	94	size_t size() const { return m_animations.size(); }
95	const Vector<GraphicsLayerAnimation>& animations() const { return m_animations; }	95	const Vector<GraphicsLayerAnimation>& animations() const { return m_animations; }

Lines 42-47 namespace WebCore { a/Source/WebCore/platform/graphics/chromium/AnimationTranslationUtil.h_sec1
- a/Source/WebCore/platform/graphics/chromium/AnimationTranslationUtil.h -1 / +2 lines
42	class KeyframeValueList;	42	class KeyframeValueList;
43	class Animation;	43	class Animation;
44	class FloatSize;	44	class FloatSize;
		45	class IntSize;
45		46
46		47
47	// Translates WebCore animation data into a WebAnimation. If we are unable	48	// Translates WebCore animation data into a WebAnimation. If we are unable
Lines 49-55 class FloatSize; a/Source/WebCore/platform/graphics/chromium/AnimationTranslationUtil.h_sec2
49	// - a steps timing function is used,	50	// - a steps timing function is used,
50	// - a property other than AnimatedPropertyWebkitTransform, or AnimatedPropertyOpacity is animated, or	51	// - a property other than AnimatedPropertyWebkitTransform, or AnimatedPropertyOpacity is animated, or
51	// - a transform animation involves a non-invertable transform.	52	// - a transform animation involves a non-invertable transform.
52	PassOwnPtr<WebKit::WebAnimation> createWebAnimation(const KeyframeValueList&, const Animation*, int animationId, double timeOffset, const FloatSize& boxSize);	53	PassOwnPtr<WebKit::WebAnimation> createWebAnimation(const KeyframeValueList&, const Animation*, int animationId, double timeOffset, const FloatSize& boxSize, const IntSize& viewportSize);
53		54
54	} // namespace WebCore	55	} // namespace WebCore
55		56

Lines 582-588 void GraphicsLayerChromium::setContentsTo(ContentsLayerPurpose purpose, WebLayer a/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.cpp_sec1
- a/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.cpp -2 / +2 lines
582	updateChildList();	582	updateChildList();
583	}	583	}
584		584
585	bool GraphicsLayerChromium::addAnimation(const KeyframeValueList& values, const IntSize& boxSize, const Animation* animation, const String& animationName, double timeOffset)	585	bool GraphicsLayerChromium::addAnimation(const KeyframeValueList& values, const IntSize& boxSize, const IntSize& viewportSize, const Animation* animation, const String& animationName, double timeOffset)
586	{	586	{
587	platformLayer()->setAnimationDelegate(this);	587	platformLayer()->setAnimationDelegate(this);
588		588
Lines 591-597 bool GraphicsLayerChromium::addAnimation(const KeyframeValueList& values, const a/Source/WebCore/platform/graphics/chromium/GraphicsLayerChromium.cpp_sec2
591	if (m_animationIdMap.contains(animationName))	591	if (m_animationIdMap.contains(animationName))
592	animationId = m_animationIdMap.get(animationName);	592	animationId = m_animationIdMap.get(animationName);
593		593
594	OwnPtr<WebAnimation> toAdd(createWebAnimation(values, animation, animationId, timeOffset, boxSize));	594	OwnPtr<WebAnimation> toAdd(createWebAnimation(values, animation, animationId, timeOffset, boxSize, viewportSize));
595		595
596	if (toAdd) {	596	if (toAdd) {
597	animationId = toAdd->id();	597	animationId = toAdd->id();

Lines 54-60 CustomFilterOperation::~CustomFilterOperation() a/Source/WebCore/platform/graphics/filters/CustomFilterOperation.cpp_sec1
- a/Source/WebCore/platform/graphics/filters/CustomFilterOperation.cpp -2 / +2 lines
54	{	54	{
55	}	55	}
56		56
57	PassRefPtr<FilterOperation> CustomFilterOperation::blend(const FilterOperation* from, double progress, const LayoutSize& size, bool blendToPassthrough)	57	PassRefPtr<FilterOperation> CustomFilterOperation::blend(const FilterOperation* from, double progress, const LayoutSize& size, const IntSize& viewportSize, bool blendToPassthrough)
58	{	58	{
59	// FIXME: There's no way to decide what is the "passthrough filter" for shaders using the current CSS Syntax.	59	// FIXME: There's no way to decide what is the "passthrough filter" for shaders using the current CSS Syntax.
60	// https://bugs.webkit.org/show_bug.cgi?id=84903	60	// https://bugs.webkit.org/show_bug.cgi?id=84903
Lines 70-76 PassRefPtr<FilterOperation> CustomFilterOperation::blend(const FilterOperation* a/Source/WebCore/platform/graphics/filters/CustomFilterOperation.cpp_sec2
70	return this;	70	return this;
71		71
72	CustomFilterParameterList animatedParameters;	72	CustomFilterParameterList animatedParameters;
73	m_parameters.blend(fromOp->m_parameters, progress, size, animatedParameters);	73	m_parameters.blend(fromOp->m_parameters, progress, size, viewportSize, animatedParameters);
74	return CustomFilterOperation::create(m_program, animatedParameters, m_meshRows, m_meshColumns, m_meshType);	74	return CustomFilterOperation::create(m_program, animatedParameters, m_meshRows, m_meshColumns, m_meshType);
75	}	75	}
76		76

Lines 69-75 bool CustomFilterParameterList::checkAlphabeticalOrder() const a/Source/WebCore/platform/graphics/filters/CustomFilterParameterList.cpp_sec1
- a/Source/WebCore/platform/graphics/filters/CustomFilterParameterList.cpp -2 / +2 lines
69	}	69	}
70		70
71	void CustomFilterParameterList::blend(const CustomFilterParameterList& fromList,	71	void CustomFilterParameterList::blend(const CustomFilterParameterList& fromList,
72	double progress, const LayoutSize& frameSize, CustomFilterParameterList& resultList) const	72	double progress, const LayoutSize& frameSize, const IntSize& viewportSize, CustomFilterParameterList& resultList) const
73	{	73	{
74	// This method expects both lists to be sorted by parameter name and the result list is also sorted.	74	// This method expects both lists to be sorted by parameter name and the result list is also sorted.
75	ASSERT(checkAlphabeticalOrder());	75	ASSERT(checkAlphabeticalOrder());
Lines 79-85 void CustomFilterParameterList::blend(const CustomFilterParameterList& fromList, a/Source/WebCore/platform/graphics/filters/CustomFilterParameterList.cpp_sec2
79	CustomFilterParameter* paramFrom = fromList.at(fromListIndex).get();	79	CustomFilterParameter* paramFrom = fromList.at(fromListIndex).get();
80	CustomFilterParameter* paramTo = at(toListIndex).get();	80	CustomFilterParameter* paramTo = at(toListIndex).get();
81	if (paramFrom->name() == paramTo->name()) {	81	if (paramFrom->name() == paramTo->name()) {
82	resultList.append(paramTo->blend(paramFrom, progress, frameSize));	82	resultList.append(paramTo->blend(paramFrom, progress, frameSize, viewportSize));
83	++fromListIndex;	83	++fromListIndex;
84	++toListIndex;	84	++toListIndex;
85	continue;	85	continue;

Lines 47-53 public: a/Source/WebCore/platform/graphics/filters/CustomFilterTransformParameter.h_sec1
- a/Source/WebCore/platform/graphics/filters/CustomFilterTransformParameter.h -4 / +4 lines
47	return adoptRef(new CustomFilterTransformParameter(name));	47	return adoptRef(new CustomFilterTransformParameter(name));
48	}	48	}
49		49
50	virtual PassRefPtr<CustomFilterParameter> blend(const CustomFilterParameter* fromParameter, double progress, const LayoutSize& size)	50	virtual PassRefPtr<CustomFilterParameter> blend(const CustomFilterParameter* fromParameter, double progress, const LayoutSize& size, const IntSize& viewportSize)
51	{	51	{
52	if (!fromParameter \|\| !isSameType(*fromParameter))	52	if (!fromParameter \|\| !isSameType(*fromParameter))
53	return this;	53	return this;
Lines 60-66 public: a/Source/WebCore/platform/graphics/filters/CustomFilterTransformParameter.h_sec2
60		60
61	RefPtr<CustomFilterTransformParameter> result = CustomFilterTransformParameter::create(name());	61	RefPtr<CustomFilterTransformParameter> result = CustomFilterTransformParameter::create(name());
62	if (from.size() && to.size())	62	if (from.size() && to.size())
63	result->setOperations(to.blend(from, progress, size));	63	result->setOperations(to.blend(from, progress, size, viewportSize));
64	else	64	else
65	result->setOperations(progress > 0.5 ? to : from);	65	result->setOperations(progress > 0.5 ? to : from);
66	return result;	66	return result;
Lines 74-83 public: a/Source/WebCore/platform/graphics/filters/CustomFilterTransformParameter.h_sec3
74	return m_operations == other->m_operations;	74	return m_operations == other->m_operations;
75	}	75	}
76		76
77	void applyTransform(TransformationMatrix& transform, const FloatSize& boxSize) const	77	void applyTransform(TransformationMatrix& transform, const FloatSize& boxSize, const IntSize& viewportSize) const
78	{	78	{
79	for (unsigned i = 0, size = m_operations.size(); i < size; ++i)	79	for (unsigned i = 0, size = m_operations.size(); i < size; ++i)
80	m_operations.at(i)->apply(transform, boxSize);	80	m_operations.at(i)->apply(transform, boxSize, viewportSize);
81	}	81	}
82		82
83	const TransformOperations& operations() const { return m_operations; }	83	const TransformOperations& operations() const { return m_operations; }

Lines 46-57 private: a/Source/WebCore/platform/graphics/transforms/IdentityTransformOperation.h_sec1
- a/Source/WebCore/platform/graphics/transforms/IdentityTransformOperation.h -2 / +2 lines
46	return isSameType(o);	46	return isSameType(o);
47	}	47	}
48		48
49	virtual bool apply(TransformationMatrix&, const FloatSize&) const	49	virtual bool apply(TransformationMatrix&, const FloatSize&, const IntSize&) const
50	{	50	{
51	return false;	51	return false;
52	}	52	}
53		53
54	virtual PassRefPtr<TransformOperation> blend(const TransformOperation*, double, bool = false)	54	virtual PassRefPtr<TransformOperation> blend(const TransformOperation*, double, const IntSize&, bool = false)
55	{	55	{
56	return this;	56	return this;
57	}	57	}

Lines 53-65 private: a/Source/WebCore/platform/graphics/transforms/Matrix3DTransformOperation.h_sec1
- a/Source/WebCore/platform/graphics/transforms/Matrix3DTransformOperation.h -2 / +2 lines
53	return m_matrix == m->m_matrix;	53	return m_matrix == m->m_matrix;
54	}	54	}
55		55
56	virtual bool apply(TransformationMatrix& transform, const FloatSize&) const	56	virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize&) const
57	{	57	{
58	transform.multiply(TransformationMatrix(m_matrix));	58	transform.multiply(TransformationMatrix(m_matrix));
59	return false;	59	return false;
60	}	60	}
61		61
62	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, bool blendToIdentity = false);	62	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);
63		63
64	Matrix3DTransformOperation(const TransformationMatrix& mat)	64	Matrix3DTransformOperation(const TransformationMatrix& mat)
65	{	65	{

Lines 59-72 private: a/Source/WebCore/platform/graphics/transforms/MatrixTransformOperation.h_sec1
- a/Source/WebCore/platform/graphics/transforms/MatrixTransformOperation.h -2 / +2 lines
59	return m_a == m->m_a && m_b == m->m_b && m_c == m->m_c && m_d == m->m_d && m_e == m->m_e && m_f == m->m_f;	59	return m_a == m->m_a && m_b == m->m_b && m_c == m->m_c && m_d == m->m_d && m_e == m->m_e && m_f == m->m_f;
60	}	60	}
61		61
62	virtual bool apply(TransformationMatrix& transform, const FloatSize&) const	62	virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize&) const
63	{	63	{
64	TransformationMatrix matrix(m_a, m_b, m_c, m_d, m_e, m_f);	64	TransformationMatrix matrix(m_a, m_b, m_c, m_d, m_e, m_f);
65	transform.multiply(matrix);	65	transform.multiply(matrix);
66	return false;	66	return false;
67	}	67	}
68		68
69	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, bool blendToIdentity = false);	69	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);
70		70
71	MatrixTransformOperation(double a, double b, double c, double d, double e, double f)	71	MatrixTransformOperation(double a, double b, double c, double d, double e, double f)
72	: m_a(a)	72	: m_a(a)

Lines 42-48 public: a/Source/WebCore/platform/graphics/transforms/PerspectiveTransformOperation.h_sec1
- a/Source/WebCore/platform/graphics/transforms/PerspectiveTransformOperation.h -4 / +4 lines
42	Length perspective() const { return m_p; }	42	Length perspective() const { return m_p; }
43		43
44	private:	44	private:
45	virtual bool isIdentity() const { return !floatValueForLength(m_p, 1); }	45	virtual bool isIdentity() const { return !floatValueForLength(m_p, 1, IntSize(1, 1)); }
46	virtual OperationType getOperationType() const { return PERSPECTIVE; }	46	virtual OperationType getOperationType() const { return PERSPECTIVE; }
47	virtual bool isSameType(const TransformOperation& o) const { return o.getOperationType() == PERSPECTIVE; }	47	virtual bool isSameType(const TransformOperation& o) const { return o.getOperationType() == PERSPECTIVE; }
48		48
Lines 54-66 private: a/Source/WebCore/platform/graphics/transforms/PerspectiveTransformOperation.h_sec2
54	return m_p == p->m_p;	54	return m_p == p->m_p;
55	}	55	}
56		56
57	virtual bool apply(TransformationMatrix& transform, const FloatSize&) const	57	virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize& viewportSize) const
58	{	58	{
59	transform.applyPerspective(floatValueForLength(m_p, 1));	59	transform.applyPerspective(floatValueForLength(m_p, 1, viewportSize));
60	return false;	60	return false;
61	}	61	}
62		62
63	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, bool blendToIdentity = false);	63	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);
64		64
65	PerspectiveTransformOperation(const Length& p)	65	PerspectiveTransformOperation(const Length& p)
66	: m_p(p)	66	: m_p(p)

Lines 60-72 private: a/Source/WebCore/platform/graphics/transforms/RotateTransformOperation.h_sec1
- a/Source/WebCore/platform/graphics/transforms/RotateTransformOperation.h -2 / +2 lines
60	return m_x == r->m_x && m_y == r->m_y && m_z == r->m_z && m_angle == r->m_angle;	60	return m_x == r->m_x && m_y == r->m_y && m_z == r->m_z && m_angle == r->m_angle;
61	}	61	}
62		62
63	virtual bool apply(TransformationMatrix& transform, const FloatSize& /borderBoxSize/) const	63	virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize&) const
64	{	64	{
65	transform.rotate3d(m_x, m_y, m_z, m_angle);	65	transform.rotate3d(m_x, m_y, m_z, m_angle);
66	return false;	66	return false;
67	}	67	}
68		68
69	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, bool blendToIdentity = false);	69	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);
70		70
71	RotateTransformOperation(double x, double y, double z, double angle, OperationType type)	71	RotateTransformOperation(double x, double y, double z, double angle, OperationType type)
72	: m_x(x)	72	: m_x(x)

Lines 59-71 private: a/Source/WebCore/platform/graphics/transforms/ScaleTransformOperation.h_sec1
- a/Source/WebCore/platform/graphics/transforms/ScaleTransformOperation.h -2 / +2 lines
59	return m_x == s->m_x && m_y == s->m_y && m_z == s->m_z;	59	return m_x == s->m_x && m_y == s->m_y && m_z == s->m_z;
60	}	60	}
61		61
62	virtual bool apply(TransformationMatrix& transform, const FloatSize&) const	62	virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize&) const
63	{	63	{
64	transform.scale3d(m_x, m_y, m_z);	64	transform.scale3d(m_x, m_y, m_z);
65	return false;	65	return false;
66	}	66	}
67		67
68	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, bool blendToIdentity = false);	68	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);
69		69
70	ScaleTransformOperation(double sx, double sy, double sz, OperationType type)	70	ScaleTransformOperation(double sx, double sy, double sz, OperationType type)
71	: m_x(sx)	71	: m_x(sx)

Lines 52-64 private: a/Source/WebCore/platform/graphics/transforms/SkewTransformOperation.h_sec1
- a/Source/WebCore/platform/graphics/transforms/SkewTransformOperation.h -2 / +2 lines
52	return m_angleX == s->m_angleX && m_angleY == s->m_angleY;	52	return m_angleX == s->m_angleX && m_angleY == s->m_angleY;
53	}	53	}
54		54
55	virtual bool apply(TransformationMatrix& transform, const FloatSize&) const	55	virtual bool apply(TransformationMatrix& transform, const FloatSize&, const IntSize&) const
56	{	56	{
57	transform.skew(m_angleX, m_angleY);	57	transform.skew(m_angleX, m_angleY);
58	return false;	58	return false;
59	}	59	}
60		60
61	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, bool blendToIdentity = false);	61	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false);
62		62
63	SkewTransformOperation(double angleX, double angleY, OperationType type)	63	SkewTransformOperation(double angleX, double angleY, OperationType type)
64	: m_angleX(angleX)	64	: m_angleX(angleX)

Lines 59-67 public: a/Source/WebCore/platform/graphics/transforms/TransformOperation.h_sec1
- a/Source/WebCore/platform/graphics/transforms/TransformOperation.h -2 / +2 lines
59	virtual bool isIdentity() const = 0;	59	virtual bool isIdentity() const = 0;
60		60
61	// Return true if the borderBoxSize was used in the computation, false otherwise.	61	// Return true if the borderBoxSize was used in the computation, false otherwise.
62	virtual bool apply(TransformationMatrix&, const FloatSize& borderBoxSize) const = 0;	62	virtual bool apply(TransformationMatrix&, const FloatSize& borderBoxSize, const IntSize& viewportSize) const = 0;
63		63
64	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, bool blendToIdentity = false) = 0;	64	virtual PassRefPtr<TransformOperation> blend(const TransformOperation* from, double progress, const IntSize& viewportSize, bool blendToIdentity = false) = 0;
65		65
66	virtual OperationType getOperationType() const = 0;	66	virtual OperationType getOperationType() const = 0;
67	virtual bool isSameType(const TransformOperation&) const { return false; }	67	virtual bool isSameType(const TransformOperation&) const { return false; }